ޠjcbSSKJr SSKrSSKJrJrJrJrJr SSK J r J r SSK J r Jr SSKJr SSKJr SSKJr SS KJr \ (aSS KJrJr SS KJr SS KJrJr SS jrSSjr \"SS9"SS55r!\"SS9"SS55r""SS5r#"SS\!\#5r$"SS\"\#5r%g)) annotationsN) AsyncIterator AwaitableCallableIteratorMapping)MappingProxyType TracebackType) TYPE_CHECKINGAny)beta)convert_to_protocol_event) StreamMux) ProtocolEvent)AsyncChatModelStreamChatModelStream StreamChannel)LifecyclePayloadSubgraphStatusc<U"5(aU"5(aMgg)z*Call the sync pump until it returns False.Npumps U/var/www/html/gaurav/venv/lib/python3.13/site-packages/langgraph/stream/run_stream.py_drive_until_doners &&  &&cl# U"5IShvN (aU"5IShvN (aMggN"N7f)z+Call the async pump until it returns False.Nrrs r_adrive_until_doners,, ,,,s 4042 444z4The v3 streaming protocol on Pregel is experimental.)messagec\rSrSr%SrS\S'S\S'S\S'S \S 'S S .SS jjrSSjrSSjrSSjr SSjr S Sjr S!Sjr \ S"Sj5r\ SSj5r\ S#Sj5rS$SjrS%SjrSrg)&GraphRunStream$uSync 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_pumpcFXlX l[UR5UlSUlSUlSUl/Ul[UR5Ul URHn[XURU5 M U(aURU5 gg)aInitialize 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)self graph_itermuxr+keys r__init__GraphRunStream.__init__Cs&& -=cnn-M.2 !&(&*399o??C Ds~~c2 3#   # #C ( rc:URUR5 g)a<Wire 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_nextr:r<s rr9!GraphRunStream._wire_request_morecs doo&rcUSS:wagUSnUSUR:wagUSUlURSS5nU(a#S UlURR U5 gg z;Track values-event state for output/interrupted/interrupts.methodr%Nparams namespacedata interruptsrTr6r1getr2r3extendr:eventrHrKs r_observe_eventGraphRunStream._observe_eventno ?h & x + $"2"2 2 f~ ZZ b1  $D     # #J / rcUR(d URcg[UR5n[U5nUR U5 UR R U5 g![a$ UR R5 SUlg[a,nUR RU5 SUlSnAgSnAff=f)zPull 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) r0r-nextrrQr.push StopIterationclose Exceptionfailr:partrPes rrBGraphRunStream._pump_next{s ??d..6 (()D-d3E    & IINN5 !  IIOO "DO  IINN1 "DO sA A..+C C$"C  CcUR(agSUlURnSUlUb[USS5=nbU"5 URR 5 g![a N(f=f![a gf=f)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. NTrX)r0r-getattrrYr.rX)r:r;rXs rabortGraphRunStream.aborts ?? %%   "!*gt<<I   IIOO      s$A$ A4$ A10A14 BBcU$Nrr:s r __enter__GraphRunStream.__enter__s rc$UR5 grdrar:exc_typeexctbs r__exit__GraphRunStream.__exit__s rc[UR5 URRR=nbUeUR $)z7Drive the run to completion and return the final state.)rrBr._events_errorr1r:errs routputGraphRunStream.outputs: $//*99$$++ +C 8I||rc[UR5 URRR=nbUeUR $)zDrive the run to completion, then return whether it was interrupted. Raises: BaseException: If the run ended with an error. )rrBr.rqrrr2rss r interruptedGraphRunStream.interrupteds< $//*99$$++ +C 8I   rc[UR5 URRR=nbUeUR $)zyDrive the run to completion, then return interrupt payloads. Raises: BaseException: If the run ended with an error. )rrBr.rqrrr3rss rrKGraphRunStream.interruptss< $//*99$$++ +C 8Irc@[URR5$z>&(133"&!#/2!UDd)c(m+/3 ( 0HD| zz"))990"$))O yyy " ! Q<57?$)=D!1##+G#4#;#;#C#C#ELF7D/)99--D|466!$T(0(8HD#/ #%:::')yy'<.0ii$(HHTN )9 t9.!;d)c(m+>oo'!&(hoo'!&(s= KEJ#%J#A=J#J#J#+AJ#K# KK)r0r-r2r3r1r.r6r/N)r;zIterator[Any] | Noner<rr+boolreturnNoner<rrrrPrrrrrrr)rr"rkztype[BaseException] | NonerlzBaseException | NonermzTracebackType | Nonerrrzdict[str, Any] | Nonerz list[Any])rzIterator[ProtocolEvent])rstrrzIterator[tuple[str, Any]])r __module__ __qualname____firstlineno____doc____annotations__r>r9rQrBrarfrnpropertyrurxrKrr__static_attributes__rrrr"r"$s0 *),,..// )())  )  )@ ' 022," !    ! !    '_'rr"c\rSrSr%SrS\S'S\S'S\S'S \S 'S S .SS jjrSSjrSSjrSSjr SSjr SSjr S Sjr S!Sjr SSjrS"SjrS#SjrSrg)$AsyncGraphRunStreami?uSAsync 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*cXlX l[UR5UlSUlSUlSUl/Ul[UR5Ul [R"5Ul SUlSUlSUlUR"Hn[%XURU5 M U(aUR'U5 gg)aInitialize 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_aiterr.r r/r0r1r2r3r4r5r6asyncio Condition _pump_cond_pumping _anext_task _abortingr7r8_wire_arequest_more)r: graph_aiterr<r+r=s rr>AsyncGraphRunStream.__init__fs&( -=cnn-M.2 !&(&*399o!++- 7;??C Ds~~c2 3#   $ $S ) rcUSS:wagUSnUSUR:wagUSUlURSS5nU(a#S UlURR U5 ggrFrLrOs rrQ"AsyncGraphRunStream._observe_eventrSrc:URUR5 g)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_nextrCs rr'AsyncGraphRunStream._wire_arequest_mores t''(rc |# URIShvN UR(d URcSSS5IShvN gUR(aDURR 5IShvN UR(+sSSS5IShvN $SUlSSS5IShvN [ R "URR55UlURIShvN nSUl[U5nURU5 URR!U5IShvN URIShvN SUlURR5 SSS5IShvN gGNzGNNGNNN!,IShvN (df  N=fN![ Ra UR(arSUlSUlURIShvN SUlURR5 SSS5IShvN g!,IShvN (df  g=fURR5 ef=f!SUlf=fGN8GN%N!,IShvN (df  g=f!["a SUlURR%5IShvN URIShvN SUlURR5 SSS5IShvN g!,IShvN (df  g=f[&anSUlURR)U5IShvN SnAURIShvN SUlURR5 SSS5IShvN g!,IShvN (df  g=fSnAff=f!URIShvN SUlURR5 SSS5IShvN f!,IShvN (df  f=f=f7f)uDrive 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)rr0rrwaitr ensure_future __anext__rCancelledErrorr notify_allcancelrrQr.apushStopAsyncIterationacloserYafailr[s rrAsyncGraphRunStream._apump_nexts(???$"3"3";#??}}oo**,,,??* #??!DM#?$ -  $+#8#89J9J9T9T9V#W  ,!%!1!11D(,D$1$7##E*iiooe,,, % **,'W# - #???$2--~~*.$ (,D$ % **,'#$$++-(,D$-'& "&ii&&(((  % **,'  "&iiooa((( % **,'    % **,'sP<F P< F P<FP<.F6F7F P<FP<F$ P</F0P<63J*F69F4:F6?AJI8JP<I;P<"J< P<I>P<P<FP<P<F1 F# ! F1-P<4F66,I)"I,#J*P<:G=;P<?"H3! P<,H/-P<3I 9H< : I P< I))I,, I55J;P<>P<JJ  JP<.OK  OOP<K" P<$"L P<LP<L/L!  L/+P<2 O;%O  M#!O &O*P<:M=;P<?"N3! P<,N/-P<3O 9N< : O P< OOP9&O) 'P9+"P P9PP9P6 %P(& P6 2P99P<c# URIShvN UR(aSSS5IShvN gSUlSUlURnSUlURnURR 5 SSS5IShvN Wb0UR 5(dUR5 UIShvN Wb [USS5=nbU"5IShvN URR5IShvN gNNN!,IShvN (df  N=fNk![R[4a Nf=fNj![a Ntf=fNY![a gf=f7f)a`Stop 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)rr0rrrrrrrrrYr`r.r)r:r anext_taskrs rraAsyncGraphRunStream.aborts6???#??#DO!DN++K $D ))J OO & & (#?  !*//*;*;          #";$??L h ))""$ $ $9#??? !**I6     %   sE2D E2D E2DE2AD E2 D,E2;D.D,D.E2 E#E$E)E"E E" E2E2E2D)D  D)%E2,D..E E2 E  E2E EE2EE2 E"" E/,E2.E//E2c# U$7frdrres r __aenter__AsyncGraphRunStream.__aenter__s  sc@# UR5IShvN gN7frdrirjs r __aexit__AsyncGraphRunStream.__aexit__s jjls c# [UR5IShvN URRR=nbUeUR $N57f)aKDrive 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)rrr.rqrrr1rss rruAsyncGraphRunStream.outputsJ!!1!122299$$++ +C 8I|| 3AA6Ac# [UR5IShvN URRR=nbUeUR $N57f)zDrive the run to completion and return whether it was interrupted. Raises: BaseException: If the run ended with an error. N)rrr.rqrrr2rss rrxAsyncGraphRunStream.interrupted-sL!!1!122299$$++ +C 8I    3rc# [UR5IShvN URRR=nbUeUR $N57f)zwDrive the run to completion and return interrupt payloads. Raises: BaseException: If the run ended with an error. N)rrr.rqrrr3rss rrKAsyncGraphRunStream.interrupts9sL !!1!122299$$++ +C 8I 3rcJURRR5$r})r.rq __aiter__res rrAsyncGraphRunStream.__aiter__Dsyy  **,,r) rrr0rr2r3r1r.rrr6r/N)rzAsyncIterator[Any] | Noner<rr+rrrrrrr)rrrrr)rzAsyncIterator[ProtocolEvent])rrrrrrr>rQrrrarrrurxrKrrrrrrr?s@ *)11..44 "*."*"*  "*  "*H 0)A-F(T," !   ( !  -rrcV\rSrSr%SrS\S'S\S'S\S'S\S 'S\S 'S \S 'S rg)_SubgraphRunStreamMixiniIu5Subgraph 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_idrstatuserrorr_seen_terminalrN)rrrrrrrrrrrrIs-&   rrcV^\rSrSrSrSSS.SU4SjjjrS SjrSrU=r$) SubgraphRunStreamiezASync handle for a discovered subgraph (extends `GraphRunStream`).Nrrc>URUl[TU] SUSS9 X lX0lX@lSUlSUlSUl g)NF)r;r<r+started) r_parent_pump_fnsuperr>rrrrrrr:r<rrr __class__s rr>SubgraphRunStream.__init__hsT;>,,    $.  #rcUR(dCUR(d2URRR(d UR cgUR 5$)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. F)r0rr.rqrrres rrBSubgraphRunStream._pump_nextsE OO""yy  ((##+##%%r)rrrrrrr r<rrrrrrrrrr) rrrrrr>rBr __classcell__rs@rrresRK"&&* $ $ $  $ $ $ $$.&&rrcV^\rSrSrSrSSS.SU4SjjjrS SjrSrU=r$) AsyncSubgraphRunStreamizGAsync handle for a discovered subgraph (extends `AsyncGraphRunStream`).Nrc>URUl[TU] SUSS9 X lX0lX@lSUlSUlSUl g)NF)rr<r+r) _apump_fn_parent_apump_fnrr>rrrrrrrs rr>AsyncSubgraphRunStream.__init__sVGJmm    $.  #rc# UR(dCUR(d2URRR(d UR cgUR 5IShvN $N7f)z$Delegate to the parent's async pump.NF)r0rr.rqrrres rr"AsyncSubgraphRunStream._apump_nextsN OO""yy  (($$,**,,,,sA)A2+A0,A2)rrrrrrrrr) rrrrrr>rrrrs@rrrsRQ"&&* $ $ $  $ $ $ $$* - -rr)rzCallable[[], bool]rr)rzCallable[[], Awaitable[bool]]rr)& __future__rrcollections.abcrrrrrtypesr r typingr r langchain_core._apir langgraph.stream._convertrlanggraph.stream._muxrlanggraph.stream._typesr0langchain_core.language_models.chat_model_streamrrrrlanggraph.stream.transformersrrrrr"rrrrrrrrs"QQ1%$?+1 >N  DEW'W'FW'tDEF-F-FF-R8(&(?(&V!-02I!-r