tjcddlmZddlZddlmZmZmZmZmZddl m Z m Z ddl m Z mZddlmZddlmZddlmZdd lmZe rdd lmZmZdd lmZdd lmZmZd dZd!dZ edGddZ!edGddZ"GddZ#Gdde!e#Z$Gdde"e#Z%dS)") annotationsN) AsyncIterator AwaitableCallableIteratorMapping)MappingProxyType TracebackType) TYPE_CHECKINGAny)beta)convert_to_protocol_event) StreamMux) ProtocolEvent)AsyncChatModelStreamChatModelStream StreamChannel)LifecyclePayloadSubgraphStatuspumpCallable[[], bool]returnNonec4|r | dSdS)z*Call the sync pump until it returns False.Nrs Y/var/www/html/CA-Chatbot/venv/lib/python3.11/site-packages/langgraph/stream/run_stream.py_drive_until_doners7 $&&   $&&     Callable[[], Awaitable[bool]]cPK|d{Vr |d{VdSdS)z+Call the async pump until it returns False.Nrrs r_adrive_until_doner#sS,,,,,,  ,,,,,,     r z4The v3 streaming protocol on Pregel is experimental.)messageceZdZUdZded<ded<ded<ded <d d d/dZd0dZd1dZd2dZd3dZ d4dZ d5d"Z e d6d$Z e d2d%Ze d7d'Zd8d)Zd9d-Zd.S):GraphRunStreamuSync run stream with caller-driven pumping. The caller's iteration on any projection (`values`, `messages`, raw events, or `output`) drives the graph forward. No background thread is used — the caller's `for` loop is the pump. Projections are single-consumer — iterating `run.values` twice raises. Use `projection.tee(n)` if you genuinely need fan-out. All transformer projections live in `extensions`. Native transformer projections (those with `_native = True`) are also set as direct attributes on this instance (e.g. `run.values`, `run.messages`). !!! warning Returned by `Pregel.stream_events(version="v3")`, which is experimental and may change. StreamChannel[dict[str, Any]]valueszStreamChannel[ChatModelStream]messagesStreamChannel[LifecyclePayload] lifecyclez StreamChannel[SubgraphRunStream] subgraphsT wire_pump graph_iterIterator[Any] | Nonemuxrr.boolrrc<||_||_t|j|_d|_d|_d|_g|_t|j |_ |j D]}t|||j||r| |dSdS)a;Initialize the run stream. Args: graph_iter: Pull-based iterator over the graph's stream, or `None` for nested run streams whose pump is driven by an outer run (e.g. `SubgraphRunStream`). mux: The StreamMux owning projections and the main log. wire_pump: When True (default), bind `_pump_next` as the mux's pump callable. Subclasses that inherit a parent pump via `StreamMux._make_child` should pass False to preserve the parent binding. FN) _graph_iter_muxr extensions _exhausted_latest _interrupted _interruptslistscope _scope_list native_keyssetattr_wire_request_more)selfr/r1r.keys r__init__zGraphRunStream.__init__Cs&& -=cn-M-M.2 !&(&*39oo? 4 4C D#s~c2 3 3 3 3  )  # #C ( ( ( ( ( ) )r c:||jdS)alWire the sync pull callback through the mux. Routing through `mux.bind_pump` (rather than walking projections directly here) lets child mini-muxes built by `mux._make_child(...)` inherit the same pump callable, so cursors on a subgraph handle's projections drive the root pump just like cursors on `run.values` do. N) bind_pump _pump_nextrAr1s rr@z!GraphRunStream._wire_request_morecs do&&&&&r eventrc|ddkrdS|d}|d|jkrdS|d|_|dd}|r#d |_|j|dSdS z;Track values-event state for output/interrupted/interrupts.methodr(Nparams namespacedata interruptsrTr=r8getr9r:extendrArHrLrOs r_observe_eventzGraphRunStream._observe_eventn ?h & & Fx + $"2 2 2 Ff~ ZZ b11  0 $D    # #J / / / / / 0 0r c|js|jdS t|j}t|}|||j|dS#t$r$|jd|_YdSt$r,}|j |d|_Yd}~dSd}~wwxYw)a Pull one event from the graph and push it through the mux. Returns: True if an event was pulled, False if the graph is exhausted or has raised. Always False when constructed with `graph_iter=None` (the run is driven by an outer pump). NFT) r7r4nextrrTr5push StopIterationclose ExceptionfailrApartrHes rrFzGraphRunStream._pump_next{s ? d.65 ())D-d33E    & & & INN5 ! ! !4    IOO   "DO55    INN1   "DO55555 sAA&&*C C!CCc|jrdSd|_|j}d|_|/t|ddx} |n#t$rYnwxYw |jdS#t$rYdSwxYw)zStop the run early. Closes the underlying graph iterator (propagating `GeneratorExit` so in-flight nodes and subgraphs are cancelled), closes the mux, and marks the stream exhausted. Idempotent. NTrZ)r7r4getattrr[r5rZ)rAr/rZs rabortzGraphRunStream.aborts ?  F%   "!*gt<<<I       IOO         DD s# A A  A A,, A:9A:c|SNrrAs r __enter__zGraphRunStream.__enter__s r exc_typetype[BaseException] | NoneexcBaseException | NonetbTracebackType | Nonec.|dSrdrbrArgrirks r__exit__zGraphRunStream.__exit__s r dict[str, Any] | Nonecbt|j|jjjx}||jS)z7Drive the run to completion and return the final state.)rrFr5_events_errorr8rAerrs routputzGraphRunStream.outputs4 $/***9$+ +C 8I|r cbt|j|jjjx}||jS)zDrive the run to completion, then return whether it was interrupted. Raises: BaseException: If the run ended with an error. )rrFr5rsrtr9rus r interruptedzGraphRunStream.interrupteds5 $/***9$+ +C 8I  r list[Any]cbt|j|jjjx}||jS)zDrive the run to completion, then return interrupt payloads. Raises: BaseException: If the run ended with an error. )rrFr5rsrtr:rus rrOzGraphRunStream.interruptss5 $/***9$+ +C 8Ir Iterator[ProtocolEvent]c4t|jjSz&3333"&!# UUDd))c(mm++/3 ( 0 0 1 1HD"t|| z!")!90"$)O y1 " ! Q<547??$)4=D##+DG#4#;#C#C#E#ELFD7D/))))9-D|4466|!$T(0(8(833HD"#4// /#%:!3')y'<.0i$(HHTNNNt99..!;d))c(mm++>oo'' ' '!& ' 'hoo'' ' '!& 's H3I I?N)r/r0r1rr.r2rrr1rrrrHrrrrr2rr)rr&rgrhrirjrkrlrrrrqrrz)rr|)rrrr)r __module__ __qualname____doc____annotations__rCr@rTrFrbrfrppropertyrwryrOrrrr rr&r&$s|0*))),,,,....//// ))))))@ ' ' ' ' 0 0 0 022X ! ! !X !    X  ''''_'_'_'_'_'_'r r&ceZdZUdZded<ded<ded<ded <d d d+dZd,dZd-dZd.dZd/dZ d0dZ d1d"Z d2d$Z d.d%Z d3d'Zd4d)Zd*S)5AsyncGraphRunStreamuAsync run stream with caller-driven pumping. Async iteration on any projection drives the graph forward — there is no background task. Concurrent consumers share a single-flight pump via an `asyncio.Lock`, so each awaiting cursor contributes one event per acquisition. Backpressure comes from the logs: when a subscribed log's buffer reaches `maxlen`, `apush` awaits the subscriber to drain, which holds back the pump and paces the graph. Projections are single-consumer — a second `aiter(run.values)` raises. Use `projection.tee(n)` for fan-out. Use as an async context manager to guarantee clean shutdown on early exit: ```python async with await handler.astream(input) as run: async for msg in run.messages: ... ``` !!! warning Awaited from `Pregel.astream_events(version="v3")`, which is experimental and may change. r'r(z#StreamChannel[AsyncChatModelStream]r)r*r+z%StreamChannel[AsyncSubgraphRunStream]r,Tr- graph_aiterAsyncIterator[Any] | Noner1rr.r2rrc||_||_t|j|_d|_d|_d|_g|_t|j |_ tj |_ d|_d|_d|_|jD]}t%|||j||r||dSdS)aIInitialize the async run stream. Args: graph_aiter: Async iterator over the graph's stream, or `None` for nested run streams whose pump is driven by an outer run (e.g. `AsyncSubgraphRunStream`). mux: The StreamMux owning projections and the main log. wire_pump: When True (default), bind `_apump_next` as the mux's async pump callable. Subclasses that inherit a parent pump via `StreamMux._make_child` should pass False to preserve the parent binding. FN) _graph_aiterr5r r6r7r8r9r:r;r<r=asyncio Condition _pump_cond_pumping _anext_task _abortingr>r?_wire_arequest_more)rArr1r.rBs rrCzAsyncGraphRunStream.__init__fs&( -=cn-M-M.2 !&(&*39oo!+-- 7;? 4 4C D#s~c2 3 3 3 3  *  $ $S ) ) ) ) ) * *r rHrc|ddkrdS|d}|d|jkrdS|d|_|dd}|r#d |_|j|dSdSrJrPrSs rrTz"AsyncGraphRunStream._observe_eventrUr c:||jdS)zWire the async pull callback through the mux. Mirrors `_wire_request_more`: routing through `mux.bind_apump` lets child mini-muxes inherit the pump callable so cursors on subgraph handles drive the root pump. N) bind_apump _apump_nextrGs rrz'AsyncGraphRunStream._wire_arequest_mores t'(((((r cK|j4d{V|js|j dddd{VdS|jr9|jd{V|j cdddd{VSd|_dddd{Vn#1d{VswxYwY t j|j|_ |jd{V}n#t j $r|j rcd|_Yd|_|j4d{Vd|_|j dddd{VdS#1d{VswxYwYdS|j wxYw d|_n #d|_wxYwt|}|||j|d{V |j4d{Vd|_|j dddd{VdS#1d{VswxYwYdS#t"$r|d|_|jd{VY|j4d{Vd|_|j dddd{VdS#1d{VswxYwYdSt&$r}d|_|j|d{VYd}~|j4d{Vd|_|j dddd{VdS#1d{VswxYwYdSd}~wwxYw#|j4d{Vd|_|j dddd{Vw#1d{VswxYwYwxYw)u{Drive one pump step, or wait for the active pumper to drive one. "Take-a-number" semantics: at most one task at a time calls `graph_aiter.__anext__()` (asyncio iterators can't be advanced concurrently). Other callers wait on a Condition that the active pumper notifies after each step. This lets a "passive" consumer — one whose projection's buffer is being filled by the active pumper's push — wake up as soon as its data lands, instead of queueing on the pump and only observing its data one graph event late. `except Exception` is intentional — `CancelledError` and other `BaseException` subclasses propagate, matching asyncio's cancellation contract. Returns: True if a pump step completed (by this task or another), False if the graph is exhausted. NFT)rr7rrwaitr ensure_future __anext__rCancelledErrorr notify_allcancelrrTr5apushStopAsyncIterationacloser[afailr]s rrzAsyncGraphRunStream._apump_nexts(? ! ! ! ! ! ! ! ! $"3"; ! ! ! ! ! ! ! ! ! ! ! ! ! !} +o**,,,,,,,,,?*  ! ! ! ! ! ! ! ! ! ! ! ! ! !!DM ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! !$ -  $+#89J9T9T9V9V#W#W  ,!%!1111111DD-~%*.$ (,D$ - - - - - - - - % **,,, - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -#$++---(,D$$tD$++++1$77##E***iooe,,,,,,,,, - - - - - - - - % **,,, - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -&   "&i&&(((((((((  - - - - - - - - % **,,, - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -    "&iooa(((((((((uuu - - - - - - - - % **,,, - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -    - - - - - - - - % **,,, - - - - - - - - - - - - - - - - - - - - - - - - - - - -sB -B 3B  BB0H# CE>E2;E><H#!E EEE22E>6H#> FAH#!H HH#0L5L8!!J J"J( L51'L0L8)!L L'*L'0L55L88N !M9'N 9 N N N N cK|j4d{V|jr dddd{VdSd|_d|_|j}d|_|j}|jdddd{Vn#1d{VswxYwY|N|s:| |d{Vn#tj tf$rYnwxYw|5t|ddx}" |d{Vn#t$rYnwxYw |j d{VdS#t$rYdSwxYw)aStop the run early. Marks the stream exhausted and wakes any pump-waiters. Cancels an in-flight pull if one is running, then closes the underlying graph iterator, so running nodes and nested subgraphs are cancelled whether or not a pump is mid-pull. Closes the mux; any `apush` blocked on backpressure wakes and returns without appending. Idempotent. NTr)rr7rrrrrrrrr[rar5r)rAr anext_taskrs rrbzAsyncGraphRunStream.abortso? ) ) ) ) ) ) ) )  ) ) ) ) ) ) ) ) ) ) ) ) ) )#DO!DN+K $D )J O & & ( ( ( ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) )  !*//*;*; !                *I6      #";$???L fhh     )""$$ $ $ $ $ $ $ $ $ $    DD sL A:K|d{VdSrdrnros r __aexit__zAsyncGraphRunStream.__aexit__s. jjllr rqcrKt|jd{V|jjjx}||jS)aDrive the run to completion and return the final state. Methods (not properties) on the async lane so `run.output` without `await` raises at type-check time instead of silently yielding a coroutine object. Example: ```python output = await run.output() ``` Raises: BaseException: If the run ended with an error. N)r#rr5rsrtr8rus rrwzAsyncGraphRunStream.outputsK!!12222222229$+ +C 8I|r crKt|jd{V|jjjx}||jS)zDrive the run to completion and return whether it was interrupted. Raises: BaseException: If the run ended with an error. N)r#rr5rsrtr9rus rryzAsyncGraphRunStream.interrupted-sL!!12222222229$+ +C 8I  r rzcrKt|jd{V|jjjx}||jS)zDrive the run to completion and return interrupt payloads. Raises: BaseException: If the run ended with an error. N)r#rr5rsrtr:rus rrOzAsyncGraphRunStream.interrupts9sL !!12222222229$+ +C 8Ir AsyncIterator[ProtocolEvent]c>|jjSr~)r5rs __aiter__res rrzAsyncGraphRunStream.__aiter__Dsy **,,,r N)rrr1rr.r2rrrrrr)rrrrr)rr)rrrrrrCrTrrrbrrrwryrOrrr rrr?sE@*)))1111....4444 "*"*"*"*"*"*H 0 0 0 0))))A-A-A-A-F((((T( ! ! ! !     ------r rcPeZdZUdZded<ded<ded<ded<ded <d ed <d S) _SubgraphRunStreamMixinumSubgraph metadata + parent-pump delegation shared by both lanes. Inherits from `GraphRunStream` (or `AsyncGraphRunStream`) with `graph_iter=None` + `wire_pump=False` — the mini-mux is driven by the parent's pump (inherited via `StreamMux._make_child`), and the handle never pulls upstream itself. Pump-driving methods delegate to the parent pump so `handle.output` and friends drive the root run. Subclasses set the parent pump function captured at construction (`_parent_pump_fn` / `_parent_apump_fn`) and override `_pump_next` / `_apump_next` to delegate to it. Status is updated in place by `SubgraphTransformer`. Iterate `run.subgraphs` to receive handles as subgraphs spawn, then drill into projections inside the loop body **before** the next pump cycle — same lazy-subscribe constraint as root projections. tuple[str, ...]path str | None graph_nametrigger_call_idrstatuserrorr2_seen_terminalN)rrrrrrr rrrIsf&r rc4eZdZdZddddfd ZddZxZS)SubgraphRunStreamzASync handle for a discovered subgraph (extends `GraphRunStream`).Nrrr1rrrrrrrrc|j|_td|d||_||_||_d|_d|_d|_ dS)NF)r/r1r.started) r_parent_pump_fnsuperrCrrrrrrrAr1rrr __class__s rrCzSubgraphRunStream.__init__hsm;>,      $.  #r r2cz|js|js|jjjs|jdS|S)zDelegate to the parent's pump. Cursors on this handle's projections call here when their buffers empty. Driving the parent fans events into our mini-mux, transparently advancing the whole run. NF)r7rr5rsrrres rrFzSubgraphRunStream._pump_nextsM O " y ( #+5##%%%r r1rrrrrrrrrr)rrrrrCrF __classcell__rs@rrresiKK"&&* $$$$$$$$.&&&&&&&&r rc4eZdZdZddddfd ZddZxZS)AsyncSubgraphRunStreamzGAsync handle for a discovered subgraph (extends `AsyncGraphRunStream`).Nrr1rrrrrrrrc|j|_td|d||_||_||_d|_d|_d|_ dS)NF)rr1r.r) _apump_fn_parent_apump_fnrrCrrrrrrrs rrCzAsyncSubgraphRunStream.__init__soGJm      $.  #r r2cK|js|js|jjjs|jdS|d{VS)z$Delegate to the parent's async pump.NF)r7rr5rsrrres rrz"AsyncSubgraphRunStream._apump_nextsc O " y ( $,5**,,,,,,,,,r rr)rrrrrCrrrs@rrrsiQQ"&&* $$$$$$$$* - - - - - - - -r r)rrrr)rr!rr)& __future__rrcollections.abcrrrrrtypesr r typingr r langchain_core._apir langgraph.stream._convertrlanggraph.stream._muxrlanggraph.stream._typesr0langchain_core.language_models.chat_model_streamrrrrlanggraph.stream.transformersrrrr#r&rrrrrr rrso""""""QQQQQQQQQQQQQQ11111111%%%%%%%%$$$$$$??????++++++111111O >=====NNNNNNNN        DEEEW'W'W'W'W'W'W'FEW'tDEEEF-F-F-F-F-F-F-FEF-R8(&(&(&(&(&(?(&(&(&V!-!-!-!-!-02I!-!-!-!-!-r