,h^PUddlmZddlZddlZddlZddlZddlZddlm Z ddl m Z m Z m Z ddlZddlZddlmZddlmZddlZddlmZmZmZmZmZmZdd lmZmZdd lmZe r dd l m!Z!m"Z"m#Z#dd l$m%Z%m&Z&dd l'm(Z(e%dZ)e dZ*GddejVZ,e,Z-edZ.de/d<dZ0e Z1eGddZ2edZ3de/d<ejhd.dZ5d/dZ6d0dZ7d1dZ8ejrdd Gd!d"Z:ejrdd Gd#d$e e*Z;ejrdd Gd%d&e e*Z d3d*Z?dd+ d4d,Z@dd+ d5d-ZAy)6) annotationsN)count) TYPE_CHECKINGGenericTypeVar)define)current_async_library_cvar)RunVar TrioToken checkpointdisable_ki_protectionenable_ki_protectionstart_thread_soon)CapacityLimiterEvent)coroutine_or_error) AwaitableCallable Generator) TypeVarTupleUnpack) RaiseCancelTTsRetTc:eZdZUdZded<ded<ded<ded <y ) _ParentTaskDatazqGlobal due to Threading API, thread local storage for data related to the parent task of native Trio threads.r tokenboolabandon_on_cancelzlist[RaiseCancelT | None]cancel_registerzlist[trio.lowlevel.Task | None] task_registerN)__name__ __module__ __qualname____doc____annotations__O/var/www/html/Resume-Scraper/venv/lib/python3.12/site-packages/trio/_threads.pyrr)s!+ ..22r)rlimiterzRunVar[CapacityLimiter]_limiter_local(c"eZdZUded<ded<y)_ActiveThreadCountintrreventNr#r$r%r'r(r)r*r/r/<s J Lr)r/active_threadszRunVar[_ActiveThreadCount]_active_threads_localc#K tj}|xj dz c_ d|xj dzc_|j dk(r*|jj t |_yy#t$r,tdt }tj |YwxYw#|xj dzc_|j dk(r*|jj t |_wwxYww)Nrr )r4get LookupErrorr/rsetrr1active_threads_locals r*_track_active_threadr;Es8488: !#1 ""a'"  % % * & & * * ,). & + 81!UW=!!"678 ""a'"  % % * & & * * ,). & +s?D BD B9AD 2B63D 5B66D 9AD  D cKtd{ tj}|jdk7r3|j j d{|jdk7r2yy7\#t$rYywxYw7'w)aWait until no threads are still running tasks. This is intended to be used when testing code with trio.to_thread to make sure no tasks are still making progress in a thread. See the following code for a usage example:: async def wait_all_settled(): while True: await trio.testing.wait_all_threads_complete() await trio.testing.wait_all_tasks_blocked() if trio.testing.active_thread_count() == 0: break Nr)r r4r6r7rr1waitr9s r*wait_all_threads_completedr>Ws ,488:  $ $ )"((--///  $ $ )   0sCBA-BA/,BA>B+B/ A;8B:A;;Bc^ tjjS#t$rYywxYw)zwReturns the number of threads that are currently running a task See `trio.testing.wait_all_threads_completed` r)r4r6rr7r(r)r*active_thread_countr@ss. $((*000 s  ,,c tj}|S#t$r(tt}tj |Y|SwxYw)zGet the default `~trio.CapacityLimiter` used by `trio.to_thread.run_sync`. The most common reason to call this would be if you want to modify its :attr:`~trio.CapacityLimiter.total_tokens` attribute. )r,r6r7r DEFAULT_LIMITr8)r+s r*current_default_thread_limiterrC~sJ$ $$& N $!-07# N$s-A A F)eqslotsceZdZUded<y)ThreadPlaceholderstrnameNr2r(r)r*rGrGs Ir)rGceZdZUded<ded<ej dejZded<ej de jZ d ed <e dd Z dd Zdd ZddZddZy)RunzCallable[..., Awaitable[RetT]]afntuple[object, ...]argsFinitfactorycontextvars.Contextcontext/stdlib_queue.SimpleQueue[outcome.Outcome[RetT]]queuecbKt|jg|j}|d{S7wN)rrLrN)selfcoros r*unprotected_afnzRun.unprotected_afns'!$((7TYY7zzs &/-/cKtjj}|j}|jj |_tjj d{t j|jd{}||_tjj d{|jj|y7t7O7$wrW) triolowlevel current_taskrScopycancel_shielded_checkpointoutcomeacapturerZrU put_nowait)rXtask old_contextresults r*runzRun.runs}}))+ll ||((* mm66888''(<(<==" mm66888 f% 9=8s6A+C(-C".&C(C$,C(C&!C($C(&C(cKtj|jd{}|jj |y7 wrW)rarbrZrUrcrXrfs r* run_systemzRun.run_systems6''(<(<== f%>s#AA!AcXtjdfd }|j|y)Ncd}|Jdtjj|tjyNrz)guaranteed by abandon_on_cancel semanticsr\r] rescheduleraValuerdrXr"s r*in_trio_threadz,Run.run_in_host_task..in_trio_thread9 #D# P%P P MM $ $T7==+> ?r)returnNonePARENT_TASK_DATAr" run_sync_soonrXrrrr"s` @r*run_in_host_taskzRun.run_in_host_task$(66  @ N+r)c4dfd }|j|y)Nc( tjjjjj y#t $rDjjtjtjdYywxYw)N)rIrSzsystem nursery is closed) r\r]spawn_system_taskrjrLrS RuntimeErrorrUrcraErrorRunFinishedError)rXsr*rrz1Run.run_in_system_nursery..in_trio_threadso  //OO LL0    %%MM$"7"78R"ST sAAA BBrt)ry)rXrrrs` r*run_in_system_nurseryzRun.run_in_system_nurserys  N+r)Nrurrtrr rurv)r#r$r%r'attrsfield contextvars copy_contextrS stdlib_queue SimpleQueuerUrrZrgrjr{rr(r)r*rKrKs '' #.5;; (($G >IU[[ ((>E :  &&, ,r)rKceZdZUded<ded<ej dejZded<ej de jZ d ed <e dd Z dd Zdd ZddZy)RunSynczCallable[..., RetT]fnrMrNFrOrRrSrTrUc $|jj|jg|j}t j |rI|j tdjt|jd|j|S)NzITrio expected a synchronous function, but {!r} appears to be asynchronousr%) rSrgrrNinspect iscoroutineclose TypeErrorformatgetattr)rXrets r*unprotected_fnzRunSync.unprotected_fnspdlltww33   s # IIK%vgdgg~tww&OP   r)cxtj|j}|jj |yrW)racapturerrUrcris r*run_synczRunSync.run_syncs(!4!45 f%r)cXtjdfd }|j|y)Ncd}|Jdtjj|tjyrmrnrqs r*rrz0RunSync.run_in_host_task..in_trio_threadrsr)rtrwrzs` @r*r{zRunSync.run_in_host_taskr|r)c:|j|jyrW)ryr)rXrs r*rzRunSync.run_in_system_nurserys DMM*r)Nrrtr)r#r$r%r'rrrrrSrrrUrrrr{rr(r)r*rrs| #.5;; (($G >IU[[ ((>E :   &,+r)r) thread_namer r+c Ktjjd{t|  t tjj gdg dt t}t|d fd tjj |8tdddtjj j}d  fd }tj jtj dd fd }j#d{t%5 t'|||d fd } tjj+|d{} t-| t.j0r| j3cdddSt-| t4r| jd{n0t-| t6r| j9nt;d | d ~ 77#j)xYw77U#1swYyxYww)u Convert a blocking operation into an async operation using a thread. These two lines are equivalent:: sync_fn(*args) await trio.to_thread.run_sync(sync_fn, *args) except that if ``sync_fn`` takes a long time, then the first line will block the Trio loop while it runs, while the second line allows other Trio tasks to continue working while ``sync_fn`` runs. This is accomplished by pushing the call to ``sync_fn(*args)`` off into a worker thread. From inside the worker thread, you can get back into Trio using the functions in `trio.from_thread`. Args: sync_fn: An arbitrary synchronous callable. *args: Positional arguments to pass to sync_fn. If you need keyword arguments, use :func:`functools.partial`. abandon_on_cancel (bool): Whether to abandon this thread upon cancellation of this operation. See discussion below. thread_name (str): Optional string to set the name of the thread. Will always set `threading.Thread.name`, but only set the os name if pthread.h is available (i.e. most POSIX installations). pthread names are limited to 15 characters, and can be read from ``/proc//task//comm`` or with ``ps -eT``, among others. Defaults to ``{sync_fn.__name__|None} from {trio.lowlevel.current_task().name}``. limiter (None, or CapacityLimiter-like object): An object used to limit the number of simultaneous threads. Most commonly this will be a `~trio.CapacityLimiter`, but it could be anything providing compatible :meth:`~trio.CapacityLimiter.acquire_on_behalf_of` and :meth:`~trio.CapacityLimiter.release_on_behalf_of` methods. This function will call ``acquire_on_behalf_of`` before starting the thread, and ``release_on_behalf_of`` after the thread has finished. If None (the default), uses the default `~trio.CapacityLimiter`, as returned by :func:`current_default_thread_limiter`. **Cancellation handling**: Cancellation is a tricky issue here, because neither Python nor the operating systems it runs on provide any general mechanism for cancelling an arbitrary synchronous function running in a thread. This function will always check for cancellation on entry, before starting the thread. But once the thread is running, there are two ways it can handle being cancelled: * If ``abandon_on_cancel=False``, the function ignores the cancellation and keeps going, just like if we had called ``sync_fn`` synchronously. This is the default behavior. * If ``abandon_on_cancel=True``, then this function immediately raises `~trio.Cancelled`. In this case **the thread keeps running in background** – we just abandon it to do whatever it's going to do, and silently discard any return value or errors that it raises. Only use this if you know that the operation is safe and side-effect free. (For example: :func:`trio.socket.getaddrinfo` uses a thread with ``abandon_on_cancel=True``, because it doesn't really affect anything if a stray hostname lookup keeps running in the background.) The ``limiter`` is only released after the thread has *actually* finished – which in the case of cancellation may be some time after this function has returned. If :func:`trio.run` finishes before the thread does, then the limiter release method will never be called at all. .. warning:: You should not use this function to call long-running CPU-bound functions! In addition to the usual GIL-related reasons why using threads for CPU-bound work is not very effective in Python, there is an additional problem: on CPython, `CPU-bound threads tend to "starve out" IO-bound threads `__, so using threads for CPU-bound work is likely to adversely affect the main thread running Trio. If you need to do this, you're better off using a worker process, or perhaps PyPy (which still has a GIL, but may do a better job of fairly allocating CPU time between threads). Returns: Whatever ``sync_fn(*args)`` returns. Raises: Exception: Whatever ``sync_fn(*args)`` raises. Nztrio.to_thread.run_sync-cdfd }tj|d7tjj dtj yy)Nct jjS#jwxYwrW)unwraprelease_on_behalf_of)r+ placeholderrfsr*do_release_then_return_resultz`to_thread_run_sync..report_back_in_trio_thread_fn..do_release_then_return_resultos.  :}},,[9,,[9s$7rr)rarr\r]rorp)rfrr+rr"s` r*report_back_in_trio_thread_fnz9to_thread_run_sync..report_back_in_trio_thread_fnnsK :!>?   ' MM $ $]1%5w}}V7L M (r)r#z from c t_t_t_t_ j g}t j|r5|jtdjtd|t`t`t`t`S#t`t`t`t`wxYw)NzBTrio expected a sync function, but {!r} appears to be asynchronousr%) rxrr r!r"rgrrrrrr)r abandon_boolrNr!rScurrent_trio_tokensync_fnr"s r* worker_fnz%to_thread_run_sync..worker_fns!3-9*+:()6& /'++g--C""3' ##)6''>7*S#T  & 2 0 .!& 2 0 .s AB&&Cctjtj5j |dddy#1swYyxYwrW) contextlibsuppressr\rry)rfrrs r*deliver_worker_fn_resultz4to_thread_run_sync..deliver_worker_fn_resultsC !6!6 7 T  , ,-JF S T T Ts AA c|d<r)dd<tjjjStjjjS)Nr)r\r]Abort SUCCEEDEDFAILED) raise_cancelrr!r"s r*abortz!to_thread_run_sync..abortsF!-OA #' a }}**444}}**111r)z=trio.to_thread.run_sync received unrecognized thread message .)rfzoutcome.Outcome[RetT]rurvr)rrruztrio.lowlevel.Abort)r\r]checkpoint_if_cancelledrrCr^next_thread_counterrGrrrIrrrgr r8acquire_on_behalf_ofr;rrwait_task_rescheduled isinstanceraOutcomerrKrrr)rrr r+rNrIrrrmsg_from_threadrr!rSrrrr"s` `` @@@@@@@r*to_thread_run_syncrsv -- / / 111)*L02 7;mm6P6P6R5SM37O %d?&;%< =D#D)K N99; *d;)7I I #I %H99I>II I cr tjd}||yy#t$r tddwxYw)aRaise `trio.Cancelled` if the associated Trio task entered a cancelled status. Only applicable to threads spawned by `trio.to_thread.run_sync`. Poll to allow ``abandon_on_cancel=False`` threads to raise :exc:`~trio.Cancelled` at a suitable place, or to end abandoned ``abandon_on_cancel=True`` threads sooner than they may otherwise. Raises: Cancelled: If the corresponding call to `trio.to_thread.run_sync` has had a delivery of cancellation attempted against it, regardless of the value of ``abandon_on_cancel`` supplied as an argument to it. RuntimeError: If this thread is not spawned from `trio.to_thread.run_sync`. .. note:: To be precise, :func:`~trio.from_thread.check_cancelled` checks whether the task running :func:`trio.to_thread.run_sync` has ever been cancelled since the last time it was running a :func:`trio.from_thread.run` or :func:`trio.from_thread.run_sync` function. It may raise `trio.Cancelled` even if a cancellation occurred that was later hidden by a modification to `trio.CancelScope.shield` between the cancelled `~trio.CancelScope` and :func:`trio.to_thread.run_sync`. This differs from the behavior of normal Trio checkpoints, which raise `~trio.Cancelled` only if the cancellation is still active when the checkpoint executes. The distinction here is *exceedingly* unlikely to be relevant to your application, but we mention it for completeness. rz@this thread wasn't created by Trio, can't check for cancellationN)rxr!AttributeErrorr)rs r*from_thread_check_cancelledrsM6'77:   N  s 6c|du}|s tj}nt |t s td t jjtd#t$r tddwxYw#t$rYnwxYw|stjr|j|n|j||jjjS)z%Shared logic of from_thread functionsNz=this thread wasn't created by Trio, pass kwarg trio_token=...z0Passed kwarg trio_token is not of type TrioTokenz2this is a blocking function; call it from a thread)rxrrrrr r\r]r^r rr{rUr6r) trio_tokenmessage_to_triotoken_provideds r*_send_message_to_triors  t+N  )//J  I .MNNQ ""$OPP O      );;--j9((4  $ $ & - - //sAA7A47 BB)rc.t|t||S)a8Run the given async function in the parent Trio thread, blocking until it is complete. Returns: Whatever ``afn(*args)`` returns. Returns or raises whatever the given function returns or raises. It can also raise exceptions of its own: Raises: RunFinishedError: if the corresponding call to :func:`trio.run` has already completed, or if the run has started its final cleanup phase and can no longer spawn new system tasks. Cancelled: If the original call to :func:`trio.to_thread.run_sync` is cancelled (if *trio_token* is None) or the call to :func:`trio.run` completes (if *trio_token* is not None) while ``afn(*args)`` is running, then *afn* is likely to raise :exc:`trio.Cancelled`. RuntimeError: if you try calling this from inside the Trio thread, which would otherwise cause a deadlock, or if no ``trio_token`` was provided, and we can't infer one from context. TypeError: if ``afn`` is not an asynchronous function. **Locating a TrioToken**: There are two ways to specify which `trio.run` loop to reenter: - Spawn this thread from `trio.to_thread.run_sync`. Trio will automatically capture the relevant Trio token and use it to re-enter the same Trio task. - Pass a keyword argument, ``trio_token`` specifying a specific `trio.run` loop to re-enter. This is useful in case you have a "foreign" thread, spawned using some other framework, and still want to enter Trio, or if you want to use a new system task to call ``afn``, maybe to avoid the cancellation context of a corresponding `trio.to_thread.run_sync` task. You can get this token from :func:`trio.lowlevel.current_trio_token`. )rrK)rLrrNs r*from_thread_runrsR !Sd^ < ??r))ruzGenerator[None, None, None]rt)rur0)rur) rCallable[[Unpack[Ts]], RetT]rN Unpack[Ts]rz str | Noner rr+zCapacityLimiter | Nonerur)rTrioToken | NonerzRun[RetT] | RunSync[RetT]rur)rLz'Callable[[Unpack[Ts]], Awaitable[RetT]]rNrrrrur)rrrNrrrrur)B __future__rrrrrUr threading itertoolsrtypingrrrrrarsniffior r\_corer r r rrr_syncrr_utilrcollections.abcrrrtyping_extensionsrrtrio._core._trapsrrrlocalrrxr,r'rBrr/r4contextmanagerr;r>r@rCfrozenrGrKrrrrrrr(r)r*rsZ"22 . *%>>6. d Bv3ioo3#$*0*;'; ' 5;;K4L1L 11"08 (e$% e$7,'$-7,%7,te$)+gdm)+%)+X##&* G )G G G  G $ G  G G T"J0 0.0 0H$()= 0)= )=!)= )=^$(#@$#@ #@!#@ #@r)