}tj9ddlZddlZddlZddlZddlZddlmZddlmZddl 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"eKeAeffd0ZLd1ejMd"eeKfd2ZNd1ejMd"dfd3ZOGd4d5ZPGd6d7ZQGd8d9ZRGd:d;ZSdeKeAefdzd?eKeAefdzd@ee!dzdAeCeDzeAzdzdBeJdCeAd"eUeVeAeKeAefeKeAefee!ffdDZWd/dev/null 2>&1; then wget -q -O "$d" "$SBX_SERVER_URL" elif command -v curl >/dev/null 2>&1; then curl -fsSL -o "$d" "$SBX_SERVER_URL" else cp "$SBX_SERVER_MOUNT/sbx-server" "$d"; fi chmod +x "$d" unset SBX_SERVER_URL SBX_SERVER_MOUNT exec "$d" hf_tokennoncereturnctj|d|tjS)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 V/var/www/html/CA-Chatbot/venv/lib/python3.11/site-packages/huggingface_hub/_sandbox.py_derive_sandbox_tokenr4^sE 8HOO%%'selfs r3okzSandboxCommandResult.okzs~""r5ct|jdkr|jn|jdddz}d|jd|d|jdS)NPMz...zSandboxCommandResult(exit_code=z , stdout=z, duration_ms=))lenr?r>rC)rFouts r3__repr__zSandboxCommandResult.__repr__~sX --33dkkSbS9IE9Qrrr#rr_c_orrrrr5)__name__ __module__ __qualname____doc__r9__annotations__strrArBboolrCpropertyrGrNr5r3r=r=osIITz KKK KKKFC$JItK #D###X#s#ssssssr5r=ceZdZUdZeed<eeezed<eddZ ded<dZ edzed <dZ edzed <d Z e ed <dZedzed <ddZdS)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>r+cL|jdd|jdS)z:Terminate the background process (idempotent server-side).DELETEz /processes/N)r__requestrZrEs r3killzSandboxProcess.kills+ x)Atx)A)ABBBBBr5r+N)rOrPrQrRr9rSrTr rr_r`rarbrUr>rfrWr5r3rYrYs HHH tCy %UE:::Hi:::Ct $M3:$$$GT IsTz   CCCCCCr5rYcjeZdZUdZeed<eed<eded<eed<dZedzed<d Z eed <dS) FileEntryz%A file or directory inside a sandbox.namepath)filedirsymlinktypesizeNmtime_msmode) rOrPrQrRrTrSrr9rqrsrWr5r3ririsd// III III * ++++ IIIHcDjD#NNNNNr5ric eZdZdZdZdZdZd#d Zd ede fd Z d$d ed edefdZ d%d edee ze zdedzddfdZ d%deezd ededzddfdZd edeezddfdZdedeeeeffdZdeedeegefdeefdZd ededee fdZd ede dedzddfdZd edeefdZd edefdZd edefdZd&d ed eddfd!Zd eddfd"Z dS)' 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 sandboxr^r+Nc||_dSN)r_rFrxs r3__init__zSandboxFiles.__init__s  r5rkc||j}||jkr)d|||S|jddd|i}|jS)z=Read a file from the sandbox and return its content as bytes.r5GET /files/readrkparams)statrpPARALLEL_THRESHOLDjoin _read_rangesr_recontent)rFrkrpresponses r3readzSandboxFiles.readsnyy# $) ) )88D--dD99:: :=))%PT~)VVr5utf-8encodingcR|||S)z@Read a file from the sandbox and return its content as a string.)rdecode)rFrkrs r3 read_textzSandboxFiles.read_texts yy%%h///r5datarsc`t|tr|}n)t|ts|}t ||jkr||||dSd|i}|||d<|j dd||dS)zHWrite content to a file in the sandbox (parent directories are created).NrkrsPUT /files/writerr) r8rTr/bytesrrLr _write_rangesr_re)rFrkrrsrs r3writezSandboxFiles.writes dC  ;;==DDD%(( 99;;D t99t. . .   tT4 0 0 0 F$  !F6N unVTRRRRRr5 local_pathcZt|j}||jkr8||t||dSt |d5}||||ddddS#1swxYwYdS)z#Upload a local file to the sandbox.Nrb)rs)rrst_sizerr read_bytesopenr)rFrrkrsrpfs r3uploadzSandboxFiles.uploadsJ$$&&. $) ) )   tT*%5%5%@%@%B%BD I I I F *d # # +q JJtQTJ * * * + + + + + + + + + + + + + + + + + +s:B  B$'B$c ||j}||jkrYt|d5}|||D]}|| dddn #1swxYwYdS|jddd|i5}t|d5}|dD]}|| dddn #1swxYwYddddS#1swxYwYdS) z!Download a file from the sandbox.wbNr~rrkrrv) chunk_size) rrprrrrr__stream iter_bytes)rFrkrrprpartrchunks r3downloadzSandboxFiles.downloadsyy# $) ) )j$'' "1 --dD99""DGGDMMMM" " " " " " " " " " " " " " " " F ] " "5- " O O #S[j$'' #1%00K0HH##EGGENNNN# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #sG/A22A69A6D//C+ D+C/ /D2C/ 3DD DrpcP|jfdtdDS)Nc:g|]}|t|z fSrW)min).0offsetrrps r3 z(SandboxFiles._ranges..s,XXXUD6M223XXXr5r)PARALLEL_CHUNK_SIZErange)rFrprs `@r3_rangeszSandboxFiles._rangess6(XXXXX%4QVBWBWXXXXr5itemsfnct|jt|}t|5}t |||cdddS#1swxYwYdS)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_WORKERSrLrlistmap)rFrrworkersexecutors r3 _parallelzSandboxFiles._parallels d/U<<  ( ( 1H R//00 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1s#A""A&)A&cdtttfdtffd }||S)Nrngr+c^|\}}jdd||d}|jS)Nr~r)rkrlengthr)r_rer)rrrrrkrFs r3fetchz(SandboxFiles._read_ranges..fetchsE NFF}--}dfX^-_-_.H# #r5)tupler9rrr)rFrkrprs`` r3rzSandboxFiles._read_rangess_ $uS#X $5 $ $ $ $ $ $ $~~dll400%888r5cdtttfddffd }t |dS)Nrr+c ||\}}|d}|d<jdd||||zdS)N)rkrrsrrrr_re)rrrrrrsrkrFs r3pushz(SandboxFiles._write_ranges..pushs` NFF.2f%E%EF!%v M " "5.QUV\_ehn_nVnQo " p p p p pr5)rr9rrrL)rFrkrrsrs```` r3rzSandboxFiles._write_rangess qeCHo q$ q q q q q q q q q t||CII..55555r5c|jddd|i}d|dDS)z List a directory in the sandbox.r~z /files/listrkrc&g|]}tdi|S)rW)ri)rentrys r3rz%SandboxFiles.list..s&KKKu ""E""KKKr5entries)r_rejsonrFrkrs r3rzSandboxFiles.list sD=))%PT~)VVKK  0JKKKKr5c||jddd|i}tdi|S)z3Get metadata of a file or directory in the sandbox.r~z /files/statrkrrW)r_rerirrs r3rzSandboxFiles.stats?=))%PT~)VV++8==??+++r5cz ||dS#t$r}|jdkrYd}~dSd}~wwxYw)z+Check whether a path exists in the sandbox.TiNF)rr status_code)rFrkes r3existszSandboxFiles.existssW  IIdOOO4   }##uuuuu  s : 55:F recursivecVd|i}|rd|d<|jdd|dS)z*Delete a file or directory in the sandbox.rk1rrdz /files/deleterNr)rFrkrrs r3deletezSandboxFiles.deletes@$  &"%F;  xHHHHHr5cD|jddd|idS)z0Create a directory (and parents) in the sandbox.POSTz /files/mkdirrkrNr)rFrks r3mkdirzSandboxFiles.mkdir&s) v~vtnMMMMMr5)rxr^r+N)rrz)F)!rOrPrQrRrrrr|rTrrrr rrrrr9r rrr r rrrrirrrUrrrrWr5r3rurus))          00c0S0s0000 S S# SS5[8%; S3: SY] S S S S++t+3+cDj+TX++++ #S #cDj #T # # # #YCYDsCx$9YYYY1tCy1hucz.B1tCy111199C9DK99996#6U6#*66666LLiLLLL ,,,,,, 34II3I4IDIIIIN#N$NNNNNNr5rur[shellc|dur$t|tstd|dur$t|trtdd|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[Nr)r8rT ValueError)r[rpayloads r3 _exec_payloadr+sl }}ZS11}^___ ~~*S#..~mnnn$clG   Nr5rc#K|D]6}|stj|}|ddkr|V7dS)zJIterate NDJSON events from a streaming response, skipping keepalive pings.eventpingN) iter_linesrloadsget)rliners r3 _iter_eventsr7sf##%%   4   99W   ' 'KKK r5c| |d}n#t$r|jdd}YnwxYwt d|jd||j)zQRead the error body and raise a SandboxError (works for streaming responses too).errorNizSandbox API error (z): )r)rr Exceptiontextrr)rmessages r3_raise_for_statusrAs MMOOO&--//'* &&&-%& OX-AOOgOO]e]q r r rrs1A  A c&eZdZdZddddedededzd ed ed ed ed ededdfdZedddde d ed ed ed ededdfdZ e dedzfdZ dedede jfdZedededee jfdZddZddZdeddfdZdS)_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 0||_||_||_||_||_||_t ||_||_| |_ d|_ d|_ tj d|j|dtj||d|_dS)NrTBearer  AuthorizationzX-Sandbox-Token)rmax_keepalive_connections)headerslimitsfollow_redirects)rr_imagerr*_api_effective_token _auth_token_sandbox_tokenrliveverifiedhttpxClientLimits_client) rFrrrrr*rrrrs r3r|z_SandboxServer.__init__Ss       +C00+    |!=4+;!=!=#0<[jkkk!     r5jobc z||j|jj|jp|jt |||||| S)zIBuild a server from a freshly fetched job (reads its exposed server URL). rrrrr*rrrr)idrrj docker_imagespace_id_find_server_url)clsrr*rrrrs r3from_jobz_SandboxServer.from_job{sPs6)."2cl%c**'+    r5c|jSrz)rrEs r3rz_SandboxServer.images {r5methodrkc |dtjdd}|jj||j|zfd|i|}|jdkrt||S)z@Request to the in-job server. Raises SandboxError on API errors.timeoutgN@$@connect)poprTimeoutrrequestrrrrFrrkkwargsrrs r3rz_SandboxServer.requestsp**Y dD(I(I(IJJ'4<' 0D``g`Y_``  3 & & h ' ' 'r5c+K|dtjdd}|jj||j|zfd|i|5}|jdkrt||VddddS#1swxYwYdS)zJStreaming request to the in-job server. Raises SandboxError on API errors.rgQ@rrrN)rrrrstreamrrrrs r3rz_SandboxServer.streams**Y dD(I(I(IJJ T\ )= Y Yw YRX Y Y ]e#s**!(+++NNN                  s A77A;>A;c8|jdSrz)rcloserEs r3rz_SandboxServer.closes r5cR|j|j|jdS)Nr namespace)r cancel_jobrrrEs r3r"z_SandboxServer.cancel_jobs' DK4:FFFFFr5 start_timeoutc tj|z}d}tj|krA |j|jdzt jd}|jdkrdSn#tj$rYnwxYwtj|z dkrtj}|j |j |j }|j j tvrUt|j|j |j }t!d |j d |j j d |j jd |tjdtj|kAt!d |j d|dd)zMPoll /health until the server answers; fail fast (with logs) if the job dies.gz/healthg@)rNg@r r!z Sandbox job z$ terminated during startup (status: z , message: ).g333333?z did not become ready within z.0fzs.)timerrrrrr RequestErrorr inspect_jobrrstatusstage_TERMINAL_STAGES_tail_job_logsrrsleep)rFr#deadlinelast_job_checkrrlogss r3 wait_readyz_SandboxServer.wait_readys9;;.ikkH$$ <++DMI,Eu}]`OaOa+bb'3..F/%    y{{^+c11!%i++4;$*+UU:#'777)$)T[DJWWWD&^t{^^$'J$4^^ADAS^^W[^^ Jt   !ikkH$$"i$+iiTaiiiijjjsAA66BBrg)rOrPrQrRrTrr9r| classmethodrr rVrrResponserrr rrr"r:r3rWr5r3rrKs " "& & & &  & Tz &  & & & & & &  & & & & P "                [ .sTzXc5>S(5>:R^GGGGkk$kkkkkkr5rc eZdZdZedddededfdZedddedegdffd Zdd dededfd ZdS) _KillMethodz>Lets `kill` work both as a classmethod and an instance method.instanceNrr+).NcdSrzrWrFr8rs r3__get__z_KillMethod.__get__sKN3r5r^cdSrzrWr:s r3r;z_KillMethod.__get__sORsr5Sandbox | Nonec h||jSddddtdtdzdtdzddffd}|S)Nr!token sandbox_idr!r@r+c\|||dS)Nr?)rrf)rAr!r@rs r3rfz!_KillMethod.__get__..kills- MM* M G G L L N N N N Nr5)_killrT)rFr8rrfs ` r3r;z_KillMethod.__get__sx  > !=AW[ O O OS Od  O#PT* O`d O O O O O O r5)rOrPrQrRrror r;rWr5r3r7r7sHH NNTNhy6INNNXN R R$R8BH;MRRRXR 0(9BUr5r7ceZdZdZdedededzdededdf d Zee fd e ddddd d dd dedede e zezdzde eefdzde eefdzdeedzdedzdede dedzddfdZeddddededzdedzddfdZeZd@dZd@dZdAdZd@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"dBd4d5d6e ezd7ed8edefd9Z#e de eeffd:Z$defd;Z%dZ(e)d>> 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||_ dS)Nz/v1/v1/sandboxes/F) r_server _local_id _base_path _owns_sandbox _owns_server_on_kill_killedrufiles)rFrrErFrGrHs r3r|zSandbox.__init__si !$,#3%%9T(9T9T*(<@  !$'' r5 cpu-basicF^@) flavor idle_timeoutenvsecretsvolumesr!forward_hf_tokenr#r@rrUrVrWrXrYr!rZr#r@c t| } t| } td} t| | }t | | ||||||\}}}}| |||||t tdttt| i|pdtg| }d} t || || tjdz}|| n#t"$r| | |j|jj n<#t"$r/}t,d |jd |Yd}~nd}~wwxYw||wxYw||j|dd d S)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@rwrWrXrYrVrZrrN rcommandrWrXrUrlabelsrYexposer!rr*rrrr zFailed to cancel sandbox job  after startup failure: TrrErFrGrH)rrrr4_bootstrap_job_specrun_jobSANDBOX_MAX_LIFETIME SANDBOX_LABEL MODE_LABELMODE_DEDICATED NONCE_LABELSANDBOX_SERVER_PORTrr rurr3rr"rrrjloggerwarningr)r rrUrVrWrXrYr!rZr#r@rr)r*rr_job_env job_secrets job_volumesrrErs r3createzSandbox.createsf%   #C((" -h>> 5H  %-' 6 6 6 2+{kk(!3 NKQVW'4'(   +/ #,,+ , AA E -F   m , , , ,    dcf GGGG d d dbsvbb_`bbcccccccc d!   scfVd[_````s7$AC&& E,1&DE, E"%E E, EE,r?rAc>t|}t||\}}t|vr|td\}}t |||} d|ddD}||vrtd|d|d n##t$r| wxYw||||d d S| || } | j pi} | t} | tdks| td|dtd| tt krtd|dtd| jjdkr td|d| jjdt't)|| } t*| | | |t.jdz}|| j|dd d S)z?Reattach to a running sandbox from anywhere, using only its id.r\rr&ch|] }|d SrrW)ritems r3 z"Sandbox.connect..osaaa4DJaaar5r~ /v1/sandboxeszSandbox z no longer exists on host r#FTrer rNJob z is not a sandbox (missing 'z ' label).z` is a sandbox host, not a single sandbox. Connect to one of its sandboxes with id 'z '.RUNNING is not running (status: r'rbrc)r_split_sandbox_id SHARED_ID_SEPsplit _connect_hostrrrrrr*r`rrlrirj MODE_POOLr+r,r4rrr rurr) r rAr!r@r host_job_idrFrEexistingrr`r*rs r3rzSandbox.connectfss%    1*i H H I J & &$.$4$4]A$F$F !K"3 yIIIF aa6>>%3Y3Y3^3^3`3`aaa8++&'f*'f'fXc'f'f'fggg,     3*VhUZhlmmm mooZ9oEE!r ;'' ::m $ $ + +u}fjffmfffgg g ::j ! !Y . .OzOO3@OOO  : y ( (c*ccszO_cccdd d-.>s.C.CUKK (('(=A )  scfVd\`aaaas A B++ C c|jrdS |j|jn#|jdd|jn=#t $r0}t d|jd|Yd}~dSd}~wwxYwd|_|j | ||j r|j dSdS)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. NrdrJzFailed to kill sandbox : T) rQrLrKr"rrrnrorrPrOr)rFrs r3rCz Sandbox._kills <  F ~% '')))) $$X/P/P/PQQQ    NNCTWCCCC D D D FFFFF  = $ MM$      ! L    ! !sAA B %BB cJ|jr|jdSdS)zRelease the local HTTP client without terminating the sandbox. Idempotent. No-op for pool sandboxes (the client belongs to the pool's host). N)rOrKrrEs r3rz Sandbox.closes3   ! L    ! !r5c|SrzrWrEs r3 __enter__zSandbox.__enter__ r5ch|jr|dS|dSrz)rNrfrrFexc_infos r3__exit__zSandbox.__exit__s/    IIKKKKK JJLLLLLr5.) rrWcwdrstdin on_stdout on_stderrcheck backgroundr[rrrrrrrrc dSrzrW) rFr[rrWrrrrrrrs r3runz Sandbox.runs  #sr5)rrWrTcdSrzrW)rFr[rrWrrs r3rz Sandbox.runs r5c  t||} |r|| d<|r|| d<| rV|dd| } t| d|| d|S||| d <||| d <g} g}d }|dd | 5}t |D]}|d dkr/| |d|||d>|d dkr/||d|||dy|d dkr|t|dd | d ||d|dd|dd} d d d n #1swxYwY|td| r#|j dks|j rt|||S)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`. rWrr /processesrrZr`)rZr[r`r_Nrrz/execrr?rr@exitr>rrrArBFrCr)r>r?r@rArBrCz%connection lost while running command)r[result)rrerrYrrrappendr=rrr>rBr)rFr[rrWrrrrrrrrr stdout_parts stderr_partsrrrs r3rz Sandbox.runsh U++  ! GEN  ! GEN  `==G=DDIIKKD!d5ksZ^___ _  !(GI   $GG "$ "$ .2 \\&'\ 8 8 H%h//  >X-- ''f 666 ,! %-0007^x// ''f 666 ,! %-0007^v--1"' "4!ww|44!ww|44$yy22"'))K"?"?$)IImQ$?$? F                & >FGG G  >f&!++v/?+%#f=== = s#DGG Gcpdd}fd|DS)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. r~rc g|]c}t|d|d|d|d|d|ddS)rZr[r`rarbr>)rZr[r`rarbr>r_)rYr)rprFs r3rz%Sandbox.processes..;s}     eHeHEE%LLeeO44) %% ,,       r5)rer)rFrs` r3 processeszSandbox.processes3sQ}}UL116688         r5c|jjSrz)rKrrEs r3rz Sandbox.imageJs |!!r5c,|j |jjndS)zIFor a shared/pool sandbox, the job id of the host running it (else None).N)rLrKrrEs r3host_idzSandbox.host_idNs'+n&@t|""dJr5/zhttps://)schemeportrkrc|jjddd}|dr|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://rrz/proxy/)rKrr startswithrM)rFrrkr host_and_rests r3 proxy_url_forzSandbox.proxy_url_forUsgL -33E1==bA s++;tttM-MMMMtMMMr5c:d|jj|jjdS)zPAuth headers to send with [`proxy_url_for`] requests (HF token + sandbox token).rr)rKrrrEs r3 proxy_headerszSandbox.proxy_headerss,Bt|'?AA#|:   r5c(d|jd|jdS)Nz Sandbox(id=z, image=rK)rrrEs r3rNzSandbox.__repr__s?TW?? ????r5rresourcec :|jj||j|zfi|Srz)rKrrM)rFrrrs r3rezSandbox._requests(#t|#FDOh,FQQ&QQQr5c+|K|jj||j|zfi|5}|VddddS#1swxYwYdSrz)rKrrM)rFrrrrs r3rzSandbox._streams T\ 8)C N Nv N N RZNNN                  s 155rg)r+r^)r),rOrPrQrRrTrrUr|r4 DEFAULT_IMAGEDEFAULT_IDLE_TIMEOUTr9r:dictr r rrsrr7rfrCrrrrr rr=rrYrrVrrrrrNrr5rerr rrWr5r3r^r^sd  ( ( ( * (  (( ((((:#ba"1E%))-'+ $!&$ babababa ba EkC'$. ba #s(^d " bac3h$&baf$ba:bababaTzba bababa[baHAE[_$b$b$b$bC$J$bcTXj$bdm$b$b$b[$bP ;==D!!!!.!!!! !%( #2525%( # # # 49_ #d{ # #s(^d " # 4Z # #Tz #SE4K(4/ #SE4K(4/ # #EN #  # # #X # !%(  49_d{  #s(^d "  4Z DM X"%) $ 2626 [[[ 49_[d{ [ #s(^d " [ 4Z [[Tz[SE4K(4/[SE4K(4/[[[  .[[[[z 4/    ."sTz"""X"KtKKKXK (Nz(N(N(N#)(N3(N(N^a(N(N(N(NT tCH~   X @#@@@@ RsRcRRRRRcSx?W^r5r^creZdZdZefdedddeddddd 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 ``` rSrNrTF) rUsandboxes_per_hostwarm_up max_hostsrjrVr!r#r@ _connect_moderrUrrrrjrVr!r#r@rr+c X|dkrtd|dkrtdt| |_||_||_||_||_||_||ndtd|_ ||_ ||_ | |_ g|_ tj|_tj|_tj|_d|_d|_| |_| |_t/|_| s|dSdS) 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.r\Nzpool-F)rrrrrUr_warm_uprrrj _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) rFrrUrrrrjrVr!r#r@rs r3r|zSandboxPool.__init__s9l  ! !?@@ @ Q;;455 5&&&   "4 " ,DD2H)A,,2H2H )#+,. ^%% &N,, $.** #0 -,(+  %  " " $ $ $ $ $ % %r5r?pool_idc `t|}|6||j|j|j|j||j||jn||d St|}t|||}t|||}| d}| d} ||j p |j pt|jt|jndt| d 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) rrUrrrjrVr!r@rr\r&SBX_IDLE_TIMEOUT SBX_MAX_HOSTSrS SBX_CAPACITY)rrrUrrrVr!r_find_pool_host_job _host_envrr r rrTr9DEFAULT_SANDBOXES_PER_HOST) r rr!r@cacherrrWidle_raw max_hosts_raws r3rzSandboxPool.connectsM. ((  3k|#(#;/"/-6->%//I"    %   !#w)DDDSI66677-..00 s"CclCm&)j&<3sz???+"377>;U#V#VWW,9,Ec-(((4*2*>XD    r5 num_hostsc|jrtd||j5|t |jz }dddn #1swxYwY|dkrN||}|j5|j|dddn #1swxYwY|j5d|_ dddn #1swxYwY| |j S)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_hostsrrLr_provision_hostsextendrr _save_cachehost_ids)rFr shortfallbooteds r3warmzSandboxPool.warmTs < ><== =  Z 5 5!C $4$44I 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 q==**955F + + ""6*** + + + + + + + + + + + + + + +   # #"DO # # # # # # # # # # # # # # # }s5AAAB**B.1B.<CCC)rWrVrZrWrZr^c |jrtdt|pi}|rt|j|d<|t |nd}g d}d} | |}|,|s*d}||}|Q|j r5|r3|j s,t|j td|j d| }| ||||} nK#t$r>|j5t#d|jd z |_dddn #1swxYwYwxYw| || S| vr |d}|d z }|t*krtd O#t$r|j5 fd |j D|_ dddn #1swxYwY D]U} |n#t$rYnwxYw|=#|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.cg|]}|v| SrWrW)rh new_hostss r3rz&SandboxPool.create..s#LLLQ)9K9Kq9K9K9Kr5)rrrrrr;r _reserve_onerrrrrj_boot_one_host _create_onerrmaxrrremove_MAX_PACK_ROUNDSr"r) rFrWrVrZ sandbox_env idle_secs discoveredroundshostrxrs @r3rszSandboxPool.createos: < ><== =39"oo  B&6ty&A&AK #8D7O%l333UY *,  <   " " $ $ $, ((**< >(+Aty1}(=(=DI>>>>>>>>>>>>>>>  *((***& y((!((..." ! ,,,&tU, Z    M MLLLL$+LLL  M M M M M M M M M M M M M M M! ! !!OO%%%% DJJLLLLDJJLLLL  sB,G D! G!E)2E E)E E)#E $E))GIHI H(%I'H((I+IIIcl|j5t|jcdddS#1swxYwYdS)z*Number of host jobs currently provisioned.N)rrLrrEs r3rzSandboxPool.num_hostss}Z $ $t{## $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $s )--c|j5td|jDcdddS#1swxYwYdS)zz,SandboxPool.num_sandboxes..s$99Tty999999r5N)rsumrrEs r3 num_sandboxeszSandboxPool.num_sandboxessZ : :99T[99999 : : : : : : : : : : : : : : : : : :s 377cf|j5d|jDcdddS#1swxYwYdS)z!Job ids of the provisioned hosts.cg|] }|j SrWrrs r3rz(SandboxPool.host_ids..s888DDK888r5N)rrrEs r3rzSandboxPool.host_idssZ 9 988DK888 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9s &**c|j5|j}g|_d|_dddn #1swxYwY|D]} |jr|n<#t $r/}t d|jd|Yd}~nd}~wwxYw| p#| wxYw|jrt|j dSdS)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) rrrrr"rrnrorrrrj)rFhostsrrs r3rzSandboxPool.closesMZ  KEDKDL                 D #&OO%%% T T TR RRqRRSSSSSSSS T    ) di ( ( ( ( ( ) )s;*..AB' B %B B' BB''B=c|SrzrWrEs r3rzSandboxPool.__enter__rr5c.|dSrz)rrs r3rzSandboxPool.__exit__s r5c|j5|jr ddddS||j|jnt |j|j}|j5|t|jz }dddn #1swxYwY|dkr| |j s|j5|t|jz }dddn #1swxYwY|dkrN| |}|j5|j |dddn #1swxYwYd|_dddn #1swxYwY|jr| dSdS)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_cacherrrrrLrrrrrr)rFtargetrrs r3rzSandboxPool._ensure_warmed_ups   # #  # # # # # # # #  ' ' ) ) )&*n&>$*S-=-=$= >>>>>>>>>>>>>>> 1}}!%!6!6y!A!A!Z77 K..v666777777777777777"DO' # # # # # # # # # # # # # # #, ;           s EAE!B9 EB E B +E8C EC E#C $%E D0$ E0D4 4E7D4 8 EEE_SandboxServer | Nonec|j5|jD]5}|j|jz dkr |xjdz c_|ccdddS6 dddn #1swxYwYdS)zNReserve one slot on the first host with free capacity (under lock), else None.rrN)rrrrrFrs r3rzSandboxPool._reserve_one1s Z     =49,q00IINIIKK         0                ts0AAAArrc|j5|}||cdddS|r$|}||cdddS|d}|||j5|j|dddn #1swxYwY|cdddS#1swxYwYdS)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)rFrrrs r3rzSandboxPool._boot_one_host:s_ ' '$$&&D  ' ' ' ' ' ' ' ''')) ((**# ' ' ' ' ' ' ' '**1--F   V $ $ $ + + ""6*** + + + + + + + + + + + + + + +$$&&! ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' 's@C(+C(%1C(B=1 C(=C C(C C((C,/C,c d|jDtfd|jdtt t |ji|jDddSt d|jdj d tj |j z}tj |kr|jj |j jj}|d vrdS|d kr6|t%fd |jDrdStjdtj |kdS)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. ch|] }|j SrWrrs r3rxz2SandboxPool._adopt_pending_host..^555555r5c3.K|]}|jv |VdSrzrvrrknowns r3rz2SandboxPool._adopt_pending_host..`s@   6&&  '&&&  r5 SCHEDULINGr+r`r!NFzPool 'z' host z: is already SCHEDULING; waiting for it instead of booting.r )rr{r{c38K|]}|jjkVdSrzrr)rrpendings r3rz2SandboxPool._adopt_pending_host..ws,IITt{gj0IIIIIIr5Tg?)rnextr list_jobsrjr POOL_LABELrjrrndebugrr(rr*r+r,ranyr/)rFr0r,rrs @@r3rzSandboxPool._adopt_pending_hostVs65555    9..'& :tyI"o/        ?5 vdivv vvvwww9;;!44ikkH$$I))t)WW^dE555u !!$$&&&IIIIT[IIIII 4 JsOOOikkH$$ur5cd|jDfd|jdttt |ji|jD}|D]~d} t|jj |j}t|j|j}t| d|j |_t|dd |_ne#t&t(jt,f$rF}t.d j d |||Yd}~d}~wwxYw|j5t7fd |jDr|n|j|dddn #1swxYwYdS) 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. ch|] }|j SrWrrs r3rxz.SandboxPool._discover_hosts..rr5c&g|] }|jv |SrWrvrs r3rz/SandboxPool._discover_hosts..s4    vU""  #""r5r{rNr&rr~ryzSkipping host z during discovery: c38K|]}|jjkVdSrzr)rrrs r3rz.SandboxPool._discover_hosts..s,EEt{cf,EEEEEEr5)rrrrjrrrjrrrrr9rrrrLrrrrr HTTPErrorrrnrrrrr)rFmatchesrErWrrrs @@r3rzSandboxPool._discover_hosts|s-65555    y** "Iz49E/+    / /CF &ty#&DOTTT  3$/JJJ"%cggnd>U&V&V"W"W!&.."H"H"M"M"O"OPP  %/>B    LcfLLLLMMM%LLNNN   / /EEEEEEEEE/LLNNNNK&&v...  / / / / / / / / / / / / / / /! / /s,"B$DE)#;E$$E)3AGG G num_newc  j5tj}dddn #1swxYwYjD||zjkr6j|z }t d|djdt d|dt t|d5 fd t|D}dddn #1swxYwYg}d}|D]C} | | +#t$r }|}Yd}~.s'PPPAxt77PPPr5)rrLrrrrrrrrrrr"r) rFr%currentallowedfuturesrrfuturerrErs ` @r3rzSandboxPool._provision_hostssn Z ' '$+&&G ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' > %'G*;dn*L*Lnw.G_g__4>__"1g___  C,<,< = = = QPPPPPwPPPG Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q')"&  F  fmmoo....        # ##%%'''' DLLNNNNFLLNNNNK s`+//CC C 'D DDD$D98E9 EEEEE4c t|j}td}t||}t |j|ddd|jd|\}}}}d|d<t |j|d<|jt |j|d<tdttt|j t|i}|j|j||||jt$||pdt&g|j } d} t*| |||jt/|jd zd |j } | |jn#t4$r |j| j| jj n<#t4$r/} t<d| jd| Yd} ~ nd} ~ wwxYw| | wxYw| S)z6Start one host job and wait until its server is ready.rwNFr]r SBX_HOST_MODErrr^r()rr*rrrrr rrd)!rrrr4rfrrTrrrirjrrrjrlrgrrUrhrmrrr rr3rrr"rrrnror) rFr)r*rr_rprqrrr`rrErs r3r+zSandboxPool._boot_hosts/#DI.." -h>> 5H I +"' 6 6 6 2+{$' #&d&=">"> > %'*4>':':GO $j)ZT_afgi*;('4'(o   +/ $,,+I #D$;a$? E E0 -F   d1 2 2 2 2    e $$CFcin$MMMM e e eccc`accdddddddd e!    s7?AE G%%+FG% G %GG%G  G%rrr=cddi}|||d<|r||d< |dd|}nf#ttjf$rM}|jrt d |jd || |Yd}~dSd}~wwxYwd |_| d pg}t| d ds|s-|j 5|j |_dddn #1swxYwYdS|d}t|jt |d||dd d} |j| _| S)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_secsrWrryrz!Dropping unreachable cached host rT sandboxesrejectedrrFre)rrrrr#rrnrr _drop_hostrr9rrrr^r~_on_sandbox_killedrP) rFrrWrbodyrrr7rwrxs r3rzSandboxPool._create_ones!(|  (1D$ %  DK <<d<CCHHJJDDeo.   }  LLOT[OOAOO P P P OOD ! ! !44444    HH[))/R txx A&& ' ' y  * * M  * * * * * * * * * * * * * * *4|+:}:d4j::$Z     2s(*?B"ABB"/ DD D rxc|j5td|jjdz |j_ddddS#1swxYwYdS)z:Free the packing slot of a shared sandbox that was killed.rrN)rrrKrr{s r3r:zSandboxPool._on_sandbox_killed+s Z D D#&q'/*>*B#C#CGO  D D D D D D D D D D D D D D D D D Ds(=AAc|j5fd|jD|_|jjdddn #1swxYwYdS)zFForget a host found dead this session (and mark it for cache pruning).cg|]}|u| SrWrW)rrrs r3rz*SandboxPool._drop_host..3sCCCQd]]1]]]r5N)rrraddrrr s `r3r9zSandboxPool._drop_host0s Z 1 1CCCCdkCCCDK   # #DK 0 0 0 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 s8A  AAc,t|j}|dSt|j}|j5d|jD}|jD]}|j|vs|j|j krt|j|j |j |j |jt||j|jt!|jdzd|j  }|j|_d|_|j| ddddS#1swxYwYdS)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. Nch|] }|j SrWrrs r3rxz5SandboxPool._seed_hosts_from_cache..Fs999TT[999r5r(r3rF)rrjrrrrrrrrrrrrr*r4rrrr)rFrr)rchrEs r3rz"SandboxPool._seed_hosts_from_cache9sg  ** = F#DI.. Z + +99T[999Ek + +9%%BK)?)?'9(*[("7"("K"K $'(?!(CS$I$I[   !g "' ""6****! + + + + + + + + + + + + + + + + + + +sCD  D D c 0|j5d|jD}t|j}dddn #1swxYwYt |j|j|j|j|j |j t|j nd|j || dS)zOPersist the pool config + current hosts (with their live counts) for next time.c g|]G}t|j|j|j|j|j|jtjHS))rrrr*rr updated_at)rrrrr*rrr(rs r3rz+SandboxPool._save_cache..\s`   ;*!]*!]#y{{   r5N)rrUrrrVr!r dead_host_ids) rrrrrrjrrUrrrr;r)rFrdeads r3rzSandboxPool._save_cacheYs Z , ,  !K   Et*++D , , , , , , , , , , , , , , ,  I*;#6nBFBTB`*4+=>>>fjo s &:>>)rrg)r+r)r+r )(rOrPrQrRrrrrTr9r:rUr|r4rr rrr rsrVrrrrrrrrrrrrrr+rr^r:r9rrrWr5r3rrs9!!J#`%""< $1E $$ #`%`%`%`% `%  `%  `%:`%Dj`%EkC'$.`%:`%`%Tz`%`% `%`%`%`%H>BX\4 4 4 c4 t4 3QU:4 an4 4 4 [4 lc$s)<&*1E!& eee#s(^d "eEkC'$. e  e  eeeeN$3$$$X$ :s:::X: 9$s)999X9 ))))0 ''''R'-=(>'CZ''''8$T$$$$L&/&/&/&/P^0DB>N>>>>@$ 0$tCH~$RUX\R\$aq$$$$LD'DdDDDD ~$++++@      r5rrct|jtr|jn t}|st d|S)NzMA Hugging Face token is required to use sandboxes. Run `hf auth login` first.)r8r@rTrr)rr@s r3rrvs?#CIs33 DCIIE ljkkk Lr5rWrXrYrVrZrci|pidtti}i|pid|i} t|pg} |tt||d<|r|| d<|jdt jd|d<t|d <| td t jtd 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_TOKENNrrz /buckets/z/resolve/sbx-serverSBX_SERVER_URLSBX_SERVER_MOUNTbucketT)rosource mount_path read_onlyz/bin/shz-c) rTrmrr;endpointrSANDBOX_SERVER_BUCKET_SERVER_MOUNT_PATHrr_BOOTSTRAP_DOWNLOAD) rr)rWrXrYrVrZrrprqrrr_s r3rfrf}s&T#)Sj#>Q:R:RSSG"Qgm"Qk="Q"QKw}"%%K&)*;L*I*I&J&J"#+"* J#&< n n):Y n n nG #5G HY%DQcosttt$ 34G G[+ 55r5rr!ct|jtr|jni}d|vr<||j|jpi}t|tr|ni}|S)z6Return a host job's env vars (where pool config lives)rr )r8 environmentrr*r)rrr!rWs r3rrsf'>> F#//BCS  ooSVyoAAMSQST**2cc Jr5r&rc|dttt|i|D]}|cSt d|d)zNReturn any running host job belonging to `pool_id` (found via the pool label).r{rrr)rrjrrr)rrr!rs r3rrsl}}*iW!MYb  K7 K K K  r5rc |||}|jpi}|t}|#|tt krt d|d|jjdkr t d|d|jjdt ||tt|||tjd z S) z?Reattach to a running host job and return its server transport.r Nrzz is not a sandbox host.r{z Sandbox host r|r'rbrc)r*r`rrlrjrrr+r,rr r4rrur)rrr!rr`r*s r3rrs // / B BC Z 2F JJ{ # #E } :..);;F+FFFGGG z9$$e;eeQTQ[Qaeeefff  " " +,.s(&E&Et{D{{&E&E&E&E&E&Er5)rfetch_job_logsrr)rrr!raliness r3r.r.sS''v'KKLLeVWWU rrIN V?TYY&E&Eu&E&E&EEE E ETVVs -0 >>)^r0r-rrr(concurrent.futuresr contextlibr dataclassesrrpathlibrrXrtypingr r r r r rrrrrr_sandbox_cacherrrr _space_apirerrorsrrrhf_apirrutilsrrutils._parsingr get_loggerrOrnrmrirjrkrrrlrrrhrr~r-rrTrUrTr4r9r:r;r=rYrirurUrrr5rrrr7r^rrrrrfrrrr}r r.rWr5r3rss  111111%%%%%%((((((((MMMMMMMMMMMMMMMMMM  EEEEEEEEEE""""""""%%%%%%%%******  H % %     !   A' cCcccccc$e c 1$c$$$$ sssssss s& CCCCCCC C.  ANANANANANANANANH sT#Y td{ tCH~    5>htnss4ssssxkxkxkxkxkxkxkxkv"{{{{{{{{| ^  ^  ^  ^  ^  ^  ^  ^  B%C#6 #6#6 c3h$  #6 #s(^d " #6 &\D #6+#d*#6#6#6 49d38nd38nd6l BC#6#6#6#6L5wcDjT#s(^NR   U S d V]    LPu3cDjTb$ *# *#* *sCRVJAW * * * *g'gcggggHLZ\WWWWsW#*WTWWadWWWWWWr5