# Sandbox

> [!NOTE]
> API Sandbox bersifat eksperimental. API dan perilakunya dapat berubah tanpa pemberitahuan. Sandbox bersama ditujukan untuk beban kerja dalam batas kepercayaan yang sama; gunakan sandbox khusus untuk beban kerja yang tidak saling percaya.

Lihat [panduan Sandboxes](../guides/sandbox) untuk mempelajari cara menggunakannya.

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

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

Mesin cloud terisolasi yang berjalan di Hugging Face Jobs.

> [!NOTE]
> API Sandbox bersifat eksperimental. API dan perilakunya dapat berubah tanpa pemberitahuan.

Buat satu yang khusus dengan [Sandbox.create()](/docs/huggingface_hub/v2.4.0/id/package_reference/sandbox#huggingface_hub.Sandbox.create) (satu job per sandbox), atau dapatkan banyak yang murah dan bersama dari [SandboxPool](/docs/huggingface_hub/v2.4.0/id/package_reference/sandbox#huggingface_hub.SandboxPool).

Lampirkan kembali ke sandbox yang sedang berjalan dari mana saja dengan [Sandbox.connect()](/docs/huggingface_hub/v2.4.0/id/package_reference/sandbox#huggingface_hub.Sandbox.connect). Gunakan sebagai context manager untuk mengakhiri saat keluar:

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

#### tutup[[huggingface_hub.Sandbox.close]]

```python
close()
```

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

Lepaskan klien HTTP lokal tanpa mengakhiri sandbox. Idempoten.

Tidak ada efek untuk sandbox pool (klien milik host pool).

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

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

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

Lampirkan kembali ke sandbox yang sedang berjalan dari mana saja, hanya menggunakan id-nya.

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

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

**Parameter:**

image (`str`, *opsional*, defaultnya `"python --3.12"`): Gambar Docker apa pun dengan `/bin/sh` (Docker Hub atau `hf.co/spaces/...`).

flavor (`str`, *opsional*, defaultnya `"cpu-basic"`) : Varian perangkat keras, misalnya `"cpu-basic"`, `"a10g-small"`. Lihat `hf jobs hardware`.

idle_timeout (`int` atau `float` atau `str`, *opsional*, defaultnya `600`) : Auto-shutdown setelah durasi inaktivitas ini (tidak ada panggilan API, tidak ada proses yang berjalan). Defaultnya 10 menit; berikan `None` untuk menonaktifkan. Perhatikan bahwa perintah *foreground* saat ini tidak dihitung sebagai aktivitas, sehingga satu `run()` yang memakan waktu lebih lama dari ini tanpa lalu lintas API lain dapat menyebabkan sandbox-nya dimatikan — tingkatkan timeout (atau berikan `None`) untuk perintah tunggal yang lama.

env (`dict[str, Any]`, *opsional*) : Variabel lingkungan yang tersedia di dalam sandbox.

secrets (`dict[str, Any]`, *opsional*) : Variabel lingkungan rahasia (dienkripsi di sisi server).

volumes (`List[Volume]`, *opsional*) : repositori/bucket HF untuk dipasang, lihat [Volume](/docs/huggingface_hub/v2.4.0/id/package_reference/jobs#huggingface_hub.Volume).

namespace (`str`, *opsional*) : Namespace pengguna atau organisasi untuk dijalankan (defaultnya adalah pengguna saat ini).

forward_hf_token (`bool`, *opsional*, defaultnya `False`) : Jika True, token HF Anda disuntikkan sebagai `HF_TOKEN` (opt-in).

labels (`dict[str, str]`, *opsional*) : Label yang akan dilampirkan ke HF Job yang mendasarinya.

start_timeout (`float`, *opsional*, default `120.0`) : Detik maksimum untuk menunggu hingga sandbox siap.

token (`str`, *opsional*) : Override token HF.

Buat sandbox khusus (satu HF Job) dan blokir hingga siap (~7 detik di cpu-basic).

Setiap sandbox adalah VM terisolasi penuh, sehingga ini adalah pilihan yang tepat untuk workload GPU atau kode yang tidak tepercaya. Untuk mendistribusikan banyak sandbox CPU yang murah, gunakan [SandboxPool](/docs/huggingface_hub/v2.4.0/id/package_reference/sandbox#huggingface_hub.SandboxPool) sebagai gantinya.

Job berjalan dengan masa hidup maksimum tetap 24 jam; `idle_timeout` adalah penjaga sebenarnya — sandbox yang idle akan mematikan dirinya sendiri jauh sebelum batas tersebut.

Gambar hanya membutuhkan `/bin/sh`. Server sandbox diunduh saat startup dengan `wget`/`curl` jika tersedia, jika tidak, dibaca dari bucket server yang selalu dimount (yang menambah ~2-3 detik ke cold start, sehingga menyertakan `wget`/`curl` menjaganya tetap cepat).

#### proses[[huggingface_hub.Sandbox.processes]]

```python
processes()
```

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

Daftarkan proses latar belakang dari sandbox ini.

Mengembalikan proses yang dimulai dengan [Sandbox.run()](/docs/huggingface_hub/v2.4.0/id/package_reference/sandbox#huggingface_hub.Sandbox.run)`(..., background=True)`; hentikan salah satunya dengan [SandboxProcess.kill()](/docs/huggingface_hub/v2.4.0/id/package_reference/sandbox#huggingface_hub.SandboxProcess.kill). Proses yang baru saja selesai tetap terdaftar (dengan `running=False` dan `exit_code` mereka); server mempertahankan jumlah terbatas dari proses tersebut, sehingga sandbox yang telah menjalankan ribuan perintah singkat tidak akan mendaftar semuanya.

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

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

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

**Parameter:**

port (`int` atau `str`) : Port (pool: `<port>` dari soket unix) tempat server internal mendengarkan.

path (`str`, *opsional*, defaultnya `"/"`) : Path pada server internal yang dituju, misalnya `"/ws"`.

scheme (`str`, *opsional*, defaultnya `"https --//"`): skema URL untuk membangun tautan. Defaultnya adalah `"https://"`; berikan `"wss://"` untuk klien WebSocket (proxy tidak bergantung pada protokol, sehingga hanya skema sisi klien yang berubah).

**Mengembalikan:** `str`

URL seperti `https://<job_id>--49983.hf.jobs/v1/.../proxy/8000/ws` (atau `wss://...` dengan `scheme="wss://"`).

URL publik yang memproksikan ke server yang berjalan *di dalam* sandbox ini.

Permintaan ke URL yang dikembalikan diteruskan oleh server sandbox dalam-jobs ke server yang Anda mulai di sandbox pada `port`, termasuk upgrade WebSocket (`ws(s)://`) dan respons yang di-stream. Gunakan bersama `proxy_headers` untuk autentikasi.

Bagaimana sandbox harus mendengarkan di `port`:

- **Pool / sandbox bersama**: tidak dapat mengikat port TCP (Landlock), jadi ikat **unix socket** di `$SBX_PROXY_DIR/<port>.sock` (variabel lingkungan `SBX_PROXY_DIR` disetel di setiap sandbox). Contoh: `uvicorn app:app --uds $SBX_PROXY_DIR/8000.sock`.
- **Sandbox khusus**: bind port TCP biasa di `127.0.0.1:<port>`. (Anda juga dapat mengekspos port secara langsung melalui job proxy tanpa melalui sini.)

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

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

**Parameter:**

cmd (`str` atau `List[str]`) : String perintah shell (dijalankan dengan `/bin/sh -c`) atau daftar argv (dieksekusi secara langsung).

shell (`bool`, *opsional*) : Memaksa mode eksekusi alih-alih menyimpulkannya dari tipe `cmd`. `True` dijalankan melalui `/bin/sh -c` dan mengharuskan `cmd` berupa string; `False` mengeksekusi `cmd` secara langsung dan mengharuskannya berupa daftar argv. `None` (default) menyimpulkan dari tipe. Tetapkan secara eksplisit untuk menghindari jebakan berbasis tipe (mis. `["echo hi"]` dieksekusi sebagai satu program bernama `"echo hi"`).

env (`dict[str, Any]`, *opsional*) : Variabel lingkungan tambahan untuk perintah ini.

cwd (`str`, *opsional*) : Direktori kerja.

timeout (`float`, *opsional*) : Hentikan perintah (seluruh grup proses) setelah jumlah detik ini.

stdin (`str`, *opsional*) : Data untuk ditulis ke stdin perintah.

on_stdout (`Callable[[str], None]`, *opsional*) : Callback yang dipanggil dengan chunk stdout saat tiba.

on_stderr (`Callable[[str], None]`, *opsional*) : Callback yang dipanggil dengan chunk stderr saat tiba.

check (`bool`, *opsional*, defaultnya `True`) : Jika True, lempar `SandboxCommandError` pada exit non-nol.

capture_output (`bool`, *opsional*, defaultnya `True`) : Jika True, kumpulkan stdout/stderr ke dalam hasil yang dikembalikan. Berikan `False` jika Anda hanya menginginkan `on_stdout`/`on_stderr`: output kemudian diteruskan ke callback dan dibuang, sehingga perintah yang menghasilkan gigabyte tidak harus muat di memori. `result.stdout`/`result.stderr` kosong dalam kasus tersebut.

background (`bool`, *opsional*, defaultnya `False`) : Jika True, mulai perintah secara terpisah dan langsung kembalikan [SandboxProcess](/docs/huggingface_hub/v2.4.0/id/package_reference/sandbox#huggingface_hub.SandboxProcess) tanpa menunggu, alih-alih menunggu dan mengembalikan [SandboxCommandResult](/docs/huggingface_hub/v2.4.0/id/package_reference/sandbox#huggingface_hub.SandboxCommandResult).

Jalankan perintah di sandbox dan tunggu hingga selesai, dengan streaming output secara langsung.

Dengan `background=True`, perintah dimulai secara terputus (detached) dan `run` langsung mengembalikan [SandboxProcess](/docs/huggingface_hub/v2.4.0/id/package_reference/sandbox#huggingface_hub.SandboxProcess) tanpa menunggu proses selesai — berguna untuk server dan proses jangka panjang lainnya. Anda dapat melihat daftarnya kemudian dengan [Sandbox.processes()](/docs/huggingface_hub/v2.4.0/id/package_reference/sandbox#huggingface_hub.Sandbox.processes) dan menghentikan salah satunya dengan [SandboxProcess.kill()](/docs/huggingface_hub/v2.4.0/id/package_reference/sandbox#huggingface_hub.SandboxProcess.kill). Opsi streaming/hanya-menunggu (`timeout`, `stdin`, `on_stdout`, `on_stderr`, `check`) tidak berlaku dalam mode tersebut.

Mengembalikan: [SandboxCommandResult](/docs/huggingface_hub/v2.4.0/id/package_reference/sandbox#huggingface_hub.SandboxCommandResult) (dengan `exit_code`, `stdout`, `stderr`, `duration_ms`), atau [SandboxProcess](/docs/huggingface_hub/v2.4.0/id/package_reference/sandbox#huggingface_hub.SandboxProcess) ketika `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)
```

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

Armada tugas "host" bersama, di mana masing-masing memuat banyak sandbox yang terisolasi oleh landlock.

> [!WARNING]
> API Sandbox bersifat eksperimental. API dan perilakunya dapat berubah tanpa pemberitahuan.
>
> **Sandbox yang dipoolkan ditujukan untuk workload di dalam satu batas kepercayaan.** Sandbox yang dipoolkan adalah sebuah uid plus ruleset Landlock di dalam VM bersama — bukan VM tersendiri — dan setiap sandbox di sebuah host berbagi token autentikasi host tersebut beserta control plane berprivilesenya. Gunakan pool untuk mendistribusikan *kode Anda sendiri* secara hemat. Untuk workload yang saling tidak mempercayai, gunakan [Sandbox.create()](/docs/huggingface_hub/v2.4.0/id/package_reference/sandbox#huggingface_hub.Sandbox.create), yang memberikan masing-masing workload VM tersendiri. Celah spesifiknya tercantum di bawah "Known limitations" pada panduan konseptual sandbox.

Satu host adalah satu HF Job yang ditagih (VM); host ini menjalankan server sandbox dan memultipleks hingga `sandboxes_per_host` sandbox ringan, yang diisolasi satu sama lain oleh uid + Landlock LSM. Hal ini membuat fan-out besar menjadi murah (biaya VM dibagikan di antara semua sandbox-nya) dan cepat (pembuatan sandbox hanya membutuhkan ~satu round-trip proxy setelah host dalam keadaan hangat). Paling cocok untuk banyak sandbox CPU paralel seperti RL rollouts; untuk GPU atau isolasi tingkat VM yang kuat di antara workload yang saling tidak mempercayai, gunakan [Sandbox.create()](/docs/huggingface_hub/v2.4.0/id/package_reference/sandbox#huggingface_hub.Sandbox.create) sebagai gantinya.

Konstruktor menyediakan `warm_up` host terlebih dahulu (default 1) dan memblokir hingga mereka siap; host tambahan kemudian disediakan sesuai permintaan saat sandbox diminta, dan semua

dibongkar pada `close()` (atau saat idle, melalui `idle_timeout`). Pengguna tidak pernah mengelola pekerjaan:

```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()` membuat **satu** sandbox pada satu waktu: ia memanfaatkan ulang host yang masih memiliki kapasitas kosong sebelum memulai host baru, sehingga Anda tumbuh sesuai permintaan saat pekerjaan datang. Untuk menghindari cold start pada beberapa panggilan pertama, siapkan host terlebih dahulu dengan `warm_up` (atau `warm`). Host yang hangat ditemukan melalui label job, sehingga pemanfaatan ulang juga berfungsi **melintasi proses** (pool baru dengan `image`/`flavor`/`name` yang sama akan menempel pada

menyimpan eksekusi sebelumnya yang ditinggalkan):

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

#### tutup[[huggingface_hub.SandboxPool.close]]

```python
close()
```

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

Lepaskan pool. Idempoten.

Untuk pool yang kami buat, ini mengakhiri semua pekerjaan host (dan dengan demikian semua sandbox mereka). Untuk handle yang terhubung melalui `connect()`, ini hanya melepaskan klien HTTP lokal: host bersama mungkin masih melayani klien lain, jadi — seperti [Sandbox.connect()](/docs/huggingface_hub/v2.4.0/id/package_reference/sandbox#huggingface_hub.Sandbox.connect) — keluar dari blok `with` tidak boleh menghancurkannya. Akhiri host dari pool yang terhubung secara eksplisit dengan `hf sandbox pool delete <id>`.

Hanya host yang *menangani proses yang dimulai* yang dibatalkan. Host yang ditemukan melalui label mungkin masih melayani sandbox dari proses lain, sehingga dilepaskan, bukan diakhiri.

Membuang `SandboxError` jika pekerjaan host tidak dapat dibatalkan, dengan menyebutkan pekerjaan yang masih berjalan — mereka tetap ditagih, dan entri cache mereka dipertahankan agar tetap dapat ditemukan. Ketika `close()` dicapai melalui `__exit__` dengan pengecualian yang sudah terjadi, kegagalan tersebut dicatat ke log, sehingga tidak dapat menutupi error asli.

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

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

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

**Parameter:**

pool_id (`str`) : id yang dikembalikan saat pool pertama kali dibuat.

namespace (`str`, *opsional*) : Namespace untuk mencari host pool (default adalah milik Anda).

adopt_hosts (`str`, *opsional*, defaultnya `"own"`) : Host mana yang dapat dilampirkan. Lihat [SandboxPool](/docs/huggingface_hub/v2.4.0/id/package_reference/sandbox#huggingface_hub.SandboxPool). Melampirkan ulang ke pool yang host-nya dimulai oleh anggota lain dari namespace memerlukan `"namespace"`.

token (`str`, *opsional*) : Override token HF.

Lampirkan kembali ke pool yang sedang berjalan berdasarkan id, dari mesin mana pun — tidak memerlukan status lokal.

Mencari host yang sedang berjalan dengan label `pool_id` dan membangun ulang konfigurasi pool (image/flavor/density/host-idle) dari spesifikasi dan variabel lingkungan job host tersebut, lalu mengembalikan [SandboxPool](/docs/huggingface_hub/v2.4.0/id/package_reference/sandbox#huggingface_hub.SandboxPool) yang siap untuk `create()` lebih banyak sandbox — mengemasnya ke host yang sedang berjalan, atau memulai duplikat (dengan konfigurasi yang sama) jika host tersebut sudah penuh.

Membuang `SandboxError` jika tidak ada host yang sedang berjalan (pool berhenti ada begitu semua hostnya hilang — karena idle-timed-out atau dihentikan).

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

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

**Parameter:**

env (`dict[str, Any]`, *opsional*) : Variabel lingkungan untuk sandbox ini (setiap sandbox memiliki variabel lingkungannya sendiri).

idle_timeout (`int` atau `float` atau `str`, *opsional*, defaultnya `600`) : Waktu tunggu idle per-sandbox — sebuah sandbox akan dieviksi dari hostnya setelah periode inaktivitas (tanpa panggilan API, tanpa proses yang berjalan) selama durasi ini. Berbeda dari waktu tunggu idle host. Berikan `None` untuk menonaktifkannya.

forward_hf_token (`bool`, *opsional*, defaultnya `False`) : Jika True, injeksi token HF Anda sebagai `HF_TOKEN` di dalam sandbox (opt-in). Berbeda dengan `secrets` dari sandbox khusus, env dari sandbox pooled dikirim ke server host saat pembuatan (tidak pernah disimpan di job host), sehingga tidak muncul di metadata job mana pun.

Buat satu sandbox, dengan menyediakan host jika diperlukan.

Memanfaatkan ulang host dengan kapasitas kosong (dari pool ini, atau host hangat yang ditemukan melalui label job / cache lokal) sebelum memulai host baru, sehingga `create()` terhadap host hangat hanya memakan waktu sekitar satu round-trip. Panggil berulang kali untuk fan out; gunakan `warm_up` (atau `warm`) untuk menyediakan host terlebih dahulu dan menghindari cold start pada panggilan pertama. Jika host terisi penuh di bawah kami (proses lain memakainya) atau host yang di-cache sudah hilang, sandbox akan ditempatkan ulang di host lain (atau host baru).

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

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

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

Pastikan `num_hosts` host kosong berjalan dan biarkan tetap berjalan. Mengembalikan id pekerjaan host dari pool.

Digunakan untuk "membuat" pool di awal: host membawa label dan konfigurasi pool (di variabel lingkungan mereka), sehingga `SandboxPool.connect(pool_id)` yang kemudian (bahkan dari mesin lain) dapat menemukannya dan memunculkan sandbox tanpa cold start. Host terus menagih biaya hingga dihentikan atau tidak aktif.

Mengadopsi host yang sudah berjalan untuk pool ini (ditemukan melalui label job) sebelum booting, sehingga `warm()` setelah `connect()` — atau `warm()` yang diulang — akan menambah hingga `num_hosts` alih-alih menduplikasi host yang aktif dan melampaui `max_hosts`.

## Struktur data

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

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

Hasil dari perintah yang dijalankan dalam sandbox dengan [Sandbox.run()](/docs/huggingface_hub/v2.4.0/id/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)
```

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

Proses latar belakang yang dimulai dalam sandbox dengan [Sandbox.run()](/docs/huggingface_hub/v2.4.0/id/package_reference/sandbox#huggingface_hub.Sandbox.run)`(..., background=True)`.

Daftarkan proses sandbox dengan [Sandbox.processes()](/docs/huggingface_hub/v2.4.0/id/package_reference/sandbox#huggingface_hub.Sandbox.processes) dan hentikan salah satunya dengan [SandboxProcess.kill()](/docs/huggingface_hub/v2.4.0/id/package_reference/sandbox#huggingface_hub.SandboxProcess.kill). Proses yang baru saja selesai tetap muncul dalam daftar (server menyimpan sejumlah terbatas proses), sehingga `running` dan `exit_code` menunjukkan apakah proses masih aktif atau sudah keluar (per saat proses tersebut didaftarkan).

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

```python
kill()
```

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

Akhiri proses latar belakang. Idempoten.

Mengembalikan apakah panggilan ini yang menghentikannya: `False` berarti proses tersebut sudah keluar atau dihentikan, yang bukan merupakan kesalahan.

Perhatikan bahwa keturunan yang melepaskan diri dengan `setsid()` akan keluar dari grup proses yang diberi sinyal dan bertahan setelah panggilan ini. Hapus sandbox untuk memastikan bahwa semua yang dimulainya telah hilang.

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

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

Berkas atau direktori di dalam sandbox.

## Kesalahan

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

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

**Parameter:**

status_code : Status HTTP yang dikembalikan oleh server dalam sandbox, jika error berasal dari respons API (misalnya `404` untuk file yang tidak ditemukan). `None` selain itu.

Pengecualian dasar untuk operasi sandbox (lihat `huggingface_hub.Sandbox`).

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

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

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

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

**Parameter:**

cmd : Perintah yang gagal.

result : `SandboxCommandResult` lengkap (exit_code, stdout, stderr, ...).

Dilempar ketika perintah yang dijalankan di dalam sandbox keluar dengan kode non-nol.