ޠj1SSKJr SSKrSSKJr SSKJrJrJrJ r SSK J r J r J r \ (aSSKJr \ "S5r"SS \ \5rg) ) annotationsN)deque) AsyncIterator AwaitableCallableIterator) TYPE_CHECKINGGenericTypeVar) StreamMuxTc\rSrSrSrSSS.SSjjjrSSjrSSjrSSjrSS jr SS jr SS jr SS jr SS jr SSjrSSjrSSSjjrSSSjjrSrg) StreamChanneluSingle-consumer drainable queue for streaming events, with optional protocol auto-forwarding. When constructed with a `name`, the StreamMux auto-wires every `push()` to also inject a `ProtocolEvent` into the main event stream using the channel's name as the method. When constructed without a name, the channel is local-only — items are only visible to in-process consumers that iterate the channel directly. Items are popped off the front as the consumer advances — there is no retention beyond what's currently queued. A channel accepts exactly one subscriber; a second `__iter__` / `__aiter__` call raises. Use `tee(n)` / `atee(n)` for fan-out. Starts unbound — neither `__iter__` nor `__aiter__` is available until the StreamMux calls `_bind(is_async)`. After binding, only the matching iteration protocol works; the other raises `TypeError`. Pump wiring (set by the run stream, not by `_bind`): - `_request_more`: sync pump callable, returns True if a new event was produced. - `_arequest_more`: async pump coroutine factory, same contract. Memory is bounded by caller pace: both sync and async use caller- driven pumps, so each cursor advance produces at most one event. Lazy-subscribe: `push` appends to the local buffer only when a subscriber has registered. Auto-forward via `_wire_fn` always fires regardless of subscription state. Lifecycle (`close` / `fail`) is managed by the mux — transformers don't need to close their channels manually. N)maxlencUbUS::a [S5eXl[5UlX lSUlSUlSUlSUlSUl SUl SUl SUl g)aInitialize the channel. Args: name: Optional protocol channel name. When set, the StreamMux wires every `push()` to also inject a `ProtocolEvent` into the main event stream. Surfaced on the wire as `custom:` for user-defined transformers, or as `` for channels owned by a native transformer (`_native = True`). When `None`, the channel is local-only. maxlen: Accepted for forward compatibility; currently unused. The caller-driven pump bounds memory naturally for single-consumer use. Raises: ValueError: If `maxlen` is not a positive integer or `None`. Nrz3StreamChannel maxlen must be a positive int or NoneF) ValueErrornamer_items_maxlen_closed_error _is_async _subscribed _request_more_arequest_more_wire_fn_mux)selfrrs Y/var/www/html/gaurav/venv/lib/python3.13/site-packages/langgraph/stream/stream_channel.py__init__StreamChannel.__init__1sj$  &A+RS S ,1G #)  ,0 &* 8<DH48 &* cXlgN)r)rmuxs r _bind_muxStreamChannel._bind_muxYs r#c@URb [S5eXlg)aBind this channel to sync or async mode. Called by the StreamMux after transformer registration. Must be called exactly once before any iteration. Args: is_async: True to enable async iteration, False for sync. Raises: RuntimeError: If the channel has already been bound. NzStreamChannel is already bound)r RuntimeError)ris_asyncs r _bindStreamChannel._bind\s >> %?@ @!r#cXlg)z8Install the auto-forward callback (called by StreamMux).N)r)rfns r _wireStreamChannel._wireps r#c&UR(aaUR(a [S5eURbURR 5OSnUR R X!45 URbURU5 gg)aAppend an item. Auto-forwards if wired. The local buffer append is a no-op when no subscriber is registered, but auto-forwarding always fires so wired events reach the main event log regardless of subscription state. Items are stored as `(stamp, item)` tuples where stamp is a monotonic counter from the owning mux. Stamps are stripped by the default cursors; raw stamped tuples are visible on `_items`. Raises: RuntimeError: If the channel is closed (and subscribed). z%Cannot push to a closed StreamChannelNr)rrr*r_next_push_seqrappendr)ritemstamps r pushStreamChannel.pushxsl   ||"#JKK26))2GDII,,.QE KK  } - == $ MM$  %r#cSUlg)zMark the channel as complete.TN)rrs r closeStreamChannel.closes  r#cXlSUlg)zYMark the channel as errored. Args: err: The exception to surface to the subscriber. TN)rr)rerrs r failStreamChannel.fails   r#cURc [S5eUR(a [S5eUR(a [S5eSUlUR 5$)zSubscribe and return a sync cursor. Can be called only once. Raises: TypeError: If the channel is unbound or bound to async mode. RuntimeError: If the channel already has a subscriber. VStreamChannel has not been bound yet. Register the transformer with a StreamMux first.uFThis StreamChannel is bound to async mode — use 'async for' instead.z@StreamChannel already has a subscriber; use .tee(n) for fan-out.T)r TypeErrorrr* _sync_cursorr:s r __iter__StreamChannel.__iter__sn >> !C  >>X    R    ""r#c#X# UR(a!URR5upUv OrUR(aURb URegURb9UR 5(d#UR(dUR(dgOgM7fr%)rpopleftrrrr_stampr5s r rDStreamChannel._sync_cursorsz{{#{{224  ;;*++%##/))++;;t||sB(B*cURc [S5eUR(d [S5eUR(a [S5eSUlUR 5$)zSubscribe and return an async cursor. Can be called only once. Raises: TypeError: If the channel is unbound or bound to sync mode. RuntimeError: If the channel already has a subscriber. rBu?This StreamChannel is bound to sync mode — use 'for' instead.zAStreamChannel already has a subscriber; use .atee(n) for fan-out.T)rrCrr* _async_cursorr:s r __aiter__StreamChannel.__aiter__sn >> !C ~~Q    S  !!##r#cn# UR(a"URR5upU7v OzUR(aURb URegURbAUR 5IShvN (d#UR(dUR(dgOgMN07fr%)rrHrrrrIs r rMStreamChannel._async_cursors{{#{{224  ;;*++%$$0!00222;;t||3sBB5B31B5c^^^^US:a [S5eUR5m[U5Vs/sH n[5PM snmS/mSUUU4Sjjm[ U4Sj[U555$s snf)aSubscribe and return `n` independent sync iterators. Each branch has its own buffer; items pulled from the underlying cursor are copied into every branch. Branches are naturally bounded by caller pace since the sync pump is caller-driven. Args: n: Number of branches to create. Must be >= 1. Returns: A tuple of `n` iterators over the same underlying stream. Raises: TypeError: If the channel is unbound or bound to async mode. RuntimeError: If the channel already has a subscriber. ValueError: If `n` < 1. ztee() requires n >= 1Fc3># TUnU(aUR5v O1TS(ag[T5nTHnURU5 M MM![a STS'gf=f7fNTr)rHnext StopIterationr4)ibufr5bbuffers exhaustedsources r branch!StreamChannel.tee..branchsq!*C++-'q\#F|%%)'+ ! s',A, AA,A)&A,(A))A,c32># UH nT"U5v M g7fr%.0rXr^s r $StreamChannel.tee..11VAYY)rXintreturn Iterator[T])rrErangertuple)rn_r^r[r\r]s @@@@r teeStreamChannel.teesj& q545 549!H"=Hq57H"=G  ' ' 1a111'#>sA4c*^^^^^^US:a [S5eUR5m[U5Vs/sH n[5PM snmS/mS/m[R "5mSUUUUU4Sjjm[ U4Sj[U555$s snf)a.Subscribe and return `n` independent async iterators. Caller-driven fan-out: each branch's `__anext__` either pops from its own buffer or, under a shared `asyncio.Lock`, pulls one item from the underlying cursor and distributes it to every branch's buffer. Args: n: Number of branches to create. Must be >= 1. Returns: A tuple of `n` async iterators over the same underlying stream. Raises: TypeError: If the channel is unbound or bound to sync mode. RuntimeError: If the channel already has a subscriber. ValueError: If `n` < 1. rSzatee() requires n >= 1FNcR># TUnU(aUR57v MTS(a TSbTSegTIShvN U(d TS(aSSS5IShvN MbT R5IShvN nTHnUR U5 M SSS5IShvN MNmNMN4![a STS'SSS5IShvN M[a&nUTS'STS'SnASSS5IShvN MSnAff=fNa!,IShvN (df  Nv=f7frU)rH __anext__StopAsyncIteration Exceptionr4) rXrYr5erZr[errorr\lockr]s r r^"StreamChannel.atee..branch<s!*C++-'Q<Qx+#Ah4il  44!%+%5%5%77%% 4  8-!'+ !   44%!#$a'+ !   44! 444s?D'B0D'D  D'$B2%D',B6?B4B6D  D')D *D'2D'4B66DD  D'CD' D" D,D 0 D';C><D'DD  D' D$D  D$ D'c32># UH nT"U5v M g7fr%rarbs r rd%StreamChannel.atee..Urfrg)rXrhriAsyncIterator[T])rrNrkrasyncioLockrl) rrmrnr^r[rwr\rxr]s @@@@@@r ateeStreamChannel.atee s}( q556 6!49!H"=Hq57H"=G -1F||~ ' '21a111=#>sB) rrrrrrrrrrrr%)rz str | Nonerz int | NoneriNone)r&r rir)r+boolrir)r/zCallable[[T], None]rir)r5r rir)rir)r> BaseExceptionrir)rirj)rir|))rmrhriztuple[Iterator[T], ...])rmrhriztuple[AsyncIterator[T], ...])__name__ __module__ __qualname____firstlineno____doc__r!r'r,r0r7r;r?rErDrNrMror__static_attributes__rar#r rrs\ D"+"+"+P"( ,#.($.()2V5252r#r) __future__rr} collectionsrcollections.abcrrrrtypingr r r langgraph.stream._muxr r rrar#r rs;"HH22/ CLG2GAJG2r#