!iZ?e@e e>eze@e/e'ffeAd4<d5e e>ezde@e/e'ffd6ZBGd7d8e'ee=ZCd9e>e=de=fd:ZDGd;dZFd5e d?eGeFdeFdzfd@ZHdAe@e/e'fd?eGeFdeFdzfdBZId5e ddfdCZJGdDdEZKedFddGedee@e/efdffdHZLdS)LN)AsyncExitStackasynccontextmanager) ContextVar)datetime timedeltatimezone) TracebackType) TYPE_CHECKINGAnyAsyncContextManagerAsyncGenerator AwaitableCallableContextManagerCounterGenericNoReturnTypeVarcast)Docket) ExecutionExecutionProgress TaskFunction get_signature) CACHE_SIZE)WorkerceZdZUdZeed<edZeeed<edZ eded<edZ ee ed<e j defdZd eed zd ed zd ed zdefd Zd S) DependencyFsingledocketworkerr executionreturnc KdSNselfs /Users/kimhansen/Desktop/03 Workspace/ceo-agents/chl-effectiveness/mcp-servers/whoop/.venv/lib/python3.11/site-packages/docket/dependencies.py __aenter__zDependency.__aenter__(s '*s _exc_typeN _exc_value _tracebackc KdSr&r')r)r-r.r/s r* __aexit__zDependency.__aexit__+s sr,)__name__ __module__ __qualname__r bool__annotations__rr!rr"r#rabcabstractmethodr r+type BaseExceptionr r1r'r,r*rr!sFD!+H!5!5FJv 555#-:h#7#7FJx 777'1z+'>'>Iz)$>>>*#**** &-"D("D(   r,rceZdZddZdS)_CurrentWorkerr$rc8K|jSr&)r"getr(s r*r+z_CurrentWorker.__aenter__4{   r,Nr$rr2r3r4r+r'r,r*r<r<3s(!!!!!!r,r<r$rc:tdtS)zA dependency to access the current Worker. Example: ```python @task async def my_task(worker: Worker = CurrentWorker()) -> None: assert isinstance(worker, Worker) ``` r)rr<r'r,r* CurrentWorkerrC8s .** + ++r,ceZdZdefdZdS)_CurrentDocketr$c8K|jSr&)r!r>r(s r*r+z_CurrentDocket.__aenter__Gr?r,N)r2r3r4rr+r'r,r*rErEFs/!&!!!!!!r,rEcDtttS)zA dependency to access the current Docket. Example: ```python @task async def my_task(docket: Docket = CurrentDocket()) -> None: assert isinstance(docket, Docket) ``` )rrrEr'r,r* CurrentDocketrHKs (( ) ))r,ceZdZdefdZdS)_CurrentExecutionr$c8K|jSr&)r#r>r(s r*r+z_CurrentExecution.__aenter__Zs~!!###r,N)r2r3r4rr+r'r,r*rJrJYs/$)$$$$$$r,rJcDtttS)zA dependency to access the current Execution. Example: ```python @task async def my_task(execution: Execution = CurrentExecution()) -> None: assert isinstance(execution, Execution) ``` )rrrJr'r,r*CurrentExecutionrM^s  ,.. / //r,ceZdZdefdZdS)_TaskKeyr$cBK|jjSr&)r#r>keyr(s r*r+z_TaskKey.__aenter__ms~!!##''r,N)r2r3r4strr+r'r,r*rOrOls/(#((((((r,rOcDtttS)zA dependency to access the key of the currently executing task. Example: ```python @task async def my_task(key: str = TaskKey()) -> None: assert isinstance(key, str) ``` )rrRrOr'r,r*TaskKeyrTqs XZZ  r,cReZdZUedzed<eed<ddedzdeddfdZdefdZdS) _TaskArgumentN parameteroptionalFr$c"||_||_dSr&rWrX)r)rWrXs r*__init__z_TaskArgument.__init__s"  r,cK|jJ|j} ||jS#t$r |jrYdSwxYwr&)rWr#r> get_argumentKeyErrorrXr)r#s r*r+z_TaskArgument.__aenter__sq~)))N&&((  ))$.99 9   } tt  sAAANF) r2r3r4rRr6r5r[r r+r'r,r*rVrVs}TzNNN!!#*!t!PT!!!!#r,rVFrWrXcHttt||S)aA dependency to access a argument of the currently executing task. This is often useful in dependency functions so they can access the arguments of the task they are injected into. Example: ```python async def customer_name(customer_id: int = TaskArgument()) -> str: ...look up the customer's name by ID... return "John Doe" @task async def greet_customer(customer_id: int, name: str = Depends(customer_name)) -> None: print(f"Hello, {name}!") ``` )rr rVrZs r* TaskArgumentrbs" ]9h77 8 88r,ceZdZddZdS) _TaskLoggerr$%logging.LoggerAdapter[logging.Logger]cxK|j}tjd|jj}tj|i|j|j | S)Nz docket.task.) r#r>logging getLoggerfunctionr2 LoggerAdapterr!labelsr"specific_labels)r)r#loggers r*r+z_TaskLogger.__aenter__sN&&(( "#O)2D2M#O#OPP$  +//##**,, +//##**,, ++--    r,Nr$rerAr'r,r*rdrds(       r,rdrec:tdtS)aA dependency to access a logger for the currently executing task. The logger will automatically inject contextual information such as the worker and docket name, the task key, and the current execution attempt number. Example: ```python @task async def my_task(logger: "LoggerAdapter[Logger]" = TaskLogger()) -> None: logger.info("Hello, world!") ``` re)rrdr'r,r* TaskLoggerrps 7 G GGr,ceZdZdZddZddZededzfdZedefdZ ede dzfdZ d eddfd Z dd eddfd Z de dzddfdZdS)Progressa9A dependency to report progress updates for the currently executing task. Tasks can use this to report their current progress (current/total values) and status messages to external observers. Example: ```python @task async def process_records(records: list, progress: Progress = Progress()) -> None: await progress.set_total(len(records)) for i, record in enumerate(records): await process(record) await progress.increment() await progress.set_message(f"Processed {record.id}") ``` r$Ncd|_dSr&) _progressr(s r*r[zProgress.__init__s 37r,cTK|j}|j|_|Sr&)r#r>progressrtr_s r*r+zProgress.__aenter__s(N&&(( "+ r,c<|j Jd|jjS)zCurrent progress value.N%Progress must be used as a dependency)rtcurrentr(s r*ryzProgress.current&~))+R)))~%%r,c<|j Jd|jjS)z)Total/target value for progress tracking.Nrx)rttotalr(s r*r|zProgress.totals&~))+R)))~##r,c<|j Jd|jjS)zUser-provided status message.Nrx)rtmessager(s r*r~zProgress.messagerzr,r|clK|j Jd|j|d{VdS)z1Set the total/target value for progress tracking.Nrx)rt set_total)r)r|s r*rzProgress.set_totalsK~))+R)))n&&u-----------r,ramountclK|j Jd|j|d{VdS)z0Atomically increment the current progress value.Nrx)rt increment)r)rs r*rzProgress.incrementsK~))+R)))n&&v...........r,r~clK|j Jd|j|d{VdS)z#Update the progress status message.Nrx)rt set_message)r)r~s r*rzProgress.set_messagesK~))+R)))n((11111111111r,r$N)r$rr)r)r2r3r4__doc__r[r+propertyintryr|rRr~rrrr'r,r*rrrrs2$8888 &t&&&X& $s$$$X$ &t&&&X& .S.T.... //c/$//// 2t2222222r,rrceZdZdZdS) ForcedRetryz5Raised when a task requests a retry via `in_` or `at`N)r2r3r4rr'r,r*rrs????r,rc|eZdZUdZdZeed<dedfdedzded dfd Z dd Z d e d e fd Z d ed e fdZdS)RetryaConfigures linear retries for a task. You can specify the total number of attempts (or `None` to retry indefinitely), and the delay between attempts. Example: ```python @task async def my_task(retry: Retry = Retry(attempts=3)) -> None: ... ``` Tr rrattemptsNdelayr$c0||_||_d|_dS)z Args: attempts: The total number of attempts to make. If `None`, the task will be retried indefinitely. delay: The delay between attempts. rN)rrattempt)r)rrs r*r[zRetry.__init__s!   r,cK|j}t|j|j}|j|_|S)Nrr)r#r>rrrr)r)r#retrys r*r+zRetry.__aenter__!s>N&&(( t}DJ???!)  r,whenctjtj}||z }|dkr|nt d}||dS)Nr)rnowrutc total_secondsrin_)r)rrdiffs r*atzRetry.at'sTl8<((cz))++q00ttill r,c,||_tr&)rr)r)rs r*rz Retry.in_.s $ mmr,)r$r)r2r3r4rr r5r6rrr[r+rrrrr'r,r*rrs  FD&'99Q<<  d  /8       xH hr,rc reZdZdZdededfdedzdeded dffd Zd d ZxZS) ExponentialRetryaOConfigures exponential retries for a task. You can specify the total number of attempts (or `None` to retry indefinitely), and the minimum and maximum delays between attempts. Example: ```python @task async def my_task(retry: ExponentialRetry = ExponentialRetry(attempts=3)) -> None: ... ``` rseconds@rN minimum_delay maximum_delayr$c\t||||_dS)a Args: attempts: The total number of attempts to make. If `None`, the task will be retried indefinitely. minimum_delay: The minimum delay between attempts. maximum_delay: The maximum delay between attempts. rN)superr[r)r)rrr __class__s r*r[zExponentialRetry.__init__As0 (-@@@*r,cK|j}t|j|j|j}|j|_|jdkr6d|jdz z}|j|z}||jkr |j|_n||_|S)N)rrrr)r#r>rrrrr)r)r#rbackoff_factorcalculated_delays r*r+zExponentialRetry.__aenter__QsN&&((  ]*,    ")  q 9#4q#89N#zN: $"444"0 .  r,)r$r) r2r3r4rrrr[r+ __classcell__)rs@r*rr3s   !#,9Q#7#7#7#,9R#8#8#8 ++*+!+! +  ++++++ r,rceZdZUdZdZeed<eed<ee dfed<e e e fed<eed<ed d fdeded d fd Z ddZ ddZde de d d fdZd S) PerpetualayDeclare a task that should be run perpetually. Perpetual tasks are automatically rescheduled for the future after they finish (whether they succeed or fail). A perpetual task can be scheduled at worker startup with the `automatic=True`. Example: ```python @task async def my_task(perpetual: Perpetual = Perpetual()) -> None: ... ``` Tevery automatic.argskwargs cancelledrFr$Nc0||_||_d|_dS)a Args: every: The target interval between task executions. automatic: If set, this task will be automatically scheduled during worker startup and continually through the worker's lifespan. This ensures that the task will always be scheduled despite crashes and other adverse conditions. Automatic tasks must not require any arguments. FN)rrr)r)rrs r*r[zPerpetual.__init__s "r,cK|j}t|j}|j|_|j|_|S)N)r)r#r>rrrr)r)r# perpetuals r*r+zPerpetual.__aenter__sEN&&(( DJ/// " $+ r,cd|_dS)NT)rr(s r*cancelzPerpetual.cancels r,c"||_||_dSr&)rr)r)rrs r* perpetuatezPerpetual.perpetuates  r,)r$rr)r2r3r4rr rr6r5tupler dictrRr[r+rrr'r,r*rrgs  F OOO S/ cNOOO%9Q<<  "str,rceZdZUdZdZeed<eed<eed<deddfdZ dd Z dd Z defd Z defd Z dd edzddfdZdS)TimeoutacConfigures a timeout for a task. You can specify the base timeout, and the task will be cancelled if it exceeds this duration. The timeout may be extended within the context of a single running task. Example: ```python @task async def my_task(timeout: Timeout = Timeout(timedelta(seconds=10))) -> None: ... ``` Tr base _deadliner$Nc||_dS)zD Args: base: The base timeout duration. Nr)r)rs r*r[zTimeout.__init__s  r,c\Kt|j}||S)Nr)rrstart)r)timeouts r*r+zTimeout.__aenter__s*ty))) r,cjtj|jz|_dSr&)time monotonicrrrr(s r*rz Timeout.starts())DI,C,C,E,EEr,c:tj|jkSr&)rrrr(s r*expiredzTimeout.expireds~4>11r,cTt|jtjz S)z1Get the remaining time until the timeout expires.r)rrrrr(s r* remainingzTimeout.remainings"$.2B2B!BCCCCr,byc\||j}|xj|z c_dS)zExtend the timeout by a given duration. If no duration is provided, the base timeout will be used. Args: by: The duration to extend the timeout by. N)rrr)r)rs r*extendzTimeout.extends0 :B "**,,,r,)r$rrr&)r2r3r4rr r5r6rfloatr[r+rrrrr'r,r*rrs  FD OOOY4 FFFF22222D9DDDD - -T) -T - - - - - -r,rR._parameter_cacheric|tvr6tjttddit|Si}t |}|jD]*\}}t|jts |j||<+|t|<tjttddi|S)NcacherW) rrsetlenr parametersitems isinstancedefaultr)ri dependencies signaturerWparams r*get_dependency_parametersrs###s+,,w .DEEE))*,Lh''I%0668800 5%-44  "'- Y!-XN3'((7K*@AAA r,c.eZdZUeeed<edZeeee e fed<edZ ee ed<de gee ezeezeezfddfdZdeee zdeee ffdZdefd ZdS) _Depends dependencyrstackr$Nc||_dSr&r)r)rs r*r[z_Depends.__init__s %r,ricK|j}i}t|}|D]F\}}t |t r|js||_||d{V||<G|Sr&)rr>rrrrVrWenter_async_context)r)rir argumentsrrWrs r*_resolve_parametersz_Depends._resolve_parameterss   $& .x88 %/%5%5%7%7 O O !Iz*m44 1Z=Q 1'0 $).)B)B:)N)N#N#N#N#N#N#NIi r,cK|j}|j|vr ||jS|j}||jd{V}|jdi|}t |t r||d{V}nt |tr| |}netj |st |tr'ttt|d{V}ntt|}|||j<|S)Nr')rr>rrrrr rr enter_contextinspect iscoroutinerrr)r)rrr raw_valueresolved_values r*r+z_Depends.__aenter__sV    ?e # #) )   224?CCCCCCCC  DO ( (i ( (  i!4 5 5 0#(#<# 2 2 0"00;;NN   + + 0z)Y/O/O 0#' ! i#@#@@@@@@@NN"!Y//N!/dor,)r2r3r4DependencyFunctionrr6rrrr rrrrrr r[rrRrr+r'r,r*rrs"1%%%%!#447J17MM M %  %%%%!3C!88 c3h&!r,rrcFttt|S)a,Include a user-defined function as a dependency. Dependencies may be: - Synchronous functions returning a value - Asynchronous functions returning a value (awaitable) - Synchronous context managers (using @contextmanager) - Asynchronous context managers (using @asynccontextmanager) If a dependency returns a context manager, it will be entered and exited around the task, giving an opportunity to control the lifetime of a resource. **Important**: Synchronous dependencies should NOT include blocking I/O operations (file access, network calls, database queries, etc.). Use async dependencies for any I/O. Sync dependencies are best for: - Pure computations - In-memory data structure access - Configuration lookups from memory - Non-blocking transformations Examples: ```python # Sync dependency - pure computation, no I/O def get_config() -> dict: # Access in-memory config, no I/O return {"api_url": "https://api.example.com", "timeout": 30} # Sync dependency - compute value from arguments def build_query_params( user_id: int = TaskArgument(), config: dict = Depends(get_config) ) -> dict: # Pure computation, no I/O return {"user_id": user_id, "timeout": config["timeout"]} # Async dependency - I/O operations async def get_user(user_id: int = TaskArgument()) -> User: # Network I/O - must be async return await fetch_user_from_api(user_id) # Async context manager - I/O resource management from contextlib import asynccontextmanager @asynccontextmanager async def get_db_connection(): # I/O operations - must be async conn = await db.connect() try: yield conn finally: await conn.close() @task async def my_task( params: dict = Depends(build_query_params), user: User = Depends(get_user), db: Connection = Depends(get_db_connection), ) -> None: await db.execute("UPDATE users SET ...", params) ``` )rrrrs r*Dependsr8sx 8J'' ( ((r,c eZdZUdZdZeed< ddedededzd dfd Z dd Z e d edzfd Z e d efd Z dS)ConcurrencyLimitaConfigures concurrency limits for a task based on specific argument values. This allows fine-grained control over task execution by limiting concurrent tasks based on the value of specific arguments. Example: ```python async def process_customer( customer_id: int, concurrency: ConcurrencyLimit = ConcurrencyLimit("customer_id", max_concurrent=1) ) -> None: # Only one task per customer_id will run at a time ... async def backup_db( db_name: str, concurrency: ConcurrencyLimit = ConcurrencyLimit("db_name", max_concurrent=3) ) -> None: # Only 3 backup tasks per database name will run at a time ... ``` Tr rN argument_namemax_concurrentscoper$cL||_||_||_d|_d|_dS)a Args: argument_name: The name of the task argument to use for concurrency grouping max_concurrent: Maximum number of concurrent tasks per unique argument value scope: Optional scope prefix for Redis keys (defaults to docket name) NF)rrr_concurrency_key _initialized)r)rrrs r*r[zConcurrencyLimit.__init__s1+, ,0"'r,cK|j}|j} ||j}n@#t $r3t |j|j|j}d|_ d|_ |cYSwxYw|jp|j }|d|jd||_ t |j|j|j}|j |_ d|_ |S)NTz :concurrency::) r#r>r!r]rr^rrrrrname)r)r#r!argument_valuelimitrs r*r+zConcurrencyLimit.__aenter__sN&&(( "" &33D4FGGNN   $"D$7E&*E "!%E LLL  )fk H H4#5 H H H H !!3T5H$*UU!%!6! sA:B Bc<|jstd|jS)zRedis key used for tracking concurrency for this specific argument value. Returns None when concurrency control is bypassed due to missing arguments. Raises RuntimeError if accessed before initialization.z:ConcurrencyLimit not initialized - use within task context)r RuntimeErrorrr(s r*concurrency_keyz ConcurrencyLimit.concurrency_keys/   L $$r,c"|jo|jduS)zIReturns True if concurrency control is bypassed due to missing arguments.N)rrr(s r* is_bypassedzConcurrencyLimit.is_bypasseds BT%:d%BBr,)rN)r$r)r2r3r4rr r5r6rRrr[r+rrrr'r,r*rrws0FDPT ( (  (25 (BE* (  ( ( ( (6%t%%%X%CTCCCXCCCr,rD)bounddependency_typec|js Jdt|D]\}}t||r|cSdSNzDependency must be single)r rrr)rir_rs r*'get_single_dependency_parameter_of_typer sk  !>>#>>>>28<<BBDD : j/ 2 2      4r,rc|js Jd|D]\}}t||r|cSdSr)r rr)rrr rs r*get_single_dependency_of_typer sc  !>>#>>>>%++-- : j/ 2 2      4r,ct|}td|D}|D]*\}}|jr|dkrt d|jd+dS)Nc34K|]}t|VdSr&)r9).0rs r* z(validate_dependencies..s*LL*T*%%LLLLLLr,rz Only one z dependency is allowed per task)rrvaluesrr ValueErrorr2)rircountsrcounts r*validate_dependenciesrs*844J LL 8I8I8K8KLLL L LF"(,,..  ! eaiiUO4UUU r,c"eZdZdededdfdZdS)FailedDependencyrWerrorr$Nc"||_||_dSr&)rWr)r)rWrs r*r[zFailedDependency.__init__s" r,)r2r3r4rR Exceptionr[r'r,r*rrs=#iDr,rr"r#cKtj|j}tj|}tj|}t ji} t4d{V}t j|} i}t|j } | D]\} } |j } | | vr | | || <t| tr(| js!t!| t#d|| <Y || d{V|| <y#t&$r} t!| | || <Yd} ~ d} ~ wwxYw|WVt j|n$#t j|wxYw dddd{Vn#1d{VswxYwYt j|tj|tj|tj|dS#t j|tj|tj|tj|wxYw)NzNo parameter name specified)rr!rr"r#rrrrrrirrrrVrWrrrrreset)r"r# docket_token worker_tokenexecution_token cache_tokenr stack_tokenrrrWrrrs r*resolved_dependenciesr"sw $((77L$((00L *..y99O.$$R((K(.!##" 2" 2" 2" 2" 2" 2" 2u".,,U33K 2,. 6y7IJJ -7-=-=-?-?RR)Iz&-F F**/5i/@ ), #:}==! * 4!0@%z2O'P'P00 ),!R5:5N5N&66000000 ),,%RRR/? 5/Q/Q ),,,,,,R $$[1111$$[11111E" 2" 2" 2" 2" 2" 2" 2" 2" 2" 2" 2" 2" 2" 2" 2" 2" 2" 2" 2" 2" 2" 2" 2" 2" 2" 2" 2H [)))""?333 --- ----- [)))""?333 --- ----stI2 G#:BF,>EF, F'E?:F,?FF, G#,!G  G#I2# G--I20G-1I22A>K0r@r`rn)Mr7rrgr contextlibrr contextvarsrrrrtypesr typingr r r r rrrrrrrrr!rr#rrrrinstrumentationrr"rABCrr<rCrErHrJrMrOrRrTrVr5rbrdrprrrrrrrrrrrrr6rrrrrr9r r rrr"r'r,r*r)s  ::::::::""""""2222222222                            PPPPPPPPPPPP''''''$!!!!!Z!!! , , , ,!!!!!Z!!! *v * * * *$$$$$ $$$ 0) 0 0 0 0(((((z((( ! ! ! ! !J&99C$J99#9999(      *     H H H H :2:2:2:2:2z:2:2:2z@@@@@)@@@+++++J+++\11111u111h55555 555p2-2-2-2-2-j2-2-2-j GCLLYq\ N1- -0CA0F FF$%c**j /44 #z/,>>>>>z71:>>>B<)*1-<)!<)<)<)<)~SCSCSCSCSCzSCSCSCl GCz"""-1!WXsJ':>q'X L T     1. 1.!*1.DcND()1.1.1.1.1.1.r,