# Sandboxes

> [!NOTE]
> La API de Sandbox es experimental. Su API y comportamiento pueden cambiar sin previo aviso. Los sandboxes compartidos están destinados a cargas de trabajo dentro del mismo límite de confianza; use sandboxes dedicados para cargas de trabajo que no se confían entre sí.

Consulta la [guía de Sandboxes](../guides/sandbox) para aprender a usarlos.

## 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)
```

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

Una máquina en la nube aislada que se ejecuta en Hugging Face Jobs.

> [!NOTE]
> La API de Sandbox es experimental. Su API y comportamiento pueden cambiar sin previo aviso.

Crea uno dedicado con [Sandbox.create()](/docs/huggingface_hub/v2.4.0/es/package_reference/sandbox#huggingface_hub.Sandbox.create) (un trabajo por sandbox) o consigue muchos compartidos y económicos de un [SandboxPool](/docs/huggingface_hub/v2.4.0/es/package_reference/sandbox#huggingface_hub.SandboxPool).

Vuelva a conectarse a un sandbox en ejecución desde cualquier lugar con [Sandbox.connect()](/docs/huggingface_hub/v2.4.0/es/package_reference/sandbox#huggingface_hub.Sandbox.connect). Úselo como un gestor de contexto para terminarlo al salir:

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

#### cerrar[[huggingface_hub.Sandbox.close]]

```python
close()
```

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

Liberar el cliente HTTP local sin terminar el sandbox. Idempotente.

Sin efecto para los sandbox de pool (el cliente pertenece al host del pool).

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

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

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

Vuelve a conectar a un sandbox en ejecución desde cualquier lugar, usando solo su id.

#### 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)
```

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

**Parámetros:**

image (`str`, *opcional*, por defecto `"python --3.12"`): Cualquier imagen de Docker con `/bin/sh` (Docker Hub o `hf.co/spaces/...`).

flavor (`str`, *opcional*, valor predeterminado `"cpu-basic"`) : Variante de hardware, p. ej. `"cpu-basic"`, `"a10g-small"`. Consulte `hf jobs hardware`.

idle_timeout (`int` o `float` o `str`, *opcional*, por defecto `600`) : Apagado automático tras este período de inactividad (sin llamadas a la API, sin procesos en ejecución). El valor por defecto es de 10 minutos; pase `None` para desactivarlo. Tenga en cuenta que un comando en *primer plano* no se cuenta actualmente como actividad, por lo que una única llamada a `run()` que dure más de este tiempo sin otro tráfico de API puede provocar que su sandbox se apague — aumente el tiempo de espera (o pase `None`) para comandos únicos de larga duración.

env (`dict[str, Any]`, *opcional*) : Variables de entorno disponibles en el sandbox.

secrets (`dict[str, Any]`, *opcional*) : Variables de entorno secretas (cifradas en el servidor).

