# Sandbox

> [!NOTE]
> L'API Sandbox est expérimentale. Son API et son comportement peuvent changer sans préavis. Les sandboxes partagées sont destinées aux charges de travail au sein de la même frontière de confiance ; utilisez des sandboxes dédiées pour les charges de travail qui ne se font pas confiance mutuellement.

Consultez le [guide des Sandboxes](../guides/sandbox) pour apprendre à les utiliser.

## Sandbox[[huggingface_hub.Sandbox]]

#### huggingface_hub.Sandbox[[huggingface_hub.Sandbox]]

```python
huggingface_hub.Sandbox(id: str, server: _SandboxServer, local_id: str | None, owns_sandbox: bool, owns_server: bool, sandbox_token: str | None = None)
```

[Source](https://github.com/huggingface/huggingface_hub/blob/v2.4.0/src/huggingface_hub/_sandbox.py#L783)

Une machine cloud isolée exécutée sur Hugging Face Jobs.

> [!NOTE]
> L'API Sandbox est expérimentale. Son API et son comportement peuvent changer sans préavis.

Créez-en une dédiée avec [Sandbox.create()](/docs/huggingface_hub/v2.4.0/fr/package_reference/sandbox#huggingface_hub.Sandbox.create) (un job par sandbox) ou obtenez-en beaucoup, peu coûteuses et partagées, à partir d’un [SandboxPool](/docs/huggingface_hub/v2.4.0/fr/package_reference/sandbox#huggingface_hub.SandboxPool).

Reconnectez-vous à un bac à sable en cours d’exécution depuis n’importe où avec [Sandbox.connect()](/docs/huggingface_hub/v2.4.0/fr/package_reference/sandbox#huggingface_hub.Sandbox.connect). Utilisez-le comme gestionnaire de contexte pour le terminer à la sortie :

```python
>>> from huggingface_hub import Sandbox
>>> with Sandbox.create(image="python:3.12") as sbx:
...     print(sbx.run("python --version").stdout)
```

#### fermer[[huggingface_hub.Sandbox.close]]

```python
close()
```

[Source](https://github.com/huggingface/huggingface_hub/blob/v2.4.0/src/huggingface_hub/_sandbox.py#L1028)

Libérez le client HTTP local sans mettre fin au bac à sable. Idempotent.

Aucune opération pour les sandbox de pool (le client appartient à l'hôte du pool).

#### connect[[huggingface_hub.Sandbox.connect]]

```python
connect(sandbox_id: str, namespace: str | None = None, token: str | None = None)
```

[Source](https://github.com/huggingface/huggingface_hub/blob/v2.4.0/src/huggingface_hub/_sandbox.py#L952)

Reconnectez-vous à un bac à sable en cours d’exécution depuis n’importe où, en utilisant uniquement son identifiant.

#### create[[huggingface_hub.Sandbox.create]]

```python
create(image: str = 'python:3.12', flavor: str = 'cpu-basic', idle_timeout: int | float | str | None = 600, env: dict[str, typing.Any] | None = None, secrets: dict[str, typing.Any] | None = None, volumes: typing.Optional[typing.List[huggingface_hub._space_api.Volume]] = None, namespace: str | None = None, forward_hf_token: bool = False, labels: dict[str, str] | None = None, start_timeout: float = 120.0, token: str | None = None)
```

[Source](https://github.com/huggingface/huggingface_hub/blob/v2.4.0/src/huggingface_hub/_sandbox.py#L835)

**Paramètres :**

image (`str`, *facultatif*, par défaut `"python --3.12"`) : toute image Docker avec `/bin/sh` (Docker Hub ou `hf.co/spaces/...`).

flavor (`str`, *facultatif*, par défaut `"cpu-basic"`) : Type de matériel, par exemple `"cpu-basic"`, `"a10g-small"`. Voir `hf jobs hardware`.

idle_timeout (`int` ou `float` ou `str`, *facultatif*, par défaut `600`) : arrêt automatique après cette durée d'inactivité (aucun appel API, aucun processus en cours). La valeur par défaut est de 10 minutes ; passez `None` pour désactiver cette fonction. Notez qu'une commande *foreground* n'est actuellement pas comptée comme une activité, de sorte qu'un seul `run()` qui prend plus de temps que cette durée, sans autre trafic API, peut voir son sandbox fermé sous lui — augmentez le délai d'attente (ou passez `None`) pour les commandes uniques de longue durée.

env (`dict[str, Any]`, *facultatif*) : Variables d'environnement disponibles dans le bac à sable.

secrets (`dict[str, Any]`, *facultatif*) : Variables d'environnement secrètes (chiffrées côté serveur).

volumes (`List[Volume]`, *facultatif*) : dépôts/bacs HF à monter, voir [Volume](/docs/huggingface_hub/v2.4.0/fr/package_reference/jobs#huggingface_hub.Volume).

namespace (`str`, *facultatif*) : Espace de nommage utilisateur ou organisation sous lequel exécuter (par défaut, l'utilisateur actuel).

forward_hf_token (`bool`, *facultatif*, valeur par défaut `False`) : Si True, votre jeton HF est injecté en tant que `HF_TOKEN` (opt-in).

labels (`dict[str, str]`, *facultatif*) : Étiquettes à associer au Job HF sous-jacent.

start_timeout (`float`, *facultatif*, valeur par défaut `120.0`) : Nombre maximal de secondes à attendre pour que le bac à sable soit prêt.

token (`str`, *facultatif*) : remplacement du jeton HF.

Créez un bac à sable dédié (un Job HF) et bloquez jusqu'à ce qu'il soit prêt (~7 s sur cpu-basic).

Chaque bac à sable est une VM isolée complète, ce qui en fait le bon choix pour les charges de travail GPU ou le code non fiable. Pour déployer de nombreux bacs à sable CPU peu coûteux, utilisez plutôt [SandboxPool](/docs/huggingface_hub/v2.4.0/fr/package_reference/sandbox#huggingface_hub.SandboxPool).

Le job s'exécute avec une durée de vie maximale fixe de 24 h ; `idle_timeout` est le véritable gardien — un bac à sable inactif se ferme bien avant cela.

L’image n’a besoin que de `/bin/sh`. Le serveur sandbox est téléchargé au démarrage avec `wget`/`curl` si disponible, sinon lu depuis un bucket de serveur toujours monté (ce qui ajoute ~2-3 s au démarrage à froid, donc inclure `wget`/`curl` le maintient rapide).

#### processus[[huggingface_hub.Sandbox.processes]]

```python
processes()
```

[Source](https://github.com/huggingface/huggingface_hub/blob/v2.4.0/src/huggingface_hub/_sandbox.py#L1202)

Listez les processus en arrière-plan de cette sandbox.

Retourne les processus démarrés avec [Sandbox.run()](/docs/huggingface_hub/v2.4.0/fr/package_reference/sandbox#huggingface_hub.Sandbox.run)`(..., background=True)` ; arrêtez-en un avec [SandboxProcess.kill()](/docs/huggingface_hub/v2.4.0/fr/package_reference/sandbox#huggingface_hub.SandboxProcess.kill). Les processus récemment terminés restent listés (avec `running=False` et leur `exit_code`) ; le serveur conserve un nombre limité de ces processus, de sorte qu’un sandbox ayant exécuté des milliers de commandes courtes ne les listera pas tous.

#### proxy_url_for[[huggingface_hub.Sandbox.proxy_url_for]]

```python
proxy_url_for(port: int | str, path: str = '/', scheme: str = 'https://')
```

[Source](https://github.com/huggingface/huggingface_hub/blob/v2.4.0/src/huggingface_hub/_sandbox.py#L1238)

**Paramètres :**

port (`int` ou `str`) : le port (pool : le `<port>` du socket unix) sur lequel le serveur interne écoute.

path (`str`, *facultatif*, par défaut `"/"`) : Chemin sur le serveur interne à cibler, par exemple `"/ws"`.

scheme (`str`, *facultatif*, par défaut `"https --//"`) : schéma d'URL à utiliser pour construire le lien. Par défaut, `"https://"` ; passez `"wss://"` pour un client WebSocket (le proxy est indépendant du protocole, seul le schéma côté client change).

**Retourne :** `str`

une URL de la forme `https://<job_id>--49983.hf.jobs/v1/.../proxy/8000/ws` (ou `wss://...` avec `scheme="wss://"`).

URL publique qui effectue un proxy vers un serveur exécuté *à l'intérieur* de cette sandbox.

Les requêtes envoyées à l’URL renvoyée sont transmises par le serveur sandbox du job vers un serveur que vous avez démarré dans le sandbox sur le `port`, y compris les mises à niveau WebSocket (`ws(s)://`) et les réponses en streaming. Associez-le à `proxy_headers` pour l’authentification.

Comment le bac à sable doit écouter sur le `port` :

- **Pool / bac à sable partagé** : il ne peut pas lier un port TCP (Landlock), il faut donc lier un **socket unix** à `$SBX_PROXY_DIR/<port>.sock` (la variable d’environnement `SBX_PROXY_DIR` est définie dans chaque bac à sable). Par exemple, `uvicorn app:app --uds $SBX_PROXY_DIR/8000.sock`.
- **Sandbox dédié** : liez un port TCP standard sur `127.0.0.1:<port>`. (Vous pouvez également exposer le port directement via le proxy du job, sans passer par ici.)

Exemple :
```python
>>> url = sandbox.proxy_url_for(8000, "/ws", scheme="wss://")
>>> import websockets
>>> async with websockets.connect(url, additional_headers=sandbox.proxy_headers) as ws:
...     await ws.send("hello")
```

#### run[[huggingface_hub.Sandbox.run]]

```python
run(cmd: typing.Union[str, typing.List[str]], shell: bool | None = None, env: dict[str, typing.Any] | None = None, cwd: str | None = None, timeout: float | None = None, stdin: str | None = None, on_stdout: typing.Optional[typing.Callable[[str], NoneType]] = None, on_stderr: typing.Optional[typing.Callable[[str], NoneType]] = None, check: bool = True, capture_output: bool = True, background: bool = False)
```

[Source](https://github.com/huggingface/huggingface_hub/blob/v2.4.0/src/huggingface_hub/_sandbox.py#L1075)

**Paramètres :**

cmd (`str` ou `List[str]`) : une chaîne de commande shell (exécutée avec `/bin/sh -c`) ou une liste argv (exécutée directement).

shell (`bool`, *facultatif*) : Force le mode d'exécution au lieu de le déduire du type de `cmd`. `True` exécute via `/bin/sh -c` et exige que `cmd` soit une chaîne de caractères ; `False` exécute `cmd` directement et exige qu'il s'agisse d'une liste argv. `None` (par défaut) déduit le mode à partir du type. Définissez-le explicitement pour éviter les pièges liés au type (par exemple, `["echo hi"]` exécuté comme un seul programme nommé `"echo hi"`).

env (`dict[str, Any]`, *facultatif*) : Variables d'environnement supplémentaires pour cette commande.

cwd (`str`, *facultatif*) : Répertoire de travail.

timeout (`float`, *facultatif*) : Tuer la commande (groupe de processus entier) après ce nombre de secondes.

stdin (`str`, *facultatif*) : Données à écrire dans l'entrée standard (stdin) de la commande.

on_stdout (`Callable[[str], None]`, *facultatif*) : Callback appelé avec les fragments de stdout à mesure qu'ils arrivent.

on_stderr (`Callable[[str], None]`, *facultatif*) : Callback appelé avec les fragments de stderr à mesure qu'ils arrivent.

check (`bool`, *facultatif*, valeur par défaut `True`) : Si True, lève `SandboxCommandError` en cas de code de sortie non nul.

capture_output (`bool`, *facultatif*, valeur par défaut `True`) : Si True, accumule stdout/stderr dans le résultat renvoyé. Passez `False` si vous ne souhaitez que `on_stdout`/`on_stderr` : la sortie est alors transmise aux callbacks et ignorée, de sorte qu'une commande produisant des gigaoctets n'a pas besoin de tenir en mémoire. `result.stdout`/`result.stderr` sont vides dans ce cas.

background (`bool`, *facultatif*, valeur par défaut `False`) : Si True, démarre la commande en mode détaché et renvoie immédiatement un [SandboxProcess](/docs/huggingface_hub/v2.4.0/fr/package_reference/sandbox#huggingface_hub.SandboxProcess) au lieu d'attendre et de renvoyer un [SandboxCommandResult](/docs/huggingface_hub/v2.4.0/fr/package_reference/sandbox#huggingface_hub.SandboxCommandResult).

Exécuter une commande dans le bac à sable et attendre sa fin, en diffusant la sortie en direct.

Avec `background=True`, la commande est lancée en tâche détachée et `run` renvoie immédiatement un [SandboxProcess](/docs/huggingface_hub/v2.4.0/fr/package_reference/sandbox#huggingface_hub.SandboxProcess), sans attendre sa fin — pratique pour les serveurs et autres processus de longue durée. Vous pouvez les lister plus tard avec [Sandbox.processes()](/docs/huggingface_hub/v2.4.0/fr/package_reference/sandbox#huggingface_hub.Sandbox.processes) et en arrêter un avec [SandboxProcess.kill()](/docs/huggingface_hub/v2.4.0/fr/package_reference/sandbox#huggingface_hub.SandboxProcess.kill). Les options de streaming/attente uniquement (`timeout`, `stdin`, `on_stdout`, `on_stderr`, `check`) ne s’appliquent pas dans ce mode.

Retourne : un [SandboxCommandResult](/docs/huggingface_hub/v2.4.0/fr/package_reference/sandbox#huggingface_hub.SandboxCommandResult) (avec `exit_code`, `stdout`, `stderr`, `duration_ms`), ou un [SandboxProcess](/docs/huggingface_hub/v2.4.0/fr/package_reference/sandbox#huggingface_hub.SandboxProcess) lorsque `background=True`.

## SandboxPool[[huggingface_hub.SandboxPool]]

#### huggingface_hub.SandboxPool[[huggingface_hub.SandboxPool]]

```python
huggingface_hub.SandboxPool(image: str = 'python:3.12', flavor: str = 'cpu-basic', sandboxes_per_host: int = 50, warm_up: int = 1, max_hosts: int | None = None, name: str | None = None, idle_timeout: int | float | str | None = 600, namespace: str | None = None, start_timeout: float = 120.0, adopt_hosts: str = 'own', token: str | None = None, _connect_mode: bool = False)
```

[Source](https://github.com/huggingface/huggingface_hub/blob/v2.4.0/src/huggingface_hub/_sandbox.py#L1313)

Une flotte de tâches « host » partagées, chacune regroupant de nombreux sandboxes isolés par landlock.

> [!WARNING]
> L'API Sandbox est expérimentale. Son API et son comportement peuvent changer sans préavis.
>
> **Les sandbox mutualisées sont destinées aux charges de travail au sein d'une même frontière de confiance.** Une sandbox mutualisée est un uid associé à un ensemble de règles Landlock au sein d'une VM partagée — et non d'une VM dédiée — et toutes les sandbox d'un hôte partagent le jeton d'authentification de cet hôte ainsi que son plan de contrôle privilégié. Utilisez un pool pour déployer à moindre coût *votre propre* code. Pour des charges de travail mutuellement méfiantes, utilisez [Sandbox.create()](/docs/huggingface_hub/v2.4.0/fr/package_reference/sandbox#huggingface_hub.Sandbox.create), qui attribue à chacune sa propre VM. Les lacunes spécifiques sont répertoriées sous « Limitations connues » dans le guide conceptuel des sandbox.

Un hôte correspond à un Job HF facturé (une VM) ; il exécute le serveur de sandbox et multiplexe jusqu'à `sandboxes_per_host` sandboxes légères, isolées les unes des autres par uid + le Landlock LSM. Cela rend les déploiements à grande échelle peu coûteux (le coût de la VM est partagé entre toutes ses sandboxes) et rapides (la création d'une sandbox représente environ un aller-retour proxy une fois l'hôte chaud). Idéal pour de nombreuses sandboxes CPU parallèles, telles que les rollouts RL ; pour le GPU ou une isolation au niveau VM forte entre des charges de travail mutuellement méfiantes, utilisez plutôt [Sandbox.create()](/docs/huggingface_hub/v2.4.0/fr/package_reference/sandbox#huggingface_hub.Sandbox.create).

Le constructeur pré-alloue `warm_up` hôtes (1 par défaut) et bloque jusqu'à ce qu'ils soient prêts ; les hôtes supplémentaires sont ensuite alloués à la demande au fur et à mesure que des sandboxes sont demandés, et tous

sont démontés lors de l’appel de `close()` (ou en cas d’inactivité, via `idle_timeout`). L’utilisateur ne gère jamais les tâches :

```python
>>> from huggingface_hub import SandboxPool
>>> with SandboxPool(image="python:3.12", flavor="cpu-basic", warm_up=2) as pool:
...     boxes = [pool.create() for _ in range(100)]   # packed across the warm hosts
...     print(boxes[0].run("echo hi").stdout)
hi
```

`create()` crée **une** sandbox à la fois : il réutilise un hôte qui dispose encore de capacité libre avant d’en démarrer un nouveau, de sorte que la capacité augmente à la demande au fur et à mesure que le travail arrive. Pour éviter un démarrage à froid lors des premiers appels, pré-provisionnez des hôtes avec `warm_up` (ou `warm`). Les hôtes chauds sont découverts via les étiquettes de tâche, de sorte que la réutilisation fonctionne également **entre processus** (un nouveau pool avec la même `image`/`flavor`/`name` se connecte à

héberge une exécution antérieure laissée en place) :

```python
>>> pool = SandboxPool(image="python:3.12")
>>> sbx = pool.create()    # finds a warm host (here or in another process), else boots one
```

#### fermer[[huggingface_hub.SandboxPool.close]]

```python
close()
```

[Source](https://github.com/huggingface/huggingface_hub/blob/v2.4.0/src/huggingface_hub/_sandbox.py#L1729)

Libère le pool. Idempotent.

Pour un pool que nous avons créé, cela met fin à tous les jobs hôte (et donc à tous leurs sandboxes). Pour un handle obtenu via `connect()`, cela ne libère que les clients HTTP locaux : les hôtes partagés peuvent servir d'autres clients, donc — comme [Sandbox.connect()](/docs/huggingface_hub/v2.4.0/fr/package_reference/sandbox#huggingface_hub.Sandbox.connect) — quitter un bloc `with` ne doit pas les détruire. Mettez fin explicitement aux hôtes d'un pool connecté avec `hf sandbox pool delete <id>`.

Seuls les hôtes *qui ont démarré* sont annulés. Un hôte découvert via des étiquettes peut servir les boîtes à sable d'un autre processus, il est donc libéré plutôt que terminé.

Lève `SandboxError` si un travail hôte n’a pas pu être annulé, en indiquant les travaux toujours en cours — ils continuent d’être facturés et leurs entrées de cache sont conservées afin de rester découvrables. Lorsque `close()` est atteint via `__exit__` alors qu’une exception est déjà en cours, l’échec est journalisé à la place, afin de ne pas masquer l’erreur d’origine.

#### connect[[huggingface_hub.SandboxPool.connect]]

```python
connect(pool_id: str, namespace: str | None = None, adopt_hosts: str = 'own', token: str | None = None)
```

[Source](https://github.com/huggingface/huggingface_hub/blob/v2.4.0/src/huggingface_hub/_sandbox.py#L1494)

**Paramètres :**

pool_id (`str`) : l'identifiant renvoyé lors de la première création du pool.

namespace (`str`, *facultatif*) : Espace de noms dans lequel rechercher les hôtes du pool (par défaut, le vôtre).

adopt_hosts (`str`, *facultatif*, valeur par défaut `"own"`) : Hôtes auxquels il est possible de se connecter. Voir [SandboxPool](/docs/huggingface_hub/v2.4.0/fr/package_reference/sandbox#huggingface_hub.SandboxPool). La reconnexion à un pool dont les hôtes ont été démarrés par un autre membre de l’espace de noms nécessite `"namespace"`.

token (`str`, *facultatif*) : remplacement du jeton HF.

Se reconnecter à un pool en cours d’exécution par son identifiant, depuis n’importe quelle machine — aucun état local requis.

Recherche un hôte en cours d’exécution étiqueté avec `pool_id` et reconstruit la configuration du pool (image/flavor/density/host-idle) à partir de la spécification et des variables d’environnement du job de cet hôte, en renvoyant un [SandboxPool](/docs/huggingface_hub/v2.4.0/fr/package_reference/sandbox#huggingface_hub.SandboxPool) prêt à `create()` d’autres sandboxes — en les regroupant sur les hôtes en cours d’exécution, ou en démarrant un duplicata (même configuration) lorsque ceux-ci sont pleins.

Lève `SandboxError` si aucun hôte en cours d'exécution n'est trouvé (un pool cesse d'exister dès que tous ses hôtes ont disparu — expiration d'inactivité ou arrêt forcé).

#### create[[huggingface_hub.SandboxPool.create]]

```python
create(env: dict[str, typing.Any] | None = None, idle_timeout: int | float | str | None = 600, forward_hf_token: bool = False)
```

[Source](https://github.com/huggingface/huggingface_hub/blob/v2.4.0/src/huggingface_hub/_sandbox.py#L1591)

**Paramètres :**

env (`dict[str, Any]`, *facultatif*) : Variables d'environnement pour ce bac à sable (chaque bac à sable en possède ses propres).

idle_timeout (`int` ou `float` ou `str`, *facultatif*, par défaut `600`) : Délai d'inactivité par bac à sable — un bac à sable est évacué de son hôte après cette durée d'inactivité (aucun appel API, aucun processus en cours). Distinct du délai d'inactivité de l'hôte. Passez `None` pour le désactiver.

forward_hf_token (`bool`, *facultatif*, valeur par défaut `False`) : Si True, injecte votre jeton HF en tant que `HF_TOKEN` dans le bac à sable (optionnel). Contrairement aux `secrets` d'un bac à sable dédié, l'environnement d'un bac à sable mutualisé est transmis au serveur hôte lors de sa création (il n'est jamais stocké dans le travail hôte), il ne figure donc dans les métadonnées d'aucun travail.

Créez un seul bac à sable, en provisionnant un hôte si nécessaire.

Réutilise un hôte disposant d'une capacité libre (celui de ce pool, ou un hôte chaud trouvé via les étiquettes de tâche / le cache local) avant d'en démarrer un nouveau, de sorte qu'un `create()` sur un hôte chaud coûte environ un aller-retour. Appelez-le de manière répétée pour répartir la charge ; utilisez `warm_up` (ou `warm`) pour pré-provisionner les hôtes et éviter un démarrage à froid lors des premiers appels. Si un hôte se remplit sous nos pieds (un autre processus l'a saturé) ou si un hôte en cache a disparu, le bac à sable est repositionné sur un autre hôte (ou un hôte neuf).

#### chaud[[huggingface_hub.SandboxPool.warm]]

```python
warm(num_hosts: int = 1)
```

[Source](https://github.com/huggingface/huggingface_hub/blob/v2.4.0/src/huggingface_hub/_sandbox.py#L1564)

Vérifiez que `num_hosts` hôte(s) vide(s) sont en cours d'exécution et laissez-les tels quels. Renvoie les identifiants de tâche des hôtes du pool.

Utilisé pour « créer » un pool à l’avance : les hôtes portent l’étiquette et la configuration du pool (dans leurs variables d’environnement), de sorte qu’un appel ultérieur à `SandboxPool.connect(pool_id)` (même depuis une autre machine) les trouve et crée des sandboxes sans démarrage à froid. Les hôtes continuent d’être facturés jusqu’à leur arrêt ou leur inactivité.

Adopte les hôtes déjà en cours d’exécution pour ce pool (trouvés via les étiquettes de tâche) avant le démarrage, de sorte qu’un `warm()` après `connect()` — ou un `warm()` répété — complète jusqu’à `num_hosts` au lieu de dupliquer les hôtes actifs et de dépasser `max_hosts`.

## Structures de données

### SandboxCommandResult[[huggingface_hub.SandboxCommandResult]]

#### huggingface_hub.SandboxCommandResult[[huggingface_hub.SandboxCommandResult]]

```python
huggingface_hub.SandboxCommandResult(exit_code: int | None, stdout: str, stderr: str, signal: int | None = None, timed_out: bool = False, duration_ms: int = 0)
```

[Source](https://github.com/huggingface/huggingface_hub/blob/v2.4.0/src/huggingface_hub/_sandbox.py#L191)

Résultat d'une commande exécutée dans un bac à sable avec [Sandbox.run()](/docs/huggingface_hub/v2.4.0/fr/package_reference/sandbox#huggingface_hub.Sandbox.run).

### SandboxProcess[[huggingface_hub.SandboxProcess]]

#### huggingface_hub.SandboxProcess[[huggingface_hub.SandboxProcess]]

```python
huggingface_hub.SandboxProcess(id: str | None, pid: int, cmd: typing.Union[str, typing.List[str]], _sandbox: Sandbox, tag: str | None = None, started_at_ms: int | None = None, running: bool = True, exit_code: int | None = None)
```

[Source](https://github.com/huggingface/huggingface_hub/blob/v2.4.0/src/huggingface_hub/_sandbox.py#L211)

Un processus en arrière-plan démarré dans un bac à sable avec [Sandbox.run()](/docs/huggingface_hub/v2.4.0/fr/package_reference/sandbox#huggingface_hub.Sandbox.run)`(..., background=True)`.

Listez les processus d'un bac à sable avec [Sandbox.processes()](/docs/huggingface_hub/v2.4.0/fr/package_reference/sandbox#huggingface_hub.Sandbox.processes) et arrêtez-en un avec [SandboxProcess.kill()](/docs/huggingface_hub/v2.4.0/fr/package_reference/sandbox#huggingface_hub.SandboxProcess.kill). Les processus récemment terminés restent dans la liste (le serveur en conserve un nombre limité), de sorte que `running` et `exit_code` indiquent si un processus est toujours actif ou s'il a déjà quitté (au moment où il a été listé).

#### kill[[huggingface_hub.SandboxProcess.kill]]

```python
kill()
```

[Source](https://github.com/huggingface/huggingface_hub/blob/v2.4.0/src/huggingface_hub/_sandbox.py#L235)

Arrêter le processus en arrière-plan. Idempotent.

Indique si cet appel est celui qui l'a arrêtée : `False` signifie qu'elle s'était déjà terminée ou avait été interrompue, ce qui n'est pas une erreur.

Notez qu'un descendant qui se détache via `setsid()` quitte le groupe de processus signalé et survit à cet appel. Supprimez le bac à sable pour vous assurer que tout ce qu'il a démarré a bien été supprimé.

### FileEntry[[huggingface_hub._sandbox.FileEntry]]

#### huggingface_hub._sandbox.FileEntry[[huggingface_hub._sandbox.FileEntry]]

```python
huggingface_hub._sandbox.FileEntry(name: str, path: str, type: typing.Literal['file', 'dir', 'symlink'], size: int, mtime_ms: int | None = None, mode: str = '')
```

[Source](https://github.com/huggingface/huggingface_hub/blob/v2.4.0/src/huggingface_hub/_sandbox.py#L256)

Un fichier ou un répertoire à l'intérieur d'un bac à sable.

## Erreurs

### SandboxError[[huggingface_hub.errors.SandboxError]]

#### huggingface_hub.errors.SandboxError[[huggingface_hub.errors.SandboxError]]

```python
huggingface_hub.errors.SandboxError(message: str, status_code: int | None = None)
```

[Source](https://github.com/huggingface/huggingface_hub/blob/v2.4.0/src/huggingface_hub/errors.py#L598)

**Paramètres :**

status_code : Le statut HTTP renvoyé par le serveur dans le bac à sable, si l'erreur provient d'une réponse d'API (par exemple `404` pour un fichier manquant). `None` sinon.

Exception de base pour les opérations de bac à sable (voir `huggingface_hub.Sandbox`).

### SandboxCommandError[[huggingface_hub.errors.SandboxCommandError]]

#### huggingface_hub.errors.SandboxCommandError[[huggingface_hub.errors.SandboxCommandError]]

```python
huggingface_hub.errors.SandboxCommandError(cmd, result)
```

[Source](https://github.com/huggingface/huggingface_hub/blob/v2.4.0/src/huggingface_hub/errors.py#L611)

**Paramètres :**

cmd : La commande qui a échoué.

result : Le `SandboxCommandResult` complet (exit_code, stdout, stderr, ...).

Lévé lorsqu'une commande exécutée dans un bac à sable se termine avec un code non nul.