^j 9TddlZddlZddlZddlZddlZddlmZddlmZddl m Z m Z ddl m Z ddlmZddlmZmZmZmZmZmZmZddlZdd lmZdd lmZmZmZmZdd l m!Z!dd l"m#Z#m$Z$m%Z%dd l&m'Z'm(Z(ddl)m*Z*m+Z+ddl,m-Z-e+j\e/Z0dZ1dZ2dZ3dZ4dZ5dZ6dZ7dZ8dZ9dZ:dZ;dZdZ?dZ@d eAd!eAd"eAfd#ZBd$eCeDzeAzd"eCfd%ZEe Gd&d'ZFe Gd(d)ZGe Gd*d+ZHGd,d-ZId.eAeeAzd/eJdzd"eKeAeffd0ZLd1ejd"eeKfd2ZNd1ejd"dfd3ZOGd4d5ZPGd6d7ZQGd8d9ZRGd:d;ZSdeKeAefdzd?eKeAefdzd@ee!dzdAeCeDzeAzdzdBeJdCeAd"eUeVeAeKeAefeKeAefee!ffdDZWd/dev/null 2>&1; then wget -q --header "Authorization: Bearer $SBX_DL_TOKEN" -O "$d" "$SBX_SERVER_URL" elif command -v curl >/dev/null 2>&1; then curl -fsSL -H "Authorization: Bearer $SBX_DL_TOKEN" -o "$d" "$SBX_SERVER_URL" else cp "$SBX_SERVER_MOUNT/sbx-server" "$d"; fi chmod +x "$d" unset SBX_DL_TOKEN SBX_SERVER_URL SBX_SERVER_MOUNT exec "$d" hf_tokennoncereturnctj|jd|jtjj S)a5Derive the per-sandbox auth token from the user's HF token and the sandbox nonce. Stateless: any machine holding the same HF token can recompute it from the nonce stored in the job's labels, so `Sandbox.connect(job_id)` needs no local state. The HF token itself is never sent to the sandbox. z hf-sandbox:)hmacnewencodehashlibsha256 hexdigest)r)r*s c/var/www/ramen.bs-engineer-server.com/venv/lib/python3.12/site-packages/huggingface_hub/_sandbox.py_derive_sandbox_tokenr4]s; 88HOO%UG'<'C'C'Ew~~ V ` ` bbdurationcZt|ttfr t|St|S)zBParse a duration like 300, "300s", "10m", "2h", "1d" into seconds.) isinstanceintfloatr)r6s r3_duration_to_secsr;gs%(S%L)8} ( ##r5ceZdZUdZedzed<eed<eed<dZedzed<dZe ed<d Z eed <e d e fd Z d efd Z y)SandboxCommandResultz?Result of a command executed in a sandbox with [`Sandbox.run`].N exit_codestdoutstderrsignalF timed_outr duration_msr+c |jdk(SNr)r>selfs r3okzSandboxCommandResult.okys~~""r5ct|jdkr |jn|jdddz}d|jd|d|jdS)NPMz...zSandboxCommandResult(exit_code=z , stdout=z, duration_ms=))lenr?r>rC)rGouts r3__repr__zSandboxCommandResult.__repr__}sW -3dkkSb9IE9Q00@ #P^_c_o_o^ppqrrr5)__name__ __module__ __qualname____doc__r9__annotations__strrArBboolrCpropertyrHrOr5r3r=r=nsbITz K KFC$JItK #D##s#sr5r=ceZdZUdZeed<eeezed<eddZ ded<dZ edzed <dZ edzed <d Z e ed <dZedzed <ddZy)SandboxProcessaA background process started in a sandbox with [`Sandbox.run`]`(..., background=True)`. List a sandbox's processes with [`Sandbox.processes`] and stop one with [`SandboxProcess.kill`]. Completed processes stay in the listing until the sandbox is deleted, so `running` and `exit_code` tell whether a process is still alive or already exited (as of when it was listed). pidcmdF)reprcompareSandbox_sandboxNtag started_at_msTrunningr>cV|jjdd|jy)z:Terminate the background process (idempotent server-side).DELETEz /processes/N)r`_requestr[rFs r3killzSandboxProcess.kills! x;txxj)ABr5r+N)rPrQrRrSr9rTrUr rr`rarbrcrVr>rgrXr5r3rZrZsi H tCy UE:Hi:Ct $M3:$GT IsTz Cr5rZcbeZdZUdZeed<eed<eded<eed<dZedzed<d Z eed <y) FileEntryz%A file or directory inside a sandbox.namepath)filedirsymlinktypesizeNmtime_msmode) rPrQrRrSrUrTrr9rrrtrXr5r3rjrjs7/ I I * ++ IHcDjD#Nr5rjc eZdZdZdZdZdZddZdede fd Z d ded edefd Z d!ded ee ze zd edzddfdZ d!deezded edzddfdZdedeezddfdZdedeeeeffdZdeedeegefdeefdZdededee fdZded e d edzddfdZdedeefdZdedefdZdedefdZd"dededdfdZdeddfdZ y)# SandboxFilesu=Filesystem operations inside a sandbox, available as [`Sandbox.files`]. In shared (pool) mode, paths are rooted at the sandbox's private home — the only place its code can write — so a leading `/` is taken relative to that home. In dedicated mode, paths are absolute on the container filesystem. i r+Nc||_yN)r`rGsandboxs r3__init__zSandboxFiles.__init__s  r5rlc|j|j}||jkDr!dj|j ||S|j j ddd|i}|jS)z=Read a file from the sandbox and return its content as bytes.r5GET /files/readrlparams)statrqPARALLEL_THRESHOLDjoin _read_rangesr`rfcontent)rGrlrqresponses r3readzSandboxFiles.readskyy## $)) )88D--dD9: :==))%PT~)Vr5encodingcB|j|j|S)z@Read a file from the sandbox and return its content as a string.)rdecode)rGrlrs r3 read_textzSandboxFiles.read_textsyy%%h//r5datartc2t|tr|j}n t|ts|j }t ||j kDr|j|||yd|i}|||d<|jjdd||y)zHWrite content to a file in the sandbox (parent directories are created).NrlrtPUT /files/writerr) r8rUr/bytesrrMr _write_rangesr`rf)rGrlrrtrs r3writezSandboxFiles.writes dC ;;=DD%(99;D t9t.. .   tT4 0 $  !F6N unVTRr5 local_pathc(t|jj}||jkDr+|j |t|j |yt |d5}|j|||dddy#1swYyxYw)z#Upload a local file to the sandbox.Nrb)rt)rrst_sizerr read_bytesopenr)rGrrlrtrqfs r3uploadzSandboxFiles.uploadsJ$$&.. $)) )   tT*%5%@%@%BD I  *d # +q JJtQTJ * + + +s *BBc|j|j}||jkDr?t|d5}|j ||D]}|j | dddy|j jddd|i5}t|d5}|jdD]}|j | ddddddy#1swYyxYw#1swYxYw#1swYyxYw) z!Download a file from the sandbox.wbNrrrlrrw) chunk_size) rrqrrrrr`_stream iter_bytes)rGrlrrqrpartrchunks r3downloadzSandboxFiles.downloadsyy## $)) )j$' "1 --dD9"DGGDM" "  ]] " "5- " O #S[j$' #1%00K0H#EGGEN# # # #  "  # # # #s/)C C*)CC*CC' #C**C3rqc x|j}td||Dcgc]}|t|||z fc}Scc}wrE)PARALLEL_CHUNK_SIZErangemin)rGrqroffsets r3_rangeszSandboxFiles._rangess;((BG4QVBWXUD6M23XXXs7itemsfnct|jt|}t|5}t |j ||cdddS#1swYyxYw)zRun `fn(item)` over items concurrently. All workers share the sandbox's `httpx.Client`, which is thread-safe and pools connections, so parallel transfers fan out over several streams at once. N)rPARALLEL_MAX_WORKERSrMrlistmap)rGrrworkersexecutors r3 _parallelzSandboxFiles._parallelsL d//U<  ( 1H R/0 1 1 1s AAcdtttfdtffd }jj ||S)Nrngr+cj|\}}jjdd||d}|jS)Nrr)rlrlengthr)r`rfr)rrrrrlrGs r3fetchz(SandboxFiles._read_ranges..fetchsB NFF}}--}dfX^-_.H## #r5)tupler9rrr)rGrlrqrs`` r3rzSandboxFiles._read_rangess: $uS#X $5 $~~dll40%88r5cdtttfddffd }jjt |y)Nrr+c r|\}}|d}|d<jjdd||||zy)N)rlrrtrrrr`rf)rrrrrrtrlrGs r3pushz(SandboxFiles._write_ranges..pushsP NFF.2f%EF!%v MM " "5.QUV\_ehn_nQo " pr5)rr9rrrM)rGrlrrtrs```` r3rzSandboxFiles._write_rangessD qeCHo q$ q q t||CI.5r5c|jjddd|i}|jdDcgc] }tdi|c}Scc}w)z List a directory in the sandbox.rz /files/listrlrentriesrX)r`rfjsonrj)rGrlrentrys r3rzSandboxFiles.list sI==))%PT~)V08  0JKu "E"KKKsA ct|jjddd|i}tdi|jS)z3Get metadata of a file or directory in the sandbox.rz /files/statrlrrX)r`rfrjr)rGrlrs r3rzSandboxFiles.stats6==))%PT~)V+8==?++r5ct |j|y#t$r}|jdk(rYd}~yd}~wwxYw)z+Check whether a path exists in the sandbox.TiNF)rr status_code)rGrles r3existszSandboxFiles.existss7  IIdO }}#  s 7227 recursivecVd|i}|rd|d<|jjdd|y)z*Delete a file or directory in the sandbox.rl1rrez /files/deleterNr)rGrlrrs r3deletezSandboxFiles.deletes1$ "%F;  xHr5cD|jjddd|iy)z0Create a directory (and parents) in the sandbox.POSTz /files/mkdirrlrNr)rGrls r3mkdirzSandboxFiles.mkdir%s v~vtnMr5)r|r_r+N)zutf-8rz)F)!rPrQrRrSrrrr}rUrrrr rrrrr9r rrr r rrrrjrrrVrrrrXr5r3rvrvs))    0c0S0s0 S# SS5[8%; S3: SY] S+t+3+cDj+TX+ #S #cDj #T #YCYDsCx$9Y1tCy1hucz.B1tCy199C9DK96#6U6#*66LLiL ,,, 34I3I4IDIN#N$Nr5rvr\shellc|durt|ts td|durt|tr tdd|i}|||d<|S)zQBuild the `cmd`/`shell` part of an `/exec` payload, validating their consistency.TzCshell=True requires `cmd` to be a shell command string, not a list.FzRshell=False requires `cmd` to be an argv list (e.g. ['echo', 'hi']), not a string.r\r)r8rU ValueError)r\rpayloads r3 _exec_payloadr*sX }ZS1^__ ~*S#.mnn$clG   Nr5rc#K|jD]3}|stj|}|jddk7s0|5yw)zJIterate NDJSON events from a streaming response, skipping keepalive pings.eventpingN) iter_linesrloadsget)rliners r3 _iter_eventsr6sH##%  4  99W  'K s AA A c|j |jd}t d|j d||j #t$r|jdd}YAwxYw)zQRead the error body and raise a SandboxError (works for streaming responses too).errorNizSandbox API error (z): )r)rr Exceptiontextrr)rmessages r3_raise_for_statusr@sl MMO&--/'* ,X-A-A,B#gYO]e]q]q rr &--%&sA A'&A'c eZdZdZddddedededzd ed ed ed ed ededdfdZedddde d ed ed ed ededdfdZ e dedzfdZ dedede jfdZedededee jfdZddZddZdeddfdZy)_SandboxServeruEHTTP transport to one `sbx-server` instance — a dedicated job or a shared host. Owns the `httpx.Client`, the base URL and the auth headers. In dedicated mode a server is paired 1:1 with its [`Sandbox` In pool mode one server (one host job) is shared by many sandboxes, and `live`/`capacity` track packing. r)max_connectionscapacityjob_idownerimageNbase_urlr* sandbox_tokenapirrr+c 4||_||_||_||_||_||_t ||_||_| |_ d|_ d|_ tjd|j|dtj||d|_y)NrTBearer  AuthorizationzX-Sandbox-Token)rmax_keepalive_connections)headerslimitsfollow_redirects)rr_imagerr*_api_effective_token _auth_token_sandbox_tokenrliveverifiedhttpxClientLimits_client) rGrrrrr*rrrrs r3r}z_SandboxServer.__init__Rs       +C0+    ||#*4+;+;*>S(5>>:RGkk$kr5rc veZdZdZedddededfdZedddedegdffd Zdd dededfd Zy) _KillMethodz>Lets `kill` work both as a classmethod and an instance method.instanceNrr+).NcyrzrXrGr3rs r3__get__z_KillMethod.__get__sKNr5r_cyrzrXr5s r3r6z_KillMethod.__get__sORr5Sandbox | Nonec l| |jSddddtdtdzdtdzddffd}|S)Nrtoken sandbox_idrr;r+cJj|||jy)Nr:)rrg)r<rr;rs r3rgz!_KillMethod.__get__..kills MM* M G L L Nr5)_killrU)rGr3rrgs ` r3r6z_KillMethod.__get__sP  >> !=AW[ OS Od  O#PT* O`d O r5)rPrQrRrSrrpr r6rXr5r3r2r2smH NNTNhy6INN R R$R8BH;MRR 0(9BUr5r2ceZdZdZdedededzdededdf d Zee fd e ddddd d dd dedede e zezdzde eefdzde eefdzdeedzdedzdede dedzddfdZeddddededzdedzddfdZeZd?dZd?dZd@dZd?dZed d d d d d d d d d! d"eeezd#edzde eefdzd$edzd%e dzd&edzd'eegdfdzd(eegdfdzd)ed*ed defd+Zed d d d,d"eeezd#edzde eefdzd$edzd*ed-def d.Zdddddddd-d d! d"eeezd#edzde eefdzd$edzd%e dzd&edzd'eegdfdzd(eegdfdzd)ed*edeezfd/Zdeefd0Ze dedzfd1Z!e dedzfd2Z"dAd3d4d5e ezd6ed7edefd8Z#e de eeffd9Z$defd:Z%d;edZ+y)Br_aAn isolated cloud machine running on Hugging Face Jobs. Create a dedicated one with [`Sandbox.create`] (one job per sandbox), or get many cheap shared ones from a [`SandboxPool`]. Reattach to a running sandbox from anywhere with [`Sandbox.connect`]. Use as a context manager to terminate it on exit: ```python >>> from huggingface_hub import Sandbox >>> with Sandbox.create(image="python:3.12") as sbx: ... print(sbx.run("python --version").stdout) ``` rserverlocal_idN owns_sandbox owns_serverr+c||_||_||_|dnd||_||_||_d|_d|_t||_ y)Nz/v1/v1/sandboxes/F) r_server _local_id _base_path _owns_sandbox _owns_server_on_kill_killedrvfiles)rGrr@rArBrCs r3r}zSandbox.__init__s^ !$,#3%>(9T*(<@  !$' r5 cpu-basicF^@) flavor idle_timeoutenvsecretsvolumesrforward_hf_tokenrr;rrPrQrRrSrTrrUrr;c t| } t| } td} t| | }t | | ||||||\}}}}| j |||||t tdttt| i|xsdtg| }d} tj|| || tjdz}|j!| ||j&|dd d S#t"$r | j%|j&|j(j* n;#t"$r/}t,j/d |j&d |Yd}~nd}~wwxYw||j1wxYw)u3Create a dedicated sandbox (one HF Job) and block until it is ready (~7s on cpu-basic). Each sandbox is a full isolated VM, so this is the right choice for GPU workloads or untrusted code. To fan out many cheap CPU sandboxes instead, use [`SandboxPool`]. The job runs with a fixed 24h maximum lifetime; `idle_timeout` is the real keeper — an idle sandbox shuts itself down well before that. Args: image (`str`, *optional*, defaults to `"python:3.12"`): Any Docker image with `/bin/sh` (Docker Hub or `hf.co/spaces/...`). flavor (`str`, *optional*, defaults to `"cpu-basic"`): Hardware flavor, e.g. `"cpu-basic"`, `"a10g-small"`. See `hf jobs hardware`. idle_timeout (`int` or `float` or `str`, *optional*, defaults to `600`): Auto-shutdown after this much inactivity (no API calls, no running processes). Defaults to 10 minutes; pass `None` to disable. env (`dict[str, Any]`, *optional*): Environment variables available in the sandbox. secrets (`dict[str, Any]`, *optional*): Secret environment variables (encrypted server-side). volumes (`List[Volume]`, *optional*): HF repos/buckets to mount, see [`Volume`]. namespace (`str`, *optional*): User or org namespace to run under (defaults to current user). forward_hf_token (`bool`, *optional*, defaults to `False`): If True, your HF token is injected as `HF_TOKEN` (opt-in). start_timeout (`float`, *optional*, defaults to `120.0`): Max seconds to wait for the sandbox to become ready. token (`str`, *optional*): HF token override. The image only needs `/bin/sh`. The sandbox server is downloaded at startup with `wget`/`curl` if available, otherwise read off an always-mounted server bucket (which adds ~2-3s to cold start, so shipping `wget`/`curl` keeps it fast). r;rxrRrSrTrQrUrrN rcommandrRrSrPr labelsrTexposerrr*rrrrzFailed to cancel sandbox job  after startup failure: Trr@rArBrC)rrrr4_bootstrap_job_specrun_jobSANDBOX_MAX_LIFETIME SANDBOX_LABEL MODE_LABELMODE_DEDICATED NONCE_LABELSANDBOX_SERVER_PORTrrrvrr.rrrrrkloggerwarningr)rrrPrQrRrSrTrrUrr;rr)r*rrZjob_env job_secrets job_volumesrr@rs r3createzSandbox.createsf% #C(" -h> 5H  %-' 6 2+{kk(!3 NKQVW'4'(  +/ #,,+ , A AA E -F   m ,cffVd[_``  dcff G d!>svvhF^_`^abcc d!   s6z '.RUNNING is not running (status: r"r]r^)r_split_sandbox_id SHARED_ID_SEPsplit _connect_hostrrrrrr%r[rrgrdre MODE_POOLr&r'r4rrrrvrr)rr<rr;r host_job_idrAr@itemexistingrr[r*rs r3rzSandbox.connectes %  1*i H I J &$.$4$4]A$F !K"3 yIF 39>>%3Y3^3^3`a4DJaa8+&*=WXcWdde'fgg, *VhUZhlm mooZ9oE!r ;' ::m $ +u}j\1Mm_\efg g ::j !Y .zl#33@/O  ::  y (*5NszzO_O_N``bcd d-.>s.CUK (('(==A ) cffVd\`aa9b   s "G. G:GGG0c|jry |j|jjn)|jj dd|jd|_|j|j||jr|jjyy#t $r/}t jd|jd|Yd}~yd}~wwxYw)zTerminate the sandbox. Idempotent. Dedicated sandboxes cancel their underlying job; shared sandboxes are removed from their host (freeing a slot) while the host keeps running. NrerEzFailed to kill sandbox : T) rLrGrFrrrrirjrrKrJr)rGrs r3r>z Sandbox._kills <<  ~~% '') $$X?O/PQ  == $ MM$     LL      NN4TWWIRsC D  sAB++ C#4%CC#cR|jr|jjyy)zRelease the local HTTP client without terminating the sandbox. Idempotent. No-op for pool sandboxes (the client belongs to the pool's host). N)rJrFrrFs r3rz Sandbox.closes"    LL    r5c|SrzrXrFs r3 __enter__zSandbox.__enter__ r5c^|jr|jy|jyrz)rIrgrrGexc_infos r3__exit__zSandbox.__exit__s    IIK JJLr5.) rrRcwdr stdin on_stdout on_stderrcheck backgroundr\rrr rrrrrc yrzrX) rGr\rrRrr rrrrrs r3runz Sandbox.runs #r5)rrRrTcyrzrX)rGr\rrRrrs r3rz Sandbox.runsr5c Nt||} |r|| d<|r|| d<| rC|jdd| j} t| d|| j d|S||| d <||| d <g} g}d }|j dd | 5}t |D]}|d dk(r#| j|d|"||d.|d dk(r#|j|d|M||dY|d dk(sbt|ddj| dj||j d|j dd|j dd} d d d | td| r(|jdk7s |jr t|||S#1swYBxYw)u+ Run a command in the sandbox and wait for it, streaming output live. With `background=True` the command is started detached and `run` returns a [`SandboxProcess`] immediately, without waiting for it to finish — handy for servers and other long-running processes. List them later with [`Sandbox.processes`] and stop one with [`SandboxProcess.kill`]. The streaming/wait-only options (`timeout`, `stdin`, `on_stdout`, `on_stderr`, `check`) don't apply in that mode. Args: cmd (`str` or `List[str]`): A shell command string (run with `/bin/sh -c`) or an argv list (exec'd directly). shell (`bool`, *optional*): Force the execution mode instead of inferring it from the type of `cmd`. `True` runs through `/bin/sh -c` and requires `cmd` to be a string; `False` exec's `cmd` directly and requires it to be an argv list. `None` (default) infers from the type. Set it explicitly to avoid the type-driven footgun (e.g. `["echo hi"]` being exec'd as a single program named `"echo hi"`). env (`dict[str, Any]`, *optional*): Extra environment variables for this command. cwd (`str`, *optional*): Working directory. timeout (`float`, *optional*): Kill the command (whole process group) after this many seconds. stdin (`str`, *optional*): Data to write to the command's stdin. on_stdout (`Callable[[str], None]`, *optional*): Callback invoked with stdout chunks as they arrive. on_stderr (`Callable[[str], None]`, *optional*): Callback invoked with stderr chunks as they arrive. check (`bool`, *optional*, defaults to `True`): If True, raise [`SandboxCommandError`] on non-zero exit. background (`bool`, *optional*, defaults to `False`): If True, start the command detached and return a [`SandboxProcess`] right away instead of waiting for it and returning a [`SandboxCommandResult`]. Returns: a [`SandboxCommandResult`] (with `exit_code`, `stdout`, `stderr`, `duration_ms`), or a [`SandboxProcess`] when `background=True`. rRrr /processesrr[ra)r[r\rar`Nr rz/execrr?rr@exitr>rsrArBFrCr)r>r?r@rArBrCz%connection lost while running command)r\result)rrfrrZrrrappendr=rrr>rBr)rGr\rrRrr rrrrrrr stdout_parts stderr_partsrrrs r3rz Sandbox.runsh U+  GEN  GEN ==G=DIIKD!d5ksZ^_ _  !(GI   $GG "$ "$ .2 \\&'\ 8 H%h/ >X- ''f 6 ,!%-07^x/ ''f 6 ,!%-07^v-1"' "4!ww|4!ww|4$yy2"'))K"?$)IImQ$? F  & >FG G f&&!+v/?/?%#f= = /  s-F6*F!F6A#FF$c |jddj}|Dcgc]J}t|d|d|jd|jd|d|jd| Lc}Scc}w) a.List the background processes of this sandbox. Returns the processes started with [`Sandbox.run`]`(..., background=True)`; stop one with [`SandboxProcess.kill`]. Completed processes stay listed (with `running=False` and their `exit_code`) until the sandbox is deleted. rrr[r\rarbrcr>)r[r\rarbrcr>r`)rfrrZr)rGrps r3 processeszSandbox.processes2s}}UL1668   eHeHEE%LeeO4) %% ,    sAA7c.|jjSrz)rFrrFs r3rz Sandbox.imageIs||!!!r5cJ|j|jjSdS)zIFor a shared/pool sandbox, the job id of the host running it (else None).N)rGrFrrFs r3host_idzSandbox.host_idMs"'+nn&@t||""JdJr5zhttps://)schemeportrlrc|jjjddd}|jdr|nd|z}|||jd||S)a4Public URL that proxies through to a server running *inside* this sandbox. Requests to the returned URL are forwarded by the in-job sandbox server to a server you started in the sandbox on `port`, including WebSocket (`ws(s)://`) upgrades and streamed responses. Pair it with [`proxy_headers`] for auth. How the sandbox must listen on `port`: - **Pool / shared sandbox**: it cannot bind a TCP port (Landlock), so bind a **unix socket** at `$SBX_PROXY_DIR/.sock` (the `SBX_PROXY_DIR` env var is set in every sandbox). E.g. `uvicorn app:app --uds $SBX_PROXY_DIR/8000.sock`. - **Dedicated sandbox**: bind a normal TCP port on `127.0.0.1:`. (You can also expose the port directly via the job proxy without going through here.) Args: port (`int` or `str`): The port (pool: the `` of the unix socket) the inner server listens on. path (`str`, *optional*, defaults to `"/"`): Path on the inner server to point at, e.g. `"/ws"`. scheme (`str`, *optional*, defaults to `"https://"`): URL scheme to build the link with. Defaults to `"https://"`; pass `"wss://"` for a WebSocket client (the proxy is protocol-agnostic, so only the client-side scheme changes). Returns: `str`: a URL like `https://--49983.hf.jobs/v1/.../proxy/8000/ws` (or `wss://...` with `scheme="wss://"`). Example: ```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") ``` z://r/z/proxy/)rFrrv startswithrH)rGrrlr host_and_rests r3 proxy_url_forzSandbox.proxy_url_forTs^L --33E1=bA s+tt-(9tfMMr5cbd|jj|jjdS)zPAuth headers to send with [`proxy_url_for`] requests (HF token + sandbox token).rr)rFrrrFs r3 proxy_headerszSandbox.proxy_headers~s0 't||'?'?&@A#||::  r5c<d|jd|jdS)Nz Sandbox(id=z, image=rL)rrrFs r3rOzSandbox.__repr__sTWWKx ~Q??r5r resourcec X|jj||j|zfi|Srz)rFrrH)rGr rrs r3rfzSandbox._requests)#t||##FDOOh,FQ&QQr5c+K|jj||j|zfi|5}|dddy#1swYyxYwwrz)rFrrH)rGr rrrs r3rzSandbox._streamsF T\\ 8)C Nv N RZN   s,A< AAArh)r+r_)r),rPrQrRrSrUrrVr}r/ DEFAULT_IMAGEDEFAULT_IDLE_TIMEOUTr9r:dictr r rrnrr2rgr>rrrrr rr=rrZrrWrrrrrOrr0rfrr rrXr5r3r_r_s ( ( ( * (  (( (:#ba"1E%))-'+ $!&$ baba ba EkC'$. ba #s(^d " bac3h$&baf$ba:bababaTzba babaHAE[_$b$bC$J$bcTXj$bdm$b$bP =D!.! !%( #2525%( # 49_ #d{ # #s(^d " # 4Z # #Tz #SE4K(4/ #SE4K(4/ # #EN #  # # !%(  49_d{  #s(^d "  4Z DM "%) $ 2626 [ 49_[d{ [ #s(^d " [ 4Z [[Tz[SE4K(4/[SE4K(4/[[[  .[z 4/ ."sTz""KtKK (Nz(N#)(N3(N(N^a(NT tCH~  @#@ RsRcRRcSx?Wr5r_c4eZdZdZefdedddeddddd ded ed ed ed edzd edzdee zezdzdedzde dedzde ddfdZ e ddddededzdedzddfdZ d9dedeefdZdedddeeefdzdee zezdzde ddfdZedefdZedefd Zedeefd!Zd:d"Zd;d#Zd:d$Zd:d%Zd>> 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()` makes **one** sandbox at a time: it reuses a host that still has free capacity before booting a new one, so you grow on demand as work arrives. To avoid a cold start on the first few calls, pre-provision hosts with `warm_up` (or [`warm`]). Warm hosts are discovered via job labels, so reuse works **across processes** too (a fresh pool with the same `image`/`flavor`/`name` attaches to hosts an earlier run left behind): ```python >>> pool = SandboxPool(image="python:3.12") >>> sbx = pool.create() # finds a warm host (here or in another process), else boots one ``` rNrNrOF) rPsandboxes_per_hostwarm_up max_hostsrkrQrrr; _connect_moderrPrrrrkrQrrr;rr+c &|dkr td|dkr tdt| |_||_||_||_||_||_||n dtd|_ ||_ ||_ | |_ g|_ tj|_tj|_tj|_d|_d|_| |_| |_t/|_| s|j3yy) u Configure a pool and pre-provision `warm_up` hosts (blocks until they are ready). Env/secrets are *not* set here: they belong to each sandbox and are passed to `create(env=...)`, so sandboxes in the same pool can have different environments. Args: image (`str`, *optional*, defaults to `"python:3.12"`): Docker image for the hosts (needs `/bin/sh`). All sandboxes in the pool share this image. flavor (`str`, *optional*, defaults to `"cpu-basic"`): Hardware flavor for the host jobs (e.g. `"cpu-basic"`). sandboxes_per_host (`int`, *optional*, defaults to `50`): How many sandboxes to pack per host (per VM density). warm_up (`int`, *optional*, defaults to `1`): How many hosts to pre-provision in the constructor (which blocks until they are ready), so an initial burst of `create()` calls doesn't pay a host cold start each. Existing warm hosts (from the cache / other processes) count towards it, so only the shortfall is booted; capped by `max_hosts`. Defaults to 1 (a single host). max_hosts (`int`, *optional*): Optional cap on the number of host jobs (a cost ceiling). When reached and all hosts are full, `create()` raises. name (`str`, *optional*): Pool name, used as the `hf-sandbox-pool` job label so the pool is discoverable (e.g. `hf sandbox pool ls`, `connect()`). `create()` reuses running hosts carrying this label (including from other processes) before booting new ones, so distinct names keep separate pools from sharing hosts. A random name is generated when omitted. idle_timeout (`int` or `float` or `str`, *optional*, defaults to `600`): Host idle timeout — a host shuts down once it has had no sandboxes for this long (a billing backstop). Each sandbox also has its own idle timeout, set at `create()`. Pass `None` to disable. namespace (`str`, *optional*): User or org namespace to run hosts under. start_timeout (`float`, *optional*, defaults to `120.0`): Max seconds to wait for a host to become ready. token (`str`, *optional*): HF token override. rz sandboxes_per_host must be >= 1.zwarm_up must be >= 1.rWNzpool-F)rrrrrPr_warm_uprrrk _idle_timeout _namespace_start_timeout_hosts threadingLock_lock _warmup_lock _boot_lock_closed _warmed_up_require_live_host _owns_hostsset_dead_host_ids_ensure_warmed_up) rGrrPrrrrkrQrrr;rs r3r}zSandboxPool.__init__sl  !?@ @ Q;45 5&   "4 " ,DE)A,2H )#+,. ^^% &NN, $..* #0 -,(+   " " $r5r:pool_idc dt|}|Q||j|j|j|j||j | |j n||d St|}t|||}t|||}|jd}|jd} ||jxs|jxst|jt|jndt|jd t | t| nd|| t|nd||d S) urReattach to a running pool by id, from any machine — no local state needed. Finds a running host labelled with `pool_id` and rebuilds the pool's config (image/flavor/density/host-idle) from that host job's spec and env vars, returning a [`SandboxPool`] ready to `create()` more sandboxes — packing onto the running hosts, or booting a duplicate (same config) when they are full. Raises [`SandboxError`] if no running host is found (a pool stops existing once all of its hosts are gone — idle-timed-out or killed). Args: pool_id (`str`): The id returned when the pool was first created. namespace (`str`, *optional*): Namespace to search for the pool's hosts (defaults to yours). token (`str`, *optional*): HF token override. NT) rrPrrrkrQrr;rrWr!SBX_IDLE_TIMEOUT SBX_MAX_HOSTSrN SBX_CAPACITY)rrrPrrrQrr_find_pool_host_job _host_envrrrrrUr9DEFAULT_SANDBOXES_PER_HOST) rrrr;cacherrrRidle_raw max_hosts_raws r3rzSandboxPool.connects. (  kk||#(#;#;//"//-6->%//I"  % !#w)DSI677-.0 ""CcllCm&)jj&<3szz?+"377>;U#VW,9,Ec-(4*2*>XD  r5 num_hostsc|jr td|j|j5|t |j z }ddddkDrA|j |}|j5|j j|ddd|j5d|_ ddd|j|jS#1swYxYw#1swYMxYw#1swY=xYw)uEnsure `num_hosts` empty host(s) are running and leave them running. Returns the pool's host job ids. Used to "create" a pool up front: the hosts carry the pool label and config (in their env vars), so a later `SandboxPool.connect(pool_id)` (even from another machine) finds them and spawns sandboxes without a cold start. The hosts keep billing until killed or idle. Adopts hosts already running for this pool (found via job labels) before booting, so a `warm()` after `connect()` — or a repeated `warm()` — tops up to `num_hosts` instead of duplicating live hosts and blowing past `max_hosts`. This SandboxPool is closed.NrT) rr_discover_hostsrrMr_provision_hostsextendrr _save_cachehost_ids)rGr shortfallbooteds r3warmzSandboxPool.warmSs <<<= =  ZZ 5!C $44I 5 q=**95F + ""6* +    #"DO # }} 5 5 + + # #s#C7C'C+CC(+C4)rRrQrUrRrUr_c|jr tdt|xsi}|rt|j|d<| t |nd}g}d}d} |j  |j} | $|s"d}|j|j} | Y|jr<|r:|js.t|jtd|jd|j|} | = |j| ||} | |j'| S| |vr|j)| d}|d z }|t*kDr td #t$rA|j 5t#d| j$d z | _ddd#1swYxYwwxYw#t$r|j 5|jD cgc] } | |vs|  ncc} wc} |_ dddn #1swYnxYw|D]H} | j-n#t$rYnwxYw| j/5#| j/wxYwwxYw) uCreate one sandbox, provisioning a host if needed. Reuses a host with free capacity (this pool's, or a warm host found via job labels / the local cache) before booting a new one, so a `create()` against a warm host costs ~one round-trip. Call it repeatedly to fan out; use `warm_up` (or [`warm`]) to pre-provision hosts and avoid a cold start on the first calls. If a host fills up under us (another process packed it) or a cached host is gone, the sandbox is re-placed on another host (or a fresh one). Args: env (`dict[str, Any]`, *optional*): Environment variables for this sandbox (each sandbox gets its own). idle_timeout (`int` or `float` or `str`, *optional*, defaults to `600`): Per-sandbox idle timeout — a sandbox is evicted from its host after this much inactivity (no API calls, no running process). Distinct from the host idle timeout. Pass `None` to disable. forward_hf_token (`bool`, *optional*, defaults to `False`): If True, inject your HF token as `HF_TOKEN` in the sandbox (opt-in). Unlike a dedicated sandbox's `secrets`, a pooled sandbox's env is delivered to the host server at creation (never stored in the host job), so it doesn't appear in any job's metadata. rHF_TOKENNFrT No running host found for pool 'X'. The pool has stopped (all its hosts were killed or idle-timed-out); create a new one.rzZCould not place sandbox: hosts kept reporting full. Raise max_hosts or sandboxes_per_host.)rrrrrr;r _reserve_onerrrrrk_boot_one_host _create_onerrmaxrrremove_MAX_PACK_ROUNDSrr) rGrRrQrU sandbox_env idle_secs new_hosts discoveredroundshostr|hs r3rnzSandboxPool.creatensc: <<<= =39"o &6tyy&AK #8D7O%l3UY *,  <   " " $((*< !%J((*,,.D<..:dkk*$))4*>tyykJ__ ..y9D#"&"2"24i"P*((*& y(!((." ! ,,&tU0%"ZZ>(+Atyy1}(=DI>> *  M*.++LQ)9KqLL  M M M! !!OO% JJLDJJL  !  sB$F!<EF!#1F!F)F FF FF!!I6G* GGG*! I*G3 / I<H  H- HH-HH-I-H??Icp|j5t|jcdddS#1swYyxYw)z*Number of host jobs currently provisioned.N)rrMrrFs r3rzSandboxPool.num_hostss,ZZ $t{{# $ $ $s,5c~|j5td|jDcdddS#1swYyxYw)zz,SandboxPool.num_sandboxes..s9Ttyy9sN)rsumrrFs r3 num_sandboxeszSandboxPool.num_sandboxess2ZZ :9T[[99 : : :s3<c|j5|jDcgc]}|jc}cdddScc}w#1swYyxYw)z!Job ids of the provisioned hosts.N)rrrrGrs r3rzSandboxPool.host_idss>ZZ 9,0KK8DDKK8 9 98 9 9sA;AAA c|j5|j}g|_d|_dddD]/} |jr|j |j1|jrt|jyy#1swY`xYw#t $r/}t jd|jd|Yd}~td}~wwxYw#|jwxYw)uRelease the pool. Idempotent. For a pool we created, this terminates all host jobs (and therefore all their sandboxes). For a `connect()`'d handle it only releases the local HTTP clients: the shared hosts may be serving other clients, so — like [`Sandbox.connect`] — leaving a `with` block must not tear them down. Terminate a connected pool's hosts explicitly with `hf sandbox pool delete `. TNFailed to cancel sandbox host r}) rrrrrrrirjrrrrk)rGhostsrrs r3rzSandboxPool.closesZZ KKEDKDL  D ##OO%      dii (    T!? }BqcRSS T s4BBB C %CCC  CC c|SrzrXrFs r3rzSandboxPool.__enter__rr5c$|jyrz)rrs r3rzSandboxPool.__exit__s  r5c|j5|jr dddy|j|j |jnt |j|j}|j 5|t|jz }ddddkDr|j|jss|j 5|t|jz }ddd|dkDrA|j|}|j 5|jj|dddd|_ddd|jr|jyy#1swYxYw#1swYxYw#1swYNxYw#1swYKxYw)uOne-time: seed from the cache and pre-provision up to `warm_up` hosts. Cheap by default: seeding is local (no HTTP), and if the cache already gives at least `warm_up` hosts we trust them and skip discovery/booting (dead ones are pruned lazily by `create()`). Only when short do we list_jobs and boot the shortfall in parallel, capped by `max_hosts`. Runs at most once per pool, under `_warmup_lock`: concurrent first `create()` calls block here until the warm-up completes — and see its hosts — rather than racing past a half-set flag and each booting their own. `_warmed_up` is only set once the work succeeds, so a failed warm-up is retried (seeding/discovery dedupe by job id). Warm-up hosts are pool-level (like [`warm`]): they are not torn down if the triggering `create()` later fails — `close()` (or the `with` block) reclaims them. NrT)rr_seed_hosts_from_cacherrrrrMrrrrrr)rGtargetrrs r3rzSandboxPool._ensure_warmed_upsL    # # #  ' ' )&*nn&$*S-=$= > 1}!%!6!6y!A!ZZ7 KK..v67"DO' #, ;;     # 6 6>>77# # #sYE>AE>8E5E>E&*E> E2%E>E# E>&E/ +E>2E; 7E>>F_SandboxServer | Nonec|j5|jD]@}|j|jz dkDs |xjdz c_|ccdddS dddy#1swYyxYw)zNReserve one slot on the first host with free capacity (under lock), else None.rrN)rrrrrs r3rzSandboxPool._reserve_one0sg ZZ   ==499,q0IINIK       s,A'A'A''A0rrc|j5|j}| |cdddS|jr|j}| |cdddS|jd}|j ||j 5|j j |ddd|jcdddS#1swY"xYw#1swYyxYw)uhProvision (or adopt) one host and reserve a slot on it. Returns None to retry. Held under `_boot_lock` so that, within a process, only one host is booted at a time: a burst of create() calls that all found every host full queue here, and each new host frees `sandboxes_per_host` slots for the threads still waiting — so they reuse it instead of each booting their own. Before booting, we reuse a slot freed by a concurrent boot and, failing that, adopt a host already SCHEDULING for this pool (here or in another process) rather than piling on a duplicate. Nr)rr_adopt_pending_hostrrrr)rGrrrs r3rzSandboxPool._boot_one_host9s__ '$$&D  ' ''')((*# ' '**1-F   V $ + ""6* +$$&! ' ' + + ' 's.C#C.CC"CC CCc 0|jDchc]}|jc}tfd|jj dt t t|ji|jDdytjd|jdjdtj|jz}tj|kr|jjj|j j j"}|d vry|d k(r/|j%t'fd |jDry tj(dtj|krycc}w)aWait for and adopt a host already SCHEDULING for this pool, if any. Avoids over-provisioning when a host is already on its way up for this pool (started by another process, or an earlier create() in this one): rather than booting a duplicate, wait for it to reach RUNNING and adopt it via discovery. Returns True if a pending host was found (whether or not it eventually came up), False if none is scheduling. c3>K|]}|jvr|ywrz)r)rrknowns r3rz2SandboxPool._adopt_pending_host.._s'  66&  s SCHEDULINGr&r[rNFzPool 'z' host z: is already SCHEDULING; waiting for it instead of booting.r)rrrrrc3PK|]}|jjk(ywrzrr)rrpendings r3rz2SandboxPool._adopt_pending_host..vsITt{{gjj0I#&Tg?)rrnextr list_jobsrerx POOL_LABELrkrridebugrr#rr%r&r'ranyr*)rGrr+r'rr s @@r3rzSandboxPool._adopt_pending_hostUsB*.55 99..'& :tyyI"oo/     ? vdii[ |;uvw99;!4!44iikH$II))t)W^^ddE55 !$$&IT[[II JJsOiikH$96sFc|jDchc]}|j}}|jjdtt t |ji|jDcgc]}|j|vr|}}|D] d} t|jj|j}t|j|j}t|jd|j|_t!|j#ddj%|_|j65t9fd |jDr|j5n|jj;|dddycc}wcc}w#t(t*j,t.f$rB}t0j3djd |||j5Yd}~ud}~wwxYw#1swYxYw) aEAttach to running host jobs that match this pool (image/flavor/name). Lets `create()` reuse a host warmed by an earlier call or another process instead of booting a new one. Hosts are found via job labels; each adopted host's free capacity is read from the server, so packing stays accurate. rrrNr!rrrpzSkipping host z during discovery: c3PK|]}|jjk(ywrzr )rrrs r3rz.SandboxPool._discover_hosts..sEt{{cff,Er )rrrr rerxrrkrrrwrr9rrrrMrrrrr HTTPErrorrrirrrrr)rGrrrmatchesr@rRrs ` r3rzSandboxPool._discover_hosts{s*.555yy** "Iz499E//+  vvU"    /CF &tyy#&&DOOT  3$//J"%cggnd>U>U&V"W!&.."H"M"M"OP  /EEELLNKK&&v.  / /! /6 &!%//>B  ~cffX5HLM%LLN   / /s1F)F B&F=A HG><7G99G>H num_newc |j5t|j}ddd|jJ|z|jkDr8|j|z }t d|d|jdt d|dt t|d5}t|Dcgc]}|j|j}}dddg}d}D]"} |j| j$|*|D]#} | j| j%||S#1swY xYwcc}w#1swYtxYw#t$r } | }Yd} ~ d} ~ wwxYw#t$rYWwxYw#| jwxYw) z=Boot `num_new` host jobs in parallel, respecting `max_hosts`.Nz Pool needs z more host(s) but max_hosts=z allows only rz. more. Raise max_hosts or kill some sandboxes. ) max_workers)rrMrrrrrrrsubmit _boot_hostrrrrr) rGrcurrentallowedr_futuresrrfuturerr@s r3rzSandboxPool._provision_hostss ZZ '$++&G ' >> %'G*;dnn*Lnnw.GgY&B4>>BRS"1g//]_  C,< = QAFwPAxt7PGP Q')"& F  fmmo.     ##%%'LLN  #K ; ' 'Q Q Q   !LLNseD*D<%"D7D<EE *D47D<<E EEE E,)E/+E,,E//Fc  t|j}td}t||}t |j|ddd|j d|\}}}}d|d<t |j|d<|jt |j|d<tdttt|jt|i}|jj|j ||||j"t$||xsdt&g|j( } d} t*j-| |||jt/|jd zd |j } | j1|j2| S#t4$r |jj7| j8| j:j n;#t4$r/} t<j?d| j8d| Yd} ~ nd} ~ wwxYw| | jAwxYw)z6Start one host job and wait until its server is ready.rxNFrXr SBX_HOST_MODErrrYr()rr*rrrrrrr_)!rrrr4rarrUrrrdrerxrrkrgrbrrPrcrhrrrrr.rrrrrrirjr) rGr)r*rrZrkrlrmr[rr@rs r3rzSandboxPool._boot_hosts#DII." -h> 5H II ++"' 6 2+{$' #&d&=&="> >> %'*4>>':GO $j)ZT_afgii**;;('4'(oo  +/ $,,+II #D$;$;a$? E00 -F   d11 2   e $$CFFciinn$M e!?xG_`a_bcdd e!   s7A!E88 H ;F>=H > G6%G1,H 1G66H rrr8cddi}|||d<|r||d< |jdd|j}d |_|jd xsg}t|jd ds|s'|j5|j|_dddy|d}t|jt |d||dd d} |j"| _| S#ttjf$rM}|j rt jd |jd ||j|Yd}~yd}~wwxYw#1swYyxYw)uCreate one sandbox on a reserved `host`. Returns the sandbox, or None to retry. None means either the host filled up between our reservation and the create (server-authoritative capacity — another client packed it, so we mark it full and place the sandbox elsewhere) or a host rebuilt from the cache is gone/unreachable (dropped and re-placed via discovery / a fresh boot). countrNidle_timeout_secsrRrrprz!Dropping unreachable cached host r}T sandboxesrejectedrrFr`)rrrrrrrirr _drop_hostrr9rrrr_ru_on_sandbox_killedrK) rGrrRrbodyrrr&rzr|s r3rzSandboxPool._create_onesG!(|  (1D$ % DK <<d<CHHJD HH[)/R txx A& 'y * MM  *|++}od4j\:$Z   22+eoo. }} LL1AD99D>E r|c|j5td|jjdz |j_dddy#1swYyxYw)z:Free the packing slot of a shared sandbox that was killed.rrN)rrrFrr{s r3r)zSandboxPool._on_sandbox_killed*sD ZZ D#&q'//*>*>*B#CGOO  D D Ds 3A  Ac|j5|jDcgc] }||us| c}|_|jj|jddd|j ycc}w#1swYxYw)zFForget a host found dead this session (and mark it for cache pruning).N)rrraddrr)rGrrs r3r(zSandboxPool._drop_host/sc ZZ 1&*kkCQd]1CDK    # #DKK 0 1 D 1 1s A5 A0A0-A50A55A>ct|j}|yt|j}|j5|j Dchc]}|j }}|jD]}|j |vs|j|jk\r+t|j |j|j|j|jt||j|jt!|j"dzd|j }|j|_d|_|j j'| dddycc}w#1swYyxYw)uAdopt the pool's cached hosts without any HTTP (rebuilt from cached URL + nonce). Best-effort and unverified: each adopted host is confirmed on the first successful request (and dropped on the first failure, see `_create_one`). Hosts the cache believes are full are skipped — label discovery re-checks them with fresh counts if the seeded ones don't satisfy the request, so a stale-full entry never blocks a create. Nr(r"rF)rrkrrrrrrrrrrrrr*r4rrrr)rGrr)rrchr@s r3rz"SandboxPool._seed_hosts_from_cache8s  * = #DII. ZZ +-1[[9TT[[9E9kk +99%BKK)?'99((**[[(("7"(("K $'(?(?!(CS$I[[ !gg "' ""6*! + + +9 + +sE EC3EEE'cJ|j5|jDcgc]b}t|j|j|j |j |j|jtjd}}t|j}dddt|j|j|j|j |j"|j$t'|j$nd|j( ycc}w#1swYxYw)zOPersist the pool config + current hosts (with their live counts) for next time.)rrrr*rr updated_atN)rrPrrrQrr dead_host_ids)rrrrrrr*rrr#rrrrkrrPrrrr;r)rGrrdeads r3rzSandboxPool._save_cacheXs ZZ ,!KK ;;**!]]**!]]#yy{ E t**+D ,  II**;;#66nnBFBTBTB`*4+=+=>fjoo   , ,sDA'DDDD")rrh)r+r)r+r)(rPrQrRrSrrrrUr9r:rVr}r/rr rrr rnrWrrrrrrrrrrrrrrrr_r)r(rrrXr5r3rrs!J#`%""< $1E $$ #`%`% `%  `%  `%:`%Dj`%EkC'$.`%:`%`%Tz`%`% `%H>BX\4 c4 t4 3QU:4 an4 4 lc$s)<&*1E!& e#s(^d "eEkC'$. e  e  eN$3$$ :s:: 9$s)99 )0 'R'-=(>'CZ'8$T$L&/P^0DB>N>@$ 0$tCH~$RUX\R\$aq$LD'DdD ~$+@ r5rrct|jtr |jn t}|s t d|S)NzMA Hugging Face token is required to use sandboxes. Run `hf auth login` first.)r8r;rUrr)rr;s r3rrus0#CIIs3CIIE jkk Lr5rRrSrTrQrUrci|xsidtti}i|xsid|i} t|xsg} |tt||d<|r|| d<|jdt j d|d<|| d<t|d <| jtd t j td d dtg} | || | fS)aUBuild the (command, env, secrets, volumes) to launch a job running sbx-server. Shared by dedicated sandboxes and shared hosts: both fetch and exec the same unified `sbx-server` binary at startup (via `/bin/sh`), downloading it with wget/curl, or reading it off the always-mounted server bucket when the image ships neither. SBX_PORT SBX_TOKENrrz /buckets/z/resolve/sbx-serverSBX_SERVER_URL SBX_DL_TOKENSBX_SERVER_MOUNTbucketT)rpsource mount_path read_onlyz/bin/shz-c) rUrhrr;endpointrSANDBOX_SERVER_BUCKET_SERVER_MOUNT_PATHrr_BOOTSTRAP_DOWNLOAD) rr)rRrSrTrQrUrrkrlrmrZs r3rara|s&T#)Sj#>Q:RSG"Qgm"Qk="QKw}"%K&)*;L*I&J"#"* J#&<<. ):Y:Y9ZZm nG "*K#5G HY%D%DQcost$ 34G G[+ 55r5rrct|jtr |jni}d|vr?|j|j|jxsi}t|tr|ni}|S)z6Return a host job's env vars (where pool config lives)rr)r8 environmentrr%r)rrrrRs r3rrsY'>#//BCS ooSVVyoAMMSQST*c Jr5r!rcx|jdttt|i|D]}|cSt d|d)zNReturn any running host job belonging to `pool_id` (found via the pool label).rrrrr)r rerxrr)rrrrs r3rrsY}}*iW!MYb   *7)4K K r5ryc |j||}|jxsi}|jt}||jtt k7rt d|d|jjdk7r&t d|d|jjdtj||tt|||tjdz S) z?Reattach to a running host job and return its server transport.rrqz is not a sandbox host.rrz Sandbox host rsr"r]r^)r%r[rrgrerxrr&r'rrr4rrvr)rryrrr[r*s r3rwrws // / BC ZZ 2F JJ{ #E } :.);T+.EFGG zz9$];-7PQTQ[Q[QaQaPbbdeff  " " +,.s&EtD6{&Es)rfetch_job_logsrr)rrrrNliness r3r)r)sdS''v'KLeVWUJO?TYY&Eu&EE EVTVV s A A  A )^r0r-rrr#concurrent.futuresr contextlibr dataclassesrrpathlibrrSrtypingr r r r r rrrrsr_sandbox_cacherrrr _space_apirerrorsrrrhf_apirrutilsrrutils._parsingr get_loggerrPrirhrdrerfrxrrgrrrcrrur(rrArBrUr4r9r:r;r=rZrjrvrVrrr0rrrr2r_rrrrrarrrwrtrr)rXr5r3r`s  1%(MMM  EE"%*   H %     !   A' cCccc$e c 1$c$ ss s& CC C.  ANANH sT#Y td{ tCH~ 5>>htnss4sxkxkv"{{| ^  ^  B%C$6 $6$6 c3h$  $6 #s(^d " $6 &\D $6+#d*$6$6$6 49d38nd38nd6l BC$6N5wcDjT#s(^NR U S d V] LPu3cDjTb$ *# *#* *sCRVJAW *g'gcgHLZ\WWsW#*WTWWadWr5