codekingpro/portable-devtools
114k
1�
2 ��j�N � � � S SK Jr S SKrS SKrS SKJrJr S SKJr S SK J3r4J r J r S SK
Jr \S/\ 4 r " S S 5 rg)5� )� annotationsN)� Awaitable�Callable)�Any)�
ProtocolEvent�StreamTransformer�transformer_requires_async)�
StreamChannel�tuple[str, ...]c �� � \ rS rSrSr SSSSSS. SS jjjrS S jrS S6 jrS S jrS S jr S S
jr7S!S jr S"S jr S#S jr
S$S jrS"S jrS#S jrS$S jrS%S jrSS. S&S jjrS'S jrSrg)(� StreamMux� u5 Central event dispatcher for the streaming infrastructure.8 9Owns the main event log and routes events through a transformer10pipeline. StreamChannels with a name discovered in transformer11projections are auto-wired so that every `push()` also injects a12`ProtocolEvent` into the main log. StreamChannels without a name13are local-only.14 15Pass `is_async=True` when the mux will be consumed via async16iteration (`handler.astream()`). All StreamChannel instances17discovered during registration are automatically bound to the18matching mode.19 20Attributes:21 extensions: Merged projection dict across all registered22 transformers. Treat as read-only — mutations won't be23 reflected back in individual transformers' state.24 native_keys: Projection keys contributed by transformers with25 `_native = True`.26NF� T)�is_async� factories�scope� _assign_seqc � � X l X@l XPl [ 5 U l U R R US9 U R R
U 5 / U l / U l SU l SU l27 0 U l [ 5 U l
0 U l 0 U l Ub [! U5 OSU l SU l SU l Ub U H nU R) U" U5 5 M U=( d S H nU R) U5 M g)u� Initialize the mux and register transformers in order.28 29Callers pass either `transformers` (pre-built instances) or30`factories` (callables producing fresh instances per mux). Each31transformer's `init()` is called, projections are merged into32`extensions`, `_native` keys are recorded in `native_keys`, and33any StreamChannel instances are bound and (if named) wired.34 35Args:36 transformers: Already-built transformer instances. Registered37 only on this mux — they are NOT cloned into child38 mini-muxes built by `_make_child`. Use `factories` for39 transformers that should propagate to nested scopes.40 is_async: True for async dispatch (`apush` / `aclose` /41 `afail`), False for the sync path.42 factories: One-argument callables `(scope) -> StreamTransformer`.43 Called once with this mux's `scope` here, and cloned44 again per child scope by `_make_child` so each45 sub-mux gets fresh instances.46 scope: The namespace the mux operates within. The root mux47 is `()`.48 _assign_seq: Internal flag for child muxes. Root muxes assign49 monotonic `seq` numbers when appending to their main event50 log; child muxes share forwarded event objects and must not51 mutate their envelopes.52 53Raises:54 RuntimeError: If any transformer requires an async run but55 the mux is in sync mode.56 TypeError: If a transformer's `init()` doesn't return a dict.57 ValueError: If transformers' projection keys collide.58�r r Nr )r r r r59 �_events�_bind� _bind_mux�
_transformers� _channels�_seq� _push_seq�60extensions�set� native_keys�_projection_owners�_transformer_by_key�list�61_factories�_pump_fn� _apump_fn� _register)�self� transformersr r r r �factory� transformers �[D:\code\apps\devtools\python\user_packages\Python313\site-packages\langgraph/stream/_mux.py�__init__�StreamMux.__init__0 s� � �R !�
�&+�62�&��5B�_�� � � � ���H��-� � � � � �t�$�68���35����� ����*,���%(�U���24�� �AC�� � )� 4�D��O�$�
�� 48��
�?C��� � �$�����w�u�~�.� %�'�-�2�-�K� �N�N�;� '� .� c �8 � U R R U5 $ )z@Return the transformer that contributed `key` to the projection.)r! �get)r' �keys r+ �transformer_by_key� StreamMux.transformer_by_key} s � ��'�'�+�+�C�0�0r. c �D � U =R S-
sl U R $ )N� )r )r' s r+ �_next_push_seq�StreamMux._next_push_seq� s � � ���!����~�~� r. c � � Xl XR l U R H nXl M U R H n[ USS5 nUc M U" U5 M g)a� Wire the sync pull callback onto every projection in this mux.63 64Records the pump on the mux so child mini-muxes built by65`_make_child` can inherit it. Propagates to:66- the main event log (`self._events`)67- every projection StreamChannel in `extensions`68- any registered transformer that exposes `_bind_pump` (e.g.69 `MessagesTransformer` so `ChatModelStream` instances drive the70 shared pump from their cursors)71�72_bind_pumpN)r$ r �
_request_morer r �getattr)r' �fn�chr* �binds r+ � bind_pump�StreamMux.bind_pump� sR � � �
�%'� � �"��.�.�B� !� � !� �-�-�K��;� �d�;�D�� ��R�� .r. c � � Xl XR l U R H nXl M U R H n[ USS5 nUc M U" U5 M g)z!Async counterpart to `bind_pump`.� _bind_apumpN)r% r �_arequest_morer r r; )r' r< r= r* �abinds r+ �73bind_apump�StreamMux.bind_apump� sP � ���&(� � �#��.�.�B� "� � !� �-�-�K��K� ��=�E�� ��b� � .r. c � � U R c [ S5 e[ U R U R USS9nU R b UR U R 5 U R b UR U R 5 U$ )aj Build a mini-mux with the same factories scoped to `scope`.74 75Used by `SubgraphTransformer` to attach a fresh transformer76pipeline to each discovered subgraph handle. The child mux77inherits the current pump bindings (so cursors on its78projection logs drive the root pump), carries the same factory79list forward to any grandchild subgraphs, and does not assign80`seq` numbers so forwarded events can be shared without81mutating their envelope.82 83Raises:84 RuntimeError: If the mux was not constructed with85 `factories=`. Mini-muxes require factories so each scope86 gets its own fresh transformer instances.87z�StreamMux._make_child requires the mux to be constructed with `factories=`; pre-built transformers can't be cloned to a new scope.F)r r r r )r# � RuntimeErrorr
r r$ r? r% rE )r' r �childs r+ � _make_child�StreamMux._make_child� s} � � �?�?� "� �)��
�88 ��o�o��]�]�� � 89�� �=�=� $� �O�O�D�M�M� *� �>�>� %� � � �T�^�^� ,�� r. c � ^ � [ U5 ( a2 T R ( d! [ [ U5 R S35 eUR 5 n[
U[ 5 ( d! [ S[ U5 R 35 e[ U5 [ T R 5 - nU( aH SR U 4S j[ U5 5 5 n[ S[ U5 R SU 35 e[ [ USS5 5 nT R R# U5 T R% X%S 9 T R R' U5 [ U5 R nU H! nUT R( U' UT R* U' M# U( a) T R, R' UR/ 5 5 UR1 T 5 g90) z�Register a single transformer.91 92Calls `transformer.init()`, stores the transformer for event93processing, binds any StreamChannel instances in the projection,94and merges the projection into `extensions`.95uz requires an async run — it overrides aprocess/afinalize/afail or sets requires_async=True. Use astream(), not stream().z1StreamTransformer.init() must return a dict, got z, c 3 �P ># � U H nU< S TR U S3v � M g7f)z (owned by �)N)r )�.0r1 r' s �r+ � <genexpr>�&StreamMux._register.<locals>.<genexpr>� s1 �� � � %�,�C� �'��T�%<�%<�S�%A�$B�!�D�,�s �#&z Transformer zF returned projection keys that conflict with already-registered keys: �_nativeF��nativeN)r r rH �type�__name__�init�96isinstance�dict� TypeErrorr r �join�sorted�97ValueError�boolr; r �append�_bind_and_wire�updater r! r �keys� _on_register)r' r* �98projection� conflicts� attributions� is_native�99owner_namer1 s ` r+ r& �StreamMux._register� s� �� � &�k� 2� 2�4�=�=� �� �$�-�-�.� /D� D��
�100 !�%�%�'�101��*�d�+�+����J�'�0�0�1�3��
� �102�O�c�$�/�/�&:�:� � � �9�9� %�!�)�,�%� �L� � �t�K� 0� 9� 9� :� ;�%��(��
�103 ���i��?�@� � ���!�!�+�.� ���J��9� ��� � �z�*��+�&�/�/�104� �C�+5�D� #� #�C� (�,7�D� $� $�S� )� � � � � � #� #�J�O�O�$5� 6�� � ��&r. c � � SnU R H nUR U5 ( a M SnM U( aQ U R ( a$ U =R S-
sl U R US' U R R U5 gg)a� Route an event through all transformers, then append to the main log.105 106Each transformer's `process()` is called in registration order.107If any transformer returns False, the event is suppressed from108the main log, but transformers that already saw it keep their109side effects.110 111On the root mux, `seq` is assigned right before an event enters112the main log, not before the transformer pipeline runs. This113ensures that events auto-forwarded from StreamChannels during114`process()` get earlier seq numbers than the original event,115preserving monotonic ordering in the root log. Child muxes do116not assign `seq`, so subgraph forwarding can share event objects117without mutating their envelopes.118 119Args:120 event: The protocol event to dispatch.121TFr5 �seqN)r �processr r r �push�r' �event�keepr* s r+ rm �StreamMux.push� sn � �& �� �-�-�K� �&�&�u�-�-� �� .� �� � �� � �Q�� � #�y�y��e� � �L�L� � �e� $� r. c �@ � SnU R H n UR 5 M U R H& nUR ( a M UR 5 M( U R R 5 Ub Ueg! [ a nUc Un SnAM� SnAM� SnAff = f)u� Finalize all transformers, close all projections and the main log.122 123StreamChannels discovered in transformer projections are124auto-closed after `finalize()` runs — transformers don't need125to close them manually. If any transformer's `finalize()` raises,126the remaining transformers, projections, and the main log are127still closed; the first error is re-raised after cleanup128completes.129 130Raises:131 BaseException: The first error raised by a transformer's132 `finalize()`, re-raised after cleanup finishes.133N)r �finalize�
BaseExceptionr �_closed�closer )r' � first_errorr* �er= s r+ rv �StreamMux.close s� � � -1� � �-�-�K�
$��$�$�&� .� �.�.�B��:�:�:����134� !�
� � ��� � � "� � � #�� !�
$� �&�"#�K� '��
$�s �A=�=135B �B�B c � � U R H n UR U5 M U R H' nUR ( a M UR U5 M) U R136 R U5 g! [ a My f = f)uS Fail all transformers, projections, and the main log.137 138StreamChannels discovered in transformer projections are139auto-failed — transformers don't need to fail them manually.140If any transformer's `fail()` raises, the remaining141transformers, projections, and the main log are still failed.142 143Args:144 err: The exception that ended the run.145N)r �failrt r ru r )r' �errr* r= s r+ r{ �StreamMux.fail- ss � � �-�-�K�
�� � ��%� .�146 �.�.�B��:�:�:����� � !�
� � ���#� �� !�
��
�s �A9�9147B�Bc � �. # � SnU R H% nUR U5 I Sh v�N ( a M# SnM' U( aQ U R ( a$ U =R S-
sl U R US' U R R U5 gg Nj7f)u� Dispatch an event on the async lane.148 149Awaits each transformer's `aprocess` in registration order150before appending to the main log. A slow `aprocess` serializes151the pipeline by design — that's the guarantee that lets a later152transformer (or a synchronous consumer) see the result of the153async work. For decoupled work, use `schedule()` from inside154`process` / `aprocess` instead.155 156The main log append is a non-blocking `push` — matching v1's157`put_nowait` shape. The root mux assigns `seq`; child muxes do158not, so forwarded subgraph events can be shared without copying.159Memory is bounded by caller pace via the caller-driven pump; see160`StreamChannel` for the full tradeoff story.161 162Args:163 event: The protocol event to dispatch.164TNFr5 rk )r �aprocessr r r rm rn s r+ �apush�StreamMux.apushF sy � � �& �� �-�-�K�$�-�-�e�4�4�4� �� .� �� � �� � �Q�� � #�y�y��e� � �L�L� � �e� $� � 5�s �&B�B�B�A Bc � �� # � U R 5 nU( a6 [ R " USS06I Sh v�N n[ S U 5 S5 nUb UeSnU R H n UR 5 I Sh v�N M U R H& nUR ( a M UR 5 M( U R R 5 Ub Ueg N� N`! [ a nUc Un SnAM� SnAM� SnAff = f7f)a� Finalize on the async lane.165 166Awaits every task started via `StreamTransformer.schedule()`167across all transformers, then calls `afinalize()` on each,168then auto-closes channels and the main event log.169 170If any scheduled task raised under `on_error="raise"`, or any171transformer's `afinalize` raises, the exception propagates.172The caller (the pump) handles it by routing into `afail`.173 174Raises:175 BaseException: The first scheduled-task or `afinalize`176 error, re-raised after cleanup.177�return_exceptionsTNc 3 � # � U H? n[ U[ 5 ( d M [ U[ R 5 ( a M; Uv � MA g 7f�N)rX rt �asyncio�CancelledError)rO �rs r+ rP �#StreamMux.aclose.<locals>.<genexpr>v s: � � � � $��!�!�]�3� � '�q�'�*@�*@� A� �A� $�s �A � A � A ) �_collect_scheduled_tasksr� �gather�nextr � afinalizert r ru rv r )r' �pending�results� first_errrw r* rx r= s r+ �aclose�StreamMux.aclosec s� � � � �/�/�1�� � #�N�N�G� L�t� L�L�G� �� $�� ��I� �$� ��,0� � �-�-�K�
$�!�+�+�-�-�-� .� �.�.�B��:�:�:����178� !�
� � ��� � � "� � � #�1 M� .�� �
$� �&�"#�K� '��
$�sQ �1C;�C�-C;�"C�5C�6C�:"C;� 5C;�C�179C8�"C3�' C;�3C8�8C;c � � # � U R 5 nU H nUR 5 M U( a [ R " USS06I Sh v�N U R H n UR U5 I Sh v�N M U R H' nUR ( a M UR U5 M) U R R ( d U R R U5 gg N� Ny! [ a M� f = f7f)z�Fail on the async lane.180 181Cancels every scheduled task across all transformers, awaits182them to completion, then runs each transformer's `afail` hook183and auto-fails channels and the main event log.184 185Args:186 err: The exception that ended the run.187r� TN) r� �cancelr� r� r �afailrt r ru r{ r )r' r| r� �taskr* r= s r+ r� �StreamMux.afail� s� � � � �/�/�1���D� �K�K�M� � ��.�.�'�B�T�B� B� B� �-�-�K�
�!�'�'��,�,�,� .�188 �.�.�B��:�:�:����� � !� �|�|�#�#� �L�L� � �c� "� $�
C� -�� �
��
�sO �A189D� C-�
D�!C1�5C/�6C1�:"D� AD�/C1�1190C?�;D�>C?�?Dc � � U R VVs/ s H1 n[ USS5 H nUR 5 ( a M UPM M3 snn$ s snnf )z@Return a snapshot of in-flight tasks scheduled via transformers.�_stream_scheduled_tasksr )r r; �done)r' r* r� s r+ r� �"StreamMux._collect_scheduled_tasks� sO � � $� 1� 1�191� 1� � � �-F��K���9�9�;�
�K�
� 1�192� 193�� 194s195 �*A �196A rS c � ^ � UR 5 H� n[ U[ 5 ( d M UR T R S9 UR T 5 T R R U5 UR c Mn U( a UR OSUR 3nSU 4S jjnUR U" U5 5 M� g)a� Bind and optionally wire StreamChannel instances in a projection.197 198All StreamChannels are bound and tracked. Channels with a name199are additionally wired for protocol auto-forwarding.200 201Args:202 projection: The projection dict returned by a transformer's203 `init()`.204 native: True when the owning transformer is `_native`.205 Named channels owned by a native transformer use the206 channel name directly as the protocol method;207 user-defined channels are prefixed with `custom:`.208r Nzcustom:c � >^ � SU U4S jjnU$ )Nc �* >� TR TU 5 g r� )�_forward)�item� method_namer' s ��r+ r� �AStreamMux._bind_and_wire.<locals>._make_forward.<locals>._forward� s �� � �M�M�+�t� <r. )r� r �return�Noner )r� r� r' s ` �r+ �
_make_forward�/StreamMux._bind_and_wire.<locals>._make_forward� s �� �=� =� (�r. )r� �strr� zCallable[[Any], None])209�valuesrX r210 r r r r r_ �name�_wire)r' rd rT �value�methodr� s ` r+ r` �StreamMux._bind_and_wire� s� �� � �&�&�(�E��%� �/�/�� � �T�]�]� �3�����%����%�%�e�,��:�:�)�+1�U�Z�Z����� �7M�F�(� �K�K�
�f� 5�6� )r. c �� � SU/ [ [ R " 5 S- 5 US.S.nU R ( a$ U =R S-
sl U R US' U R R U5 g)a6 Inject a ProtocolEvent for a StreamChannel push.211 212Forwarded events bypass the transformer pipeline to avoid213infinite recursion (a transformer that pushes to a channel214during `process()` would re-trigger itself). These events are215visible in this mux's main event log but are not passed through216transformers' `process()` methods. Only the root mux assigns217`seq` to forwarded channel events.218 219Args:220 method: The full protocol method (already with or without221 the `custom:` prefix; resolved by `_bind_and_wire`).222 item: The payload pushed onto the channel.223ro i� )� namespace� timestamp�data)rU r� �paramsr5 rk N)�int�timer r r rm )r' r� r� ro s r+ r� �StreamMux._forward� sf � � � � � �����t�!3� 4� �� 224�� � � � �I�I��N�I� �9�9�E�%�L� � � ���%� r. )r% r r r r# r r$ r r r! r r r r r r� ) r( z list[StreamTransformer] | Noner r^ r z list[TransformerFactory] | Noner r r r^ r� r� )r1 r� r� zStreamTransformer | None)r� r� )r< zCallable[[], bool]r� r� )r< z Callable[[], Awaitable[bool]]r� r� )r r r� r
)r* r r� r� )ro r r� r� )r� r� )r| rt r� r� )r� zlist[asyncio.Task[Any]])rd zdict[str, Any]rT r^ r� r� )r� r� r� r r� r� )rV �225__module__� __qualname__�__firstlineno__�__doc__r, r2 r6 r? rE rJ r& rm rv r{ r� r� r� r� r` r� �__static_attributes__r r. r+ r
r
s� � ��. 8<�K(� �59�!#� �K(�4�K(� � K(�226 3� K(� �
K(� �K(� 227�K(�Z1� ��( � �D('�T%�: �8 �2%�:* �X#�6228� =B� 7�(� 7�59� 7�
� 7�@!r. r
)�229__future__r r� r� �collections.abcr r �typingr �langgraph.stream._typesr r r � langgraph.stream.stream_channelr230 �TransformerFactoryr
r r. r+ �<module>r� sI �� "� � � /� �� �231 :� � 0� 1�3D� D�E� ��X!� X!r.