# Kum Havuzları

> [!NOTE]
> Sandbox API deneyseldir. API'si ve davranışı haber verilmeksizin değişebilir. Paylaşılan sandbox'lar aynı güven sınırındaki iş yükleri için tasarlanmıştır; birbirine güvenmeyen iş yükleri için ayrılmış sandbox'lar kullanın.

Nasıl kullanılacaklarını öğrenmek için [Sandboxes kılavuzuna](../guides/sandbox) göz atın.

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

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

Hugging Face Jobs üzerinde çalışan izole bir bulut makinesi.

> [!NOTE]
> Sandbox API deneyseldir. API'si ve davranışı haber verilmeksizin değişebilir.

[Sandbox.create()](/docs/huggingface_hub/v2.4.0/tr/package_reference/sandbox#huggingface_hub.Sandbox.create) ile özel bir tane oluşturun (her sandbox için bir iş) veya [SandboxPool](/docs/huggingface_hub/v2.4.0/tr/package_reference/sandbox#huggingface_hub.SandboxPool)'dan birçok ucuz, paylaşımlı tane alın.

Her yerden çalışan bir sandbox'a [Sandbox.connect()](/docs/huggingface_hub/v2.4.0/tr/package_reference/sandbox#huggingface_hub.Sandbox.connect) ile yeniden bağlanın. Çıkışta sonlandırmak için bir bağlam yöneticisi olarak kullanın:

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

#### kapat[[huggingface_hub.Sandbox.close]]

```python
close()
```

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

Sandbox'u sonlandırmadan yerel HTTP istemcisini serbest bırakın. İdempotenttir.

Pool kum havuzları için no-op (istemci, pool'un ana bilgisayarına aittir).

#### bağlan[[huggingface_hub.Sandbox.connect]]

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

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

Sadece kimliğini kullanarak, her yerden çalışan bir kum havuzuna yeniden bağlanın.

#### oluştur[[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)
```

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

**Parametreler:**

image (`str`, *isteğe bağlı*, varsayılan `"python --3.12"`): `/bin/sh` içeren herhangi bir Docker görüntüsü (Docker Hub veya `hf.co/spaces/...`).

flavor (`str`, *isteğe bağlı*, varsayılan `"cpu-basic"`) : Donanım türü, örn. `"cpu-basic"`, `"a10g-small"`. `hf jobs hardware` komutuna bakın.

idle_timeout (`int` veya `float` veya `str`, *isteğe bağlı*, varsayılan `600`) : Bu kadar hareketsizlikten (API çağrısı yok, çalışan süreç yok) sonra otomatik kapatma. Varsayılan olarak 10 dakikadır; devre dışı bırakmak için `None` geçirin. Dikkat edin, *foreground* komutu şu an için aktivite olarak sayılmamaktadır, bu nedenle başka API trafiği olmadan bu süreden uzun süren tek bir `run()` komutu, altındaki sandbox'ın kapatılmasına neden olabilir — uzun süreli tek komutlar için zaman aşımını artırın (veya `None` geçirin).

env (`dict[str, Any]`, *isteğe bağlı*) : Sandbox'ta kullanılabilir ortam değişkenleri.

secrets (`dict[str, Any]`, *isteğe bağlı*) : Gizli ortam değişkenleri (sunucu tarafında şifrelenir).

volumes (`List[Volume]`, *isteğe bağlı*) : Bağlanacak HF depoları/bucket'ları, bkz. [Volume](/docs/huggingface_hub/v2.4.0/tr/package_reference/jobs#huggingface_hub.Volume).

namespace (`str`, *isteğe bağlı*) : Çalıştırılacak kullanıcı veya kuruluş ad alanı (varsayılan olarak mevcut kullanıcı).

forward_hf_token (`bool`, *isteğe bağlı*, varsayılan `False`) : True ise, HF token'ınız `HF_TOKEN` olarak enjekte edilir (opt-in).

labels (`dict[str, str]`, *isteğe bağlı*) : Altta yatan HF Job'a eklenmesi gereken etiketler.

start_timeout (`float`, *isteğe bağlı*, varsayılan `120.0`) : Sandbox'ın hazır hale gelmesi için beklenecek maksimum saniye.

token (`str`, *isteğe bağlı*) : HF token geçersiz kılma.

Özel bir kum havuzu (tek bir HF Job) oluşturun ve hazır olana kadar (~7s on cpu-basic) bekleyin.

Her sandbox, tam yalıtılmış bir sanal makinedir; bu nedenle GPU iş yükleri veya güvenilmeyen kod için doğru seçimdir. Bunun yerine birçok ucuz CPU sandbox dağıtmak için [SandboxPool](/docs/huggingface_hub/v2.4.0/tr/package_reference/sandbox#huggingface_hub.SandboxPool) kullanın.

İş, sabit 24 saatlik maksimum bir ömürle çalışır; `idle_timeout` asıl belirleyicidir — boşta kalan bir sandbox, bu sürenin çok öncesinde kendini kapatır.

Görsel yalnızca `/bin/sh` gerektirir. Sandbox sunucusu, kullanılabilirse başlangıçta `wget`/`curl` ile indirilir, aksi halde her zaman bağlı olan bir sunucu kovasından okunur (bu, soğuk başlatmaya ~2-3 sn ekler, bu nedenle `wget`/`curl` dağıtılması hızı korur).

#### süreçler[[huggingface_hub.Sandbox.processes]]

```python
processes()
```

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

Bu kum havuzunun arka plan süreçlerini listeleyin.

[Sandbox.run()](/docs/huggingface_hub/v2.4.0/tr/package_reference/sandbox#huggingface_hub.Sandbox.run)`(..., background=True)` ile başlatılan süreçleri döndürür; birini [SandboxProcess.kill()](/docs/huggingface_hub/v2.4.0/tr/package_reference/sandbox#huggingface_hub.SandboxProcess.kill) ile durdurabilirsiniz. Yakın zamanda tamamlanan süreçler listede kalır (`running=False` ve `exit_code` değerleriyle); sunucu bunların sınırlı bir sayısını tutar, bu yüzden binlerce kısa komut çalıştırmış bir sandbox bunların hepsini listelemez.

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

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

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

**Parametreler:**

port (`int` veya `str`) : İç sunucunun dinlediği port (havuz: unix soketinin `<port>` değeri).

path (`str`, *isteğe bağlı*, varsayılan `"/"`) : İç sunucuda işaret edilecek yol, örn. `"/ws"`.

scheme (`str`, *isteğe bağlı*, varsayılan `"https --//"`): Bağlantıyı oluşturmak için kullanılacak URL şeması. Varsayılan olarak `"https://"` değerini alır; WebSocket istemcisi için `"wss://"` değerini iletin (proxy protokol bağımsızdır, bu nedenle yalnızca istemci tarafındaki şema değişir).

**Dönüş:** `str`

`https://<job_id>--49983.hf.jobs/v1/.../proxy/8000/ws` gibi bir URL (veya `scheme="wss://"` ile `wss://...`).

Bu kum havuzu *içinde* çalışan bir sunucuya yönlendiren herkese açık URL.

Dönen URL'ye yapılan istekler, iş içi kum havuzu sunucusu tarafından, kum havuzunda başlattığınız `port` üzerindeki sunucuya yönlendirilir; bu yönlendirme WebSocket (`ws(s)://`) yükseltmeleri ve akışlı yanıtları da içerir. Kimlik doğrulama için `proxy_headers` ile birlikte kullanın.

Sandbox'ın `port` üzerinde dinlemesi gerektiği:

- **Pool / paylaşılan sandbox**: bir TCP portuna bağlanamaz (Landlock), bu nedenle `$SBX_PROXY_DIR/<port>.sock` adresinde bir **unix socket** bağlayın (`SBX_PROXY_DIR` ortam değişkeni her sandbox'ta ayarlanır). Örn. `uvicorn app:app --uds $SBX_PROXY_DIR/8000.sock`.
- **Özel kum havuzu**: `127.0.0.1:<port>` üzerinde normal bir TCP portu bağlayın. (Portu buradan geçmeden doğrudan iş vekili aracılığıyla da açabilirsiniz.)

Örnek:
```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")
```

#### çalıştır[[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)
```

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

**Parametreler:**

cmd (`str` veya `List[str]`) : Bir kabuk komut dizesi (`/bin/sh -c` ile çalıştırılır) veya bir argv listesi (doğrudan çalıştırılır).

shell (`bool`, *isteğe bağlı*) : `cmd` türünden çıkarılacağı yerine çalışma modunu zorlar. `True`, `/bin/sh -c` üzerinden çalıştırır ve `cmd`'nin bir dize olmasını gerektirir; `False`, `cmd`'yi doğrudan çalıştırır (exec) ve bunun bir argv listesi olmasını gerektirir. `None` (varsayılan) türden çıkarım yapar. Tür kaynaklı hatalardan kaçınmak için bunu açıkça belirleyin (ör. `["echo hi"]`'nin `"echo hi"` adlı tek bir program olarak çalıştırılması).

env (`dict[str, Any]`, *isteğe bağlı*) : Bu komut için ek ortam değişkenleri.

cwd (`str`, *isteğe bağlı*) : Çalışma dizini.

timeout (`float`, *isteğe bağlı*) : Komutu (tüm süreç grubunu) bu kadar saniye sonra sonlandırır.

stdin (`str`, *isteğe bağlı*) : Komutun stdin'ine yazılacak veri.

on_stdout (`Callable[[str], None]`, *isteğe bağlı*) : stdout parçaları geldikçe çağrılan geri bildirim.

on_stderr (`Callable[[str], None]`, *isteğe bağlı*) : stderr parçaları geldikçe çağrılan geri bildirim.

check (`bool`, *isteğe bağlı*, varsayılan `True`) : True ise, sıfır olmayan çıkış durumunda `SandboxCommandError` fırlatılır.

capture_output (`bool`, *isteğe bağlı*, varsayılan `True`) : True ise, stdout/stderr çıktısı döndürülen sonuca biriktirilir. Sadece `on_stdout`/`on_stderr` istendiğinde `False` geçirin: çıktı o zaman geri çağrılara (callback) iletilir ve atılır, böylece gigabaytlar üreten bir komutun bellekte sığması gerekmez. Bu durumda `result.stdout`/`result.stderr` boş olur.

background (`bool`, *isteğe bağlı*, varsayılan `False`) : True ise, komutu ayrı olarak başlatır ve beklemek yerine hemen bir [SandboxProcess](/docs/huggingface_hub/v2.4.0/tr/package_reference/sandbox#huggingface_hub.SandboxProcess) döndürür, bir [SandboxCommandResult](/docs/huggingface_hub/v2.4.0/tr/package_reference/sandbox#huggingface_hub.SandboxCommandResult) döndürmez.

Sandbox'ta bir komut çalıştırın ve bekleyin, çıktıyı canlı olarak akışa alın.

`background=True` ile komut ayrılmış olarak başlatılır ve `run`, sürecin bitmesini beklemeden hemen bir [SandboxProcess](/docs/huggingface_hub/v2.4.0/tr/package_reference/sandbox#huggingface_hub.SandboxProcess) döndürür — bu, sunucular ve diğer uzun süreli süreçler için kullanışlıdır. Bunları daha sonra [Sandbox.processes()](/docs/huggingface_hub/v2.4.0/tr/package_reference/sandbox#huggingface_hub.Sandbox.processes) ile listeleyebilir ve [SandboxProcess.kill()](/docs/huggingface_hub/v2.4.0/tr/package_reference/sandbox#huggingface_hub.SandboxProcess.kill) ile birini durdurabilirsiniz. Akış/yalnızca bekleme seçenekleri (`timeout`, `stdin`, `on_stdout`, `on_stderr`, `check`) bu modda geçerli değildir.

Dönüş: `background=True` olduğunda bir [SandboxProcess](/docs/huggingface_hub/v2.4.0/tr/package_reference/sandbox#huggingface_hub.SandboxProcess), aksi halde `exit_code`, `stdout`, `stderr`, `duration_ms` içeren bir [SandboxCommandResult](/docs/huggingface_hub/v2.4.0/tr/package_reference/sandbox#huggingface_hub.SandboxCommandResult).

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

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

Her biri birçok landlock yalıtımlı kum havuzunu barındıran, paylaşımlı "host" işlerinden oluşan bir filo.

> [!WARNING]
> Sandbox API deneyseldir. API'si ve davranışı haber verilmeksizin değişebilir.
>
> **Toplu kum havuzları, tek bir güven sınırının içindeki iş yükleri içindir.** Toplu bir kum havuzu, paylaşılan bir sanal makinenin içindeki bir uid ve bir Landlock kuralları kümesidir — kendi sanal makinesi değildir — ve bir ana makinedeki her kum havuzu, o ana makinenin kimlik doğrulama belirteciyle ayrıcalıklı kontrol düzlemini paylaşır. Bir havuz kullanarak *kendi* kodunuzu düşük maliyetle dağıtın. Birbirine güvenmeyen iş yükleri için, her birine kendi sanal makinesini veren [Sandbox.create()](/docs/huggingface_hub/v2.4.0/tr/package_reference/sandbox#huggingface_hub.Sandbox.create) kullanın. Belirli eksiklikler, kum havuzu kavramsal kılavuzundaki "Bilinen kısıtlamalar" başlığı altında listelenmiştir.

Bir host, faturalandırılan tek bir HF Job'dur (bir VM); sandbox sunucusunu çalıştırır ve uid + Landlock LSM ile birbirinden izole edilmiş, en fazla `sandboxes_per_host` hafif sandbox'u çoklayıcı (multiplex) olarak yönetir. Bu, büyük yelpazeli dağıtımları (fan-out) ucuz (VM maliyeti tüm sandbox'lar arasında paylaşılır) ve hızlı (host ısındıktan sonra bir sandbox oluşturmak ~bir proxy gidiş-dönüşü kadardır) hale getirir. RL rollouts gibi birçok paralel CPU sandbox'u için en iyisidir; GPU veya birbirine güvenmeyen iş yükleri arasında güçlü VM düzeyinde izolasyon gerekiyorsa, bunun yerine [Sandbox.create()](/docs/huggingface_hub/v2.4.0/tr/package_reference/sandbox#huggingface_hub.Sandbox.create) kullanın.

Oluşturucu, `warm_up` ana bilgisayarını (varsayılan 1) önceden tahsis eder ve bunlar hazır olana kadar bekler; ardından ana bilgisayarlar, sandbox'lar istendiğinde talep üzerine tahsis edilir ve tüm

`close()` (veya boşta kalındığında, `idle_timeout` üzerinden) ile kaldırılır. Kullanıcı asla işleri yönetmez:

```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()` her seferinde **tek** bir sandbox oluşturur: yeni bir sandbox başlatmadan önce hâlâ boş kapasitesi olan bir host’u yeniden kullanır, böylece işler geldikçe talep üzerine ölçeklenirsiniz. İlk birkaç çağrıda soğuk başlatmayı önlemek için host’ları `warm_up` (veya `warm`) ile önceden hazırlayın. Sıcak host’lar iş etiketleri üzerinden keşfedildiğinden, yeniden kullanım **süreçler arası** da çalışır (aynı `image`/`flavor`/`name` değerlerine sahip yeni bir havuz,

daha önceki bir çalıştırmanın geride bıraktığı):

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

#### kapat[[huggingface_hub.SandboxPool.close]]

```python
close()
```

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

Havuzu serbest bırakın. İdempotent.

Oluşturduğumuz bir havuz için bu, tüm ana bilgisayar işlerini (ve dolayısıyla tüm kum havuzlarını) sonlandırır. `connect()` ile bağlanmış bir tutamaç için yalnızca yerel HTTP istemcileri serbest bırakılır: paylaşılan ana bilgisayarlar başka istemcilere hizmet verebilir, bu nedenle — tıpkı [Sandbox.connect()](/docs/huggingface_hub/v2.4.0/tr/package_reference/sandbox#huggingface_hub.Sandbox.connect) gibi — bir `with` bloğundan çıkarken onları kapatmamalıdır. Bağlı bir havuzun ana bilgisayarlarını açıkça `hf sandbox pool delete <id>` ile sonlandırın.

Yalnızca *bu tarafından başlatılan* hostlar iptal edilir. Etiketler aracılığıyla keşfedilen bir host, başka bir sürecin kum havuzlarını sunabilir; bu nedenle sonlandırılmak yerine serbest bırakılır.

Bir host işi iptal edilemediğinde `SandboxError` yükseltilir ve hâlâ çalışan işler adlandırılır — bunlar faturalandırmaya devam eder ve keşfedilebilir kalmaları için önbellek girdileri korunur. `close()`, `__exit__` üzerinden zaten uçuşta olan bir istisna ile ulaşıldığında, hata yerine kayıt altına alınır, böylece orijinal hatayı gizleyemez.

#### bağlan[[huggingface_hub.SandboxPool.connect]]

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

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

**Parametreler:**

pool_id (`str`) : Havuz ilk oluşturulduğunda döndürülen kimlik.

namespace (`str`, *isteğe bağlı*) : Havuzun ana bilgisayarlarının aranacağı ad alanı (varsayılan olarak sizinkidir).

adopt_hosts (`str`, *isteğe bağlı*, varsayılan `"own"`) : Bağlanabilecek konaklar. [SandboxPool](/docs/huggingface_hub/v2.4.0/tr/package_reference/sandbox#huggingface_hub.SandboxPool) bölümüne bakın. Ad alanının başka bir üyesinin başlattığı konaklara sahip bir havuza yeniden bağlanmak için `"namespace"` gerekir.

token (`str`, *isteğe bağlı*) : HF token geçersiz kılma.

Herhangi bir makineden, yerel durum gerektirmeden, kimlik numarası üzerinden çalışan bir havuza yeniden bağlanın.

`pool_id` etiketiyle çalışan bir host bulur ve havuzun yapılandırmasını (image/flavor/density/host-idle) o host işinin spec ve env değişkenlerinden yeniden oluşturur; ardından daha fazla sandbox `create()` etmeye hazır bir [SandboxPool](/docs/huggingface_hub/v2.4.0/tr/package_reference/sandbox#huggingface_hub.SandboxPool) döndürür — çalışan hostlara paketler veya hostlar doluysa bir kopya (aynı yapılandırma) başlatır.

Çalışan bir host bulunamazsa `SandboxError` fırlatılır (bir havuz, tüm hostları gittiğinde — boşta zaman aşımına uğradığında veya öldürüldüğünde — var olmaktan çıkar).

#### oluştur[[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)
```

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

**Parametreler:**

env (`dict[str, Any]`, *isteğe bağlı*) : Bu kum havuzu için ortam değişkenleri (her kum havuzu kendi değişkenlerine sahip olur).

idle_timeout (`int` veya `float` veya `str`, *isteğe bağlı*, varsayılan `600`) : Sandbox başına boşta kalma zaman aşımı — bir sandbox, bu kadar süre hareketsiz kaldıktan sonra (API çağrısı yok, çalışan süreç yok) konak makinesinden atılır. Konak makinesi boşta kalma zaman aşımından farklıdır. Devre dışı bırakmak için `None` geçirin.

forward_hf_token (`bool`, *isteğe bağlı*, varsayılan `False`) : True ise, HF token'ınızı sandbox'ta `HF_TOKEN` olarak enjekte eder (opt-in). Adanmış bir sandbox'un `secrets` değerlerinden farklı olarak, havuzlanmış bir sandbox'un env değerleri, oluşturulma sırasında host sunucusuna iletilir (host işinde asla saklanmaz), bu nedenle hiçbir işin metadata'sında görünmez.

Gerekirse bir ana bilgisayar tahsis ederek tek bir kum havuzu oluşturun.

Boş kapasiteye sahip bir ana makineyi (bu havuzunkini veya iş etiketleri / yerel önbellek yoluyla bulunan ılık bir ana makineyi) yeniden kullanır ve yeni bir ana makine başlatmadan önce bunu yapar; bu nedenle ılık bir ana makineye karşı yapılan `create()` çağrısı yaklaşık bir gidiş-dönüş maliyetine mal olur. Dağıtım yapmak için bunu tekrar tekrar çağırın; ilk çağrılarda soğuk başlatmayı önlemek ve ana makineleri önceden ayarlamak için `warm_up` (veya `warm`) kullanın. Bir ana makine altında dolarsa (başka bir süreç onu doldurduysa) veya önbelleğe alınmış bir ana makine yoksa, kum havuzu başka bir ana makineye (veya taze bir ana makineye) yeniden yerleştirilir.

#### sıcak[[huggingface_hub.SandboxPool.warm]]

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

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

`num_hosts` boş hostun çalıştığından emin olun ve çalışmaya devam etmelerini sağlayın. Havuzun host iş kimliklerini döndürür.

Önceden bir havuz "oluşturmak" için kullanılır: konaklar havuz etiketini ve yapılandırmasını (ortam değişkenlerinde) taşır, böylece sonraki bir `SandboxPool.connect(pool_id)` çağrısı (hatta başka bir makineden bile) onları bulur ve soğuk başlatma olmadan kum havuzları oluşturur. Konaklar, öldürülene veya boşta kalana kadar faturalandırmaya devam eder.

Bu havuz için zaten çalışan hostları (iş etiketleri üzerinden bulunan) başlatmadan önce benimser; böylece `connect()` sonrasında — veya tekrarlanan bir `warm()` çağrısında — `warm()` canlı hostları kopyalayarak `max_hosts` sınırını aşmak yerine `num_hosts` değerine tamamlama yapar.

## Veri yapıları

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

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

[Sandbox.run()](/docs/huggingface_hub/v2.4.0/tr/package_reference/sandbox#huggingface_hub.Sandbox.run) ile bir kum havuzunda (sandbox) yürütülen bir komutun sonucu.

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

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

Sandbox içinde [Sandbox.run()](/docs/huggingface_hub/v2.4.0/tr/package_reference/sandbox#huggingface_hub.Sandbox.run)`(..., background=True)` ile başlatılan bir arka plan süreci.

Bir sandbox'un süreçlerini [Sandbox.processes()](/docs/huggingface_hub/v2.4.0/tr/package_reference/sandbox#huggingface_hub.Sandbox.processes) ile listeleyin ve birini [SandboxProcess.kill()](/docs/huggingface_hub/v2.4.0/tr/package_reference/sandbox#huggingface_hub.SandboxProcess.kill) ile durdurun. Son zamanlarda tamamlanan süreçler listede kalır (sunucu bunlardan sınırlı sayıda tutar), bu nedenle `running` ve `exit_code`, bir sürecin hâlâ aktif mi yoksa zaten sonlanmış mı olduğunu (listelendiği anda) belirtir.

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

```python
kill()
```

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

Arka plan sürecini sonlandırın. İdempotenttir.

Bu çağrının durdurma nedenini döndürür: `False`, zaten çıkış yapıldığı veya sonlandırıldığı anlamına gelir ve bu bir hata değildir.

`setsid()` ile ayrışan bir torun, sinyal gönderilen işlem grubundan ayrılır ve bu çağrının ötesinde yaşamaya devam eder. Başlattığı her şeyin ortadan kalktığından emin olmak için kum havuzunu silin.

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

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

Bir sandbox içindeki dosya veya dizin.

## Hatalar

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

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

**Parametreler:**

status_code : Hata bir API yanıtından kaynaklanıyorsa (ör. eksik bir dosya için `404`) kum havuzu içindeki sunucu tarafından döndürülen HTTP durumu. Aksi halde `None`.

Sandbox işlemleri için temel istisna (bkz. `huggingface_hub.Sandbox`).

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

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

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

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

**Parametreler:**

cmd : Başarısız olan komut.

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

Bir komutun sandbox içinde sıfır olmayan bir kodla çıktığında oluşturulur.