volumes (`List[Volume]`, *opcional*) : repositorios/baldes de HF para montar, ver [Volume](/docs/huggingface_hub/v2.4.0/es/package_reference/jobs#huggingface_hub.Volume).

namespace (`str`, *opcional*) : Espacio de nombres de usuario u organización bajo el que se ejecutará (por defecto, el usuario actual).

forward_hf_token (`bool`, *opcional*, valor predeterminado `False`) : Si es True, tu token de HF se inyecta como `HF_TOKEN` (opcional).

labels (`dict[str, str]`, *opcional*) : Etiquetas para adjuntar al trabajo de HF subyacente.

start_timeout (`float`, *opcional*, valor predeterminado `120.0`) : Segundos máximos a esperar para que el sandbox esté listo.

token (`str`, *opcional*) : Sustitución del token de HF.

Cree un sandbox dedicado (un solo HF Job) y bloquee hasta que esté listo (~7 s en cpu-basic).

Cada sandbox es una VM aislada completa, por lo que esta es la opción adecuada para cargas de trabajo de GPU o código no confiable. Para desplegar muchos sandboxes de CPU de bajo costo, use [SandboxPool](/docs/huggingface_hub/v2.4.0/es/package_reference/sandbox#huggingface_hub.SandboxPool).

El trabajo se ejecuta con una vida máxima fija de 24 h; `idle_timeout` es el verdadero responsable: un sandbox inactivo se apaga por sí mismo mucho antes de ese límite.

La imagen solo necesita `/bin/sh`. El servidor de sandbox se descarga al inicio con `wget`/`curl` si está disponible; de lo contrario, se lee desde un bucket de servidor que siempre está montado (lo que añade ~2-3 s al arranque en frío, por lo que incluir `wget`/`curl` mantiene la velocidad).

#### procesos[[huggingface_hub.Sandbox.processes]]

```python
processes()
```

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

Liste los procesos en segundo plano de este sandbox.

Devuelve los procesos iniciados con [Sandbox.run()](/docs/huggingface_hub/v2.4.0/es/package_reference/sandbox#huggingface_hub.Sandbox.run)`(..., background=True)`; detenga uno con [SandboxProcess.kill()](/docs/huggingface_hub/v2.4.0/es/package_reference/sandbox#huggingface_hub.SandboxProcess.kill). Los procesos finalizados recientemente permanecen en la lista (con `running=False` y su `exit_code`); el servidor mantiene un número limitado de ellos, por lo que un sandbox que haya ejecutado miles de comandos cortos no los enumerará todos.

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

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

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

**Parámetros:**

port (`int` o `str`) : El puerto (pool: el `<port>` del socket unix) en el que escucha el servidor interno.

path (`str`, *opcional*, por defecto `"/"`) : Ruta en el servidor interno a la que apuntar, p. ej. `"/ws"`.

scheme (`str`, *opcional*, por defecto `"https --//"`): esquema de URL para construir el enlace. Por defecto es `"https://"`; pase `"wss://"` para un cliente WebSocket (el proxy no depende del protocolo, por lo que solo cambia el esquema del lado del cliente).

**Devuelve:** `str`

una URL como `https://<job_id>--49983.hf.jobs/v1/.../proxy/8000/ws` (o `wss://...` con `scheme="wss://"`).

URL pública que hace de proxy hacia un servidor que se ejecuta *dentro* de este sandbox.

Las solicitudes a la URL devuelta son reenviadas por el servidor de sandbox del trabajo a un servidor que iniciaste en el sandbox en el `port`, incluidas las actualizaciones de WebSocket (`ws(s)://`) y las respuestas en streaming. Combínalo con `proxy_headers` para la autenticación.

Cómo debe escuchar el sandbox en el `port`:

- **Pool / sandbox compartido**: no puede enlazar un puerto TCP (Landlock), por lo que debe enlazar un **socket unix** en `$SBX_PROXY_DIR/<port>.sock` (la variable de entorno `SBX_PROXY_DIR` está definida en cada sandbox). Por ejemplo, `uvicorn app:app --uds $SBX_PROXY_DIR/8000.sock`.
- **Sandbox dedicado**: vincula un puerto TCP normal en `127.0.0.1:<port>`. (También puedes exponer el puerto directamente a través del proxy del trabajo sin pasar por aquí.)

Ejemplo:
```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)
```

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

**Parámetros:**

cmd (`str` o `List[str]`) : Una cadena de comando de shell (ejecutada con `/bin/sh -c`) o una lista argv (ejecutada directamente).

shell (`bool`, *opcional*) : Fuerza el modo de ejecución en lugar de inferirlo a partir del tipo de `cmd`. `True` se ejecuta a través de `/bin/sh -c` y requiere que `cmd` sea una cadena; `False` ejecuta `cmd` directamente y requiere que sea una lista argv. `None` (predeterminado) lo infiere a partir del tipo. Establécelo explícitamente para evitar problemas derivados del tipo (p. ej., que `["echo hi"]` se ejecute como un único programa llamado `"echo hi"`).

env (`dict[str, Any]`, *opcional*) : Variables de entorno adicionales para este comando.

cwd (`str`, *opcional*) : Directorio de trabajo.

timeout (`float`, *opcional*) : Termina el comando (todo el grupo de procesos) después de este número de segundos.

stdin (`str`, *opcional*) : Datos para escribir en la entrada estándar (stdin) del comando.

on_stdout (`Callable[[str], None]`, *opcional*) : Callback que se invoca con los fragmentos de stdout a medida que llegan.

on_stderr (`Callable[[str], None]`, *opcional*) : Callback que se invoca con los fragmentos de stderr a medida que llegan.

check (`bool`, *opcional*, valor predeterminado `True`) : Si es True, lanza `SandboxCommandError` si el código de salida no es cero.

capture_output (`bool`, *opcional*, valor predeterminado `True`) : Si es True, acumula stdout/stderr en el resultado devuelto. Pasa `False` cuando solo quieras `on_stdout`/`on_stderr`: la salida se entrega a los callbacks y se descarta, por lo que un comando que produzca gigabytes no tiene que caber en memoria. `result.stdout`/`result.stderr` están vacíos en ese caso.

background (`bool`, *opcional*, valor predeterminado `False`) : Si es True, inicia el comando de forma desacoplada y devuelve un [SandboxProcess](/docs/huggingface_hub/v2.4.0/es/package_reference/sandbox#huggingface_hub.SandboxProcess) de inmediato en lugar de esperar y devolver un [SandboxCommandResult](/docs/huggingface_hub/v2.4.0/es/package_reference/sandbox#huggingface_hub.SandboxCommandResult).

Ejecuta un comando en el sandbox y espera a que termine, transmitiendo la salida en vivo.

Con `background=True`, el comando se inicia de forma desacoplada y `run` devuelve un [SandboxProcess](/docs/huggingface_hub/v2.4.0/es/package_reference/sandbox#huggingface_hub.SandboxProcess) de inmediato, sin esperar a que termine, lo cual es útil para servidores y otros procesos de larga duración. Más adelante, puede listarlos con [Sandbox.processes()](/docs/huggingface_hub/v2.4.0/es/package_reference/sandbox#huggingface_hub.Sandbox.processes) y detener uno con [SandboxProcess.kill()](/docs/huggingface_hub/v2.4.0/es/package_reference/sandbox#huggingface_hub.SandboxProcess.kill). Las opciones de streaming o solo espera (`timeout`, `stdin`, `on_stdout`, `on_stderr`, `check`) no se aplican en ese modo.

Devuelve: un [SandboxCommandResult](/docs/huggingface_hub/v2.4.0/es/package_reference/sandbox#huggingface_hub.SandboxCommandResult) (con `exit_code`, `stdout`, `stderr`, `duration_ms`), o un [SandboxProcess](/docs/huggingface_hub/v2.4.0/es/package_reference/sandbox#huggingface_hub.SandboxProcess) cuando `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)
```

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

Una flota de trabajos compartidos de "host", cada uno con muchos sandbox aislados por landlock.

> [!WARNING]
> La API de Sandbox es experimental. Su API y comportamiento pueden cambiar sin previo aviso.
>
> **Los sandbox agrupados están destinados a cargas de trabajo dentro de un mismo límite de confianza.** Un sandbox agrupado es un uid más un conjunto de reglas de Landlock dentro de una VM compartida, no una VM propia, y todos los sandbox de un host comparten el token de autenticación de ese host y su plano de control privilegiado. Utilice un pool para desplegar de forma barata *su propio* código. Para cargas de trabajo que se desconfían mutuamente, use [Sandbox.create()](/docs/huggingface_hub/v2.4.0/es/package_reference/sandbox#huggingface_hub.Sandbox.create), que asigna a cada una su propia VM. Las limitaciones específicas se enumeran en la sección "Known limitations" de la guía conceptual de sandbox.

Un host equivale a un trabajo de HF facturado (una VM); ejecuta el servidor de sandbox y multiplexa hasta `sandboxes_per_host` sandboxes ligeros, aislados entre sí mediante uid y el LSM Landlock. Esto hace que las expansiones grandes sean económicas (el coste de la VM se comparte entre todos sus sandboxes) y rápidas (crear un sandbox requiere aproximadamente un solo viaje de ida y vuelta del proxy una vez que el host está caliente). Es ideal para muchos sandboxes CPU en paralelo, como los despliegues de RL; para GPU o un aislamiento fuerte a nivel de VM entre cargas de trabajo que no se confían mutuamente, usa [Sandbox.create()](/docs/huggingface_hub/v2.4.0/es/package_reference/sandbox#huggingface_hub.Sandbox.create) en su lugar.

El constructor preasigna `warm_up` hosts (1 por defecto) y bloquea hasta que estén listos; los hosts adicionales se asignan bajo demanda a medida que se solicitan sandboxes, y todos

se desmontan al llamar a `close()` (o cuando están inactivos, mediante `idle_timeout`). El usuario nunca gestiona los trabajos:

```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()` crea **una** sandbox a la vez: reutiliza un host que aún tiene capacidad libre antes de iniciar uno nuevo, por lo que el crecimiento es bajo demanda a medida que llegan las tareas. Para evitar un arranque en frío en las primeras llamadas, preprovisiona hosts con `warm_up` (o `warm`). Los hosts calientes se detectan mediante etiquetas de trabajo, por lo que la reutilización también funciona **entre procesos** (un pool nuevo con la misma `image`/`flavor`/`name` se adjunta a

deja atrás una ejecución anterior):

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

#### cerrar[[huggingface_hub.SandboxPool.close]]

```python
close()
```

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

Liberar el pool. Idempotente.

Para un pool que creamos, esto termina todos los trabajos del host (y, por lo tanto, todos sus sandboxes). Para un handle conectado con `connect()`, solo libera los clientes HTTP locales: los hosts compartidos pueden estar sirviendo a otros clientes, por lo que — al igual que [Sandbox.connect()](/docs/huggingface_hub/v2.4.0/es/package_reference/sandbox#huggingface_hub.Sandbox.connect) — salir de un bloque `with` no debe desmontarlos. Termina explícitamente los hosts de un pool conectado con `hf sandbox pool delete <id>`.

Solo se cancelan los hosts *que gestionan procesos iniciados*. Un host descubierto mediante etiquetas puede estar sirviendo los sandbox de otro proceso, por lo que se libera en lugar de terminarse.

Lanza `SandboxError` si no se pudo cancelar un trabajo del host, indicando los trabajos que siguen en ejecución: estos siguen generando cargos y sus entradas de caché se conservan para que sigan siendo detectables. Cuando `close()` se alcanza a través de `__exit__` con una excepción ya en curso, el fallo se registra en el registro en su lugar, para que no enmascare el error original.

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

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

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

**Parámetros:**

pool_id (`str`) : El identificador devuelto cuando se creó el pool por primera vez.

namespace (`str`, *opcional*) : Espacio de nombres en el que buscar los hosts del pool (por defecto, el tuyo).

adopt_hosts (`str`, *opcional*, por defecto `"own"`) : A qué hosts se pueden adjuntar. Consulte [SandboxPool](/docs/huggingface_hub/v2.4.0/es/package_reference/sandbox#huggingface_hub.SandboxPool). Para volver a adjuntarse a un pool cuyos hosts fueron iniciados por otro miembro del espacio de nombres, se necesita `"namespace"`.

token (`str`, *opcional*) : Sustitución del token de HF.

Vincúlate a un pool en ejecución por id, desde cualquier máquina: no se necesita estado local.

Encuentra un host en ejecución etiquetado con `pool_id` y reconstruye la configuración del pool (image/flavor/density/host-idle) a partir de la especificación y las variables de entorno del trabajo de ese host, devolviendo un [SandboxPool](/docs/huggingface_hub/v2.4.0/es/package_reference/sandbox#huggingface_hub.SandboxPool) listo para `create()` más sandboxes, ya sea agrupándolos en los hosts en ejecución o iniciando un duplicado (misma configuración) cuando estos estén llenos.

Lanza `SandboxError` si no se encuentra ningún host en ejecución (un pool deja de existir cuando todos sus hosts desaparecen, ya sea por tiempo de espera inactivo o por haber sido eliminados).

#### 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)
```

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

**Parámetros:**

env (`dict[str, Any]`, *opcional*) : Variables de entorno para este sandbox (cada sandbox tiene las suyas).

idle_timeout (`int` o `float` o `str`, *opcional*, valor predeterminado `600`) : Tiempo de espera de inactividad por sandbox — un sandbox se expulsa de su host después de este período de inactividad (sin llamadas a la API, sin procesos en ejecución). Diferente del tiempo de espera de inactividad del host. Pasa `None` para desactivarlo.

forward_hf_token (`bool`, *opcional*, valor predeterminado `False`) : Si es True, inyecta tu token de HF como `HF_TOKEN` en el sandbox (opcional). A diferencia de los `secrets` de un sandbox dedicado, el entorno de un sandbox agrupado se entrega al servidor host en la creación (nunca se almacena en el trabajo host), por lo que no aparece en los metadatos de ningún trabajo.

Cree un solo sandbox, aprovisionando un host si es necesario.

Reutiliza un host con capacidad libre (de este pool, o un host cálido encontrado mediante las etiquetas del trabajo / la caché local) antes de iniciar uno nuevo, de modo que una llamada a `create()` contra un host cálido cuesta aproximadamente un solo viaje de ida y vuelta. Llámalo repetidamente para distribuir la carga; usa `warm_up` (o `warm`) para aprovisionar hosts de antemano y evitar un arranque en frío en las primeras llamadas. Si un host se llena bajo nosotros (otro proceso lo llenó) o un host en caché ya no existe, el sandbox se reubica en otro host (o en uno nuevo).

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

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

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

Asegúrese de que `num_hosts` host(s) vacíos estén en ejecución y déjelos en ejecución. Devuelve los ids de trabajo de los hosts del pool.

Se utiliza para "crear" un pool de antemano: los hosts llevan la etiqueta y la configuración del pool (en sus variables de entorno), por lo que una posterior llamada a `SandboxPool.connect(pool_id)` (incluso desde otra máquina) los encuentra y genera sandboxes sin un arranque en frío. Los hosts siguen facturando hasta que se terminen o queden inactivos.

Adopta los hosts que ya están en ejecución para este pool (detectados mediante las etiquetas del trabajo) antes de iniciarlos, de modo que una llamada a `warm()` después de `connect()` —o una llamada repetida a `warm()`— complete hasta `num_hosts` en lugar de duplicar los hosts activos y superar `max_hosts`.

## Estructuras de datos

### 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)
```

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

Resultado de un comando ejecutado en un sandbox con [Sandbox.run()](/docs/huggingface_hub/v2.4.0/es/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)
```

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

Un proceso en segundo plano iniciado en un sandbox con [Sandbox.run()](/docs/huggingface_hub/v2.4.0/es/package_reference/sandbox#huggingface_hub.Sandbox.run)`(..., background=True)`.

Liste los procesos de un sandbox con [Sandbox.processes()](/docs/huggingface_hub/v2.4.0/es/package_reference/sandbox#huggingface_hub.Sandbox.processes) y detenga uno con [SandboxProcess.kill()](/docs/huggingface_hub/v2.4.0/es/package_reference/sandbox#huggingface_hub.SandboxProcess.kill). Los procesos finalizados recientemente permanecen en la lista (el servidor mantiene un número limitado de ellos), por lo que `running` y `exit_code` indican si un proceso sigue activo o ya ha finalizado (en el momento en que se listó).

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

```python
kill()
```

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

Termina el proceso en segundo plano. Idempotente.

Indica si esta llamada es la que lo detuvo: `False` significa que ya se había finalizado o terminado, lo cual no es un error.

Tenga en cuenta que un descendiente que se desconecta con `setsid()` abandona el grupo de procesos señalados y sobrevive a esta llamada. Elimine el sandbox para asegurarse de que todo lo que inició ha desaparecido.

### 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 = '')
```

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

Un archivo o directorio dentro de un sandbox.

## Errores

### 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)
```

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

**Parámetros:**

status_code : El estado HTTP devuelto por el servidor en el sandbox, si el error proviene de una respuesta de la API (p. ej. `404` para un archivo que no existe). `None` en caso contrario.

Excepción base para operaciones de sandbox (ver `huggingface_hub.Sandbox`).

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

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

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

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

**Parámetros:**

cmd : El comando que falló.

result : El `SandboxCommandResult` completo (exit_code, stdout, stderr, ...).

Se lanza cuando un comando ejecutado en un sandbox finaliza con un código no cero.