kKj,UdZddlmZddlZddlZddlZddlmZddlm Z ddl m Z ddl m Z ddlmZmZ dd lmZe rdd lmZdd lmZdd lmZej2eZd(dZe ddGddZd)dZe ddGddZe ddZ de!d<d*dZ"d+dZ#d(dZ$efd,dZ%iZ&de!d<d-d Z'd.d!Z(eZ)d"e!d#<d$Z*d/d%Z+d0d&Z,y#e$rd'd ZYwxYw)1a%Task context and scoping for background task execution. Determines authorization scope (``get_task_scope``), manages the context snapshot that is captured at task submission and restored in workers (``TaskContextSnapshot``), and maintains in-process registries for live sessions and servers. ) annotationsN) OrderedDict) ContextVar) dataclass) TYPE_CHECKING)parse_task_keytask_redis_prefix)TaskKeycy)Nr m/Users/ahmed/devFolder/Ultron/claude-voice/.venv/lib/python3.12/site-packages/fastmcp/server/tasks/context.pyr r s r)Docket) ServerSession)FastMCPcddlm}|}|y|jr|jjdnd}|r|jd|S|jS)uTGet the authorization scope for task isolation. Returns the raw scope identifier for the current access token, or ``None`` when no auth context is present (anonymous tasks). The scope is composed as ``client_id|sub`` when the token carries a ``sub`` claim — necessary for fixed-OAuth servers where ``client_id`` is shared across all users — and falls back to ``client_id`` alone for DCR/CIMD flows where the client identity is already per-user. Encoding for Redis/Docket keys happens at the boundary in ``keys.py``; this function returns the raw value. r)get_access_tokenNsub|)fastmcp.server.dependenciesrclaimsget client_id)rtokenrs rget_task_scoper*sV=  E }%*\\%,,  5 !tC //"!C5)) ??rT)frozenslotsc(eZdZUdZded< ded<y)TaskContextInfozInformation about the current background task context. Returned by ``get_task_context()`` when running inside a Docket worker. Contains identifiers needed to communicate with the MCP session. strtask_id str | None task_scopeN)__name__ __module__ __qualname____doc____annotations__r rrr r Cs L2Prr cddlm}|syddlm} |j }t |j }t|d|dS#t$rYyttf$rYywxYw)aJGet the current task context if running inside a background task worker. This function extracts task information from the Docket execution context. Returns None if not running in a task context (e.g., foreground execution). Returns: TaskContextInfo with task_id and task_scope, or None if not in a task. r)is_docket_availableN)current_executionclient_task_idr$)r"r$) rr+docket.dependenciesr,rrkeyr LookupError ValueErrorKeyError)r+r, execution key_partss rget_task_contextr5Rsw@  5 %))+ "9==1 ./ .     !s7A A*A*)A*ceZdZUdZdZded<dZded<dZded<dZded<e d d Z e dd Z dd Z dd Z y)TaskContextSnapshotzAll context data snapshotted at task-submission time. Stored as a single Redis key per task, restored once in the worker. Nr#access_token_jsonzdict[str, str] | None http_headersorigin_request_id session_idcddlm}m}m}|}|}|j} |j }||r|jnd|dxsd|t|j|Sd|S#t $rd}YSwxYw)z6Capture current context for background task execution.r)r get_contextget_http_headersNT) include_allr8r9r:r;) rrr=r>request_contextr; RuntimeErrormodel_dump_jsonr! request_id)clsrr=r> access_tokenctxrAr;s rcapturezTaskContextSnapshot.capture{s  () m-- J2> ,,.D)d;Ct3B3NO../!  UY!   J s A88 BBct|tr|j}tj|}|j d}t|t rC|jDcic](\}}t|jt|*}}}||j d||j d|j dScc}}w)z&Deserialize from JSON stored in Redis.r9r8r:r;r@) isinstancebytesdecodejsonloadsrdictitemsr!lower)rErawparsedheaderskvs r from_jsonzTaskContextSnapshot.from_jsons c5 !**,CC**^, gt $:A--/J/$!Qs1v||~s1v-/GJ$jj)<= $jj)<=zz,/   Ks*-Cctj|j|j|j|j dS)z$Serialize to JSON for Redis storage.r@)rMdumpsr8r9r:r;)selfs rto_jsonzTaskContextSnapshot.to_jsons:zz%)%;%; $ 1 1%)%;%;"oo    rc(K|jt|d|d}|j4d{}|j||j |d{dddd{y7?77 #1d{7swYyxYww)z*Store this snapshot as a single Redis key.: :snapshotN)ex)r/r redissetr[)rZdocketr$r" ttl_secondsr/r`s rsavezTaskContextSnapshot.savesojj-j9:!G9INO<<>>U))CK)@ @ @">> @">>>sV5BA7B&A=!A9"A=& B1A;2B9A=;B=BB B B)returnr7)rRz str | bytesrer7rer!) rbrr$r#r"r!rcintreNone)r%r&r'r(r8r)r9r:r; classmethodrHrWr[rdr rrr7r7os %)z(*.L'.$(z(!J !  4       A A A A  A  Arr7 task_snapshot)defaultz2ContextVar[tuple[str, TaskContextSnapshot] | None]_task_snapshotc2tj||fy)zBind a snapshot to the current asyncio context under ``task_id``. Nothing outside this task's context sees it; stale entries left in a reused context are ignored on recall. N)rlra)r"snapshots r_remember_snapshotros *+rcHtj}| |\}}||k(r|Sy)zReturn the snapshot bound for ``task_id`` in the current context. Returns ``None`` if nothing is bound, or if the bound entry belongs to a different task (a stale leftover from a reused asyncio context). N)rlr)r"cachedcached_task_idrns r_recall_snapshotrss2    !F #)  W $O rcft}|yt|j}|r |jSdS)zGet the session_id for the current background task, if available. Reads the cached snapshot set by the worker-level restore dependency. Returns None if not in a task context or the snapshot wasn't restored. N)r5rsr"r;) task_inforns rget_task_session_idrvs8 !"I 1 12H"*8  44rc `K t|}ddlm}m} |j }||j}|y|d}|d} |j4d{}|j|jt|d|dd{}dddd{yt|tj|y#t$rYywxYw#t $rd}YwxYw77Y7K#1d{7swY[xYw#t$rtj!d|d YywxYww) u0Worker-level Docket dependency that restores the task-context snapshot. Runs before each fastmcp-owned task, populating the snapshot ContextVar so user code — and any task-scoped dependency like ``_CurrentContext`` — sees a ready snapshot without touching Redis itself. All Redis I/O goes through Docket's async client, so cluster URLs and the memory:// backend work transparently (#3897). Failures are non-fatal: the task still runs, and sync helpers return ``None`` as they would have before the snapshot was captured. Nr)_current_docket get_serverr$r-r]r^z&Failed to restore task snapshot for %sT)exc_info)rr1rrxry_docketrBrr`r/r ror7rW Exception_loggerwarning) r/partsrxryrbr$r"r`rRs rrestore_task_snapshotrs3s# H%%~ $$& ~|$J$%G V<<>>U  / ; ; 7$7$A$A#$FG1  "">>> V@#PTUVsD. C D.CD. DC,D!3C2C.C2 D$C0%D+D.,D D. CD.CD. C)&D.(C))D.,D.C20D2D8C; 9DD!D+(D.*D++D.z%dict[str, weakref.ref[ServerSession]]_task_sessionsc<tj|t|<y)zRegister a session for in-process background task access. Called automatically when a task is submitted to Docket. The session is stored as a weakref so it doesn't prevent garbage collection when the client disconnects. N)weakrefrefr)r;sessions rregister_task_sessionrs")W!5N:rcttj|}|y|}|tj|d|S)uGet a registered session by ID if still alive. Returns None in distributed workers where the session lives in another process — callers must handle this gracefully. N)rrpop)r;rrs rget_task_sessionr(s=   Z (C {eG:t, Nrz&OrderedDict[str, weakref.ref[FastMCP]]_task_server_mapi'ctj|t|<tttkDr.tj dtttkDr-yy)zRegister the server for a background task. Called at task-submission time so that background workers can resolve the correct (child) server for mounted tasks. F)lastN)rrrlen_TASK_SERVER_MAP_MAX_SIZEpopitem)r"servers rregister_task_serverr;sI !( F 3W  "; ;  e ,  "; ;rcttj|}|y|}|tj|d|S)z@Get the registered server for a background task, if still alive.N)rrr)r"rrs rget_task_serverrFs;   w 'C { UF ~Wd+ Mrrf)rer#)rezTaskContextInfo | None)r"r!rnr7rerh)r"r!rezTaskContextSnapshot | None)r/r!rerh)r;r!rrrerh)r;r!rezServerSession | None)r"r!rrrerh)r"r!rezFastMCP | None)-r( __future__rrMloggingr collectionsr contextvarsr dataclassesrtypingrfastmcp.server.tasks.keysrr rbr ImportErrorrmcp.server.sessionrfastmcp.server.serverr getLoggerr%r}rr r5r7rlr)rorsrvrrrrrrrrr rrrs+# #"! G 0- '  H %2 $d# Q Q$ Q: $d#KAKA$KA`FPTFB ,  5,39'Vd9;5:6