Ji.ddlZddlZddlmZddlmZmZmZmZm Z ddl m Z m Z ddl mZddlmZddlmZd ZGd d eZej,d eGd deZede eZGddeeZy)N)asynccontextmanager)AnyAsyncGeneratorGenericOptionalType) BaseModelValidationError)TypeVar) DictLikeModel)BaseSerializeric eZdZy)UnserializableKeyWarningN)__name__ __module__ __qualname__o/var/www/html/BankruptcyAI-uat/bankruptcy-ai/venv/lib/python3.12/site-packages/workflows/context/state_store.pyrrsrroncec(eZdZdZdeffd ZxZS) DictStatea" Dynamic, dict-like Pydantic model for workflow state. Used as the default state model when no typed state is provided. Behaves like a mapping while retaining Pydantic validation and serialization. Examples: ```python from workflows.context.state_store import DictState state = DictState() state["foo"] = 1 state.bar = 2 # attribute-style access works for nested structures ``` See Also: - [InMemoryStateStore][workflows.context.state_store.InMemoryStateStore] paramsc $t|di|y)Nr)super__init__)selfr __class__s rrzDictState.__init__,s "6"r)rrr__doc__rr __classcell__)rs@rrrs&###rrMODEL_T)bounddefaultceZdZUdZdZeeed<defdZdefdZ dedd fd Z d d de e e ffd Zede e e fd d ddfdZedeed ffdZefde dee de fdZde de dd fdZddZde de de fdZde de de dd fdZy )InMemoryStateStorea Async, in-memory, type-safe state manager for workflows. This store holds a single Pydantic model instance representing global workflow state. When the generic parameter is omitted, it defaults to [DictState][workflows.context.state_store.DictState] for flexible, dictionary-like usage. Thread-safety is ensured with an internal `asyncio.Lock`. Consumers can either perform atomic reads/writes via `get_state` and `set_state`, or make in-place, transactional edits via the `edit_state` context manager. Examples: Typed state model: ```python from pydantic import BaseModel from workflows.context.state_store import InMemoryStateStore class MyState(BaseModel): count: int = 0 store = InMemoryStateStore(MyState()) async with store.edit_state() as state: state.count += 1 ``` Dynamic state with `DictState`: ```python from workflows.context.state_store import InMemoryStateStore, DictState store = InMemoryStateStore(DictState()) await store.set("user.profile.name", "Ada") name = await store.get("user.profile.name") ``` See Also: - [Context.store][workflows.context.context.Context.store] )memory state_type initial_statecd||_tj|_t ||_y)N)_stateasyncioLock_locktyper()rr)s rrzInMemoryStateStore.__init__ds"# \\^ }-rreturnc>K|jjSw)zReturn a shallow copy of the current state model. Returns: MODEL_T: A `.model_copy()` of the internal Pydantic model. )r+ model_copyrs r get_statezInMemoryStateStore.get_stateis {{%%''sstateNcKt|t|js!tdt|j|j4d{||_dddd{y77#1d{7swYyxYww)zReplace the current state model. Args: state (MODEL_T): New state of the same type as the existing model. Raises: ValueError: If the type differs from the existing state type. zState must be of type N) isinstancer/r+ ValueErrorr.rr5s r set_statezInMemoryStateStore.set_stateqsu%dkk!235d4;;6G5HIJ J::  DK       sHAB A0B A4 B *A2+B 2B 4B:A= ;BB  serializerrct|jtr{i}|jjD]\}} |j |||<d|it|jjt|jjdS|j |j}|t|jjt|jjdS#t $rH}||j vr$tjd|dtYd}~td|d|d}~wwxYw) a<Serialize the state and model metadata for persistence. For `DictState`, each individual item is serialized using the provided serializer since values can be arbitrary Python objects. For other Pydantic models, defers to the serializer (e.g. JSON) which can leverage model-aware encoding. Args: serializer (BaseSerializer): Strategy used to encode values. Returns: dict[str, Any]: A payload suitable for [from_dict][workflows.context.state_store.InMemoryStateStore.from_dict]. z4Skipping serialization of known unserializable key: zY -- This is expected but will require this item to be set manually after deserialization.)categoryNz(Failed to serialize state value for key : _data) state_datar( state_module)r7r+ritems serialize Exceptionknown_unserializable_keyswarningswarnrr8r/rr)rr;serialized_datakeyvalueeserialized_states rto_dictzInMemoryStateStore.to_dicts: dkk9 - O"kk//1  U +5+?+?+FOC(  '8"4;;/88 $T[[ 1 < <  *33DKK@ /"4;;/88 $T[[ 1 < < +! d<<< RSVRWXtt%= !$B3%r!M sC11 E:-D=,D==ErLzInMemoryStateStore[MODEL_T]c|s|tS|jdi}|jdd}|dk(rN|jdi}i}|jD]\}} |j|||<t|} n|j|} || S#t$r} t d|d| d} ~ wwxYw) aRestore a state store from a serialized payload. Args: serialized_state (dict[str, Any]): The payload produced by [to_dict][workflows.context.state_store.InMemoryStateStore.to_dict]. serializer (BaseSerializer): Strategy to decode stored values. Returns: InMemoryStateStore[MODEL_T]: A store with the reconstructed model. r@r(rr?z*Failed to deserialize state value for key r>N)r?)rgetrB deserializerDr8) clsrLr;r@r(_data_serializeddeserialized_datarIrJrKstate_instances r from_dictzInMemoryStateStore.from_dicts y{# #%)),; %)), D   $)~~gr:  " .446  U-7-C-CE-J%c* '->?N'33J?N>""!$DSEA3Os'B## C,B==CcK|j4d{|j}|||_dddd{y7-7#1d{7swYyxYww)aEdit state transactionally under a lock. Yields the mutable model and writes it back on exit. This pattern avoids read-modify-write races and keeps updates atomic. Yields: MODEL_T: The current state model for in-place mutation. N)r.r+r9s r edit_statezInMemoryStateStore.edit_statesS::  KKEKDK        sAAAAA AAAAA A AApathr$cK|r|jdng}t|tkDrtdtd|j4d{ |j }|D]}|j ||} dddd{|S7=#t$r0|tur|cYcdddd{7Sd|d}t|wxYw7D#1d{7swYSxYww)a:Get a nested value using dot-separated paths. Supports dict keys, list indices, and attribute access transparently at each segment. Args: path (str): Dot-separated path, e.g. "user.profile.name". default (Any): If provided, return this when the path does not exist; otherwise, raise `ValueError`. Returns: Any: The resolved value. Raises: ValueError: If the path is invalid and no default is provided or if the path depth exceeds limits. .Path length exceeds segmentsNzPath 'z' not found in state) splitlen MAX_DEPTHr8r.r+_traverse_steprDEllipsis)rrXr$segmentsrJsegmentmsgs rrOzInMemoryStateStore.gets$'+4::c? x=9 $3I;iHI I:: & & &![['@G //w?E@ & &  &  &(*"N & & &tf$89 o%  & & & & & s~A C! B C!C %B 8C 9 C!C C! C C ! C!-B0.C!4CC  C! CC CC!rJcK|s td|jd}t|tkDrtdtd|j4d{|j }|ddD]} |j ||}|j||d|dddd{y7T#ttttf$ri}|j||||}YswxYw7=#1d{7swYyxYww)aSet a nested value using dot-separated paths. Intermediate containers are created as needed. Dicts, lists, tuples, and Pydantic models are supported where appropriate. Args: path (str): Dot-separated path to write. value (Any): Value to assign. Raises: ValueError: If the path is empty or exceeds the maximum depth. zPath cannot be emptyrZr[r\N) r8r]r^r_r.r+r`KeyErrorAttributeError IndexError TypeError _assign_step)rrXrJrbcurrentrc intermediates rsetzInMemoryStateStore.set s34 4::c? x=9 $3I;iHI I:: < <kkG$CR= ++"11'7CG +   gx|U ; < < <!.*iH+(*L%%gw E*G + < < < >ct|tr|||<y t|}|||<y#ttt f$rYnwxYwt |||y)zJAssign *value* to *segment* of *obj* (dict key, list index, or attribute).N)r7rsrtr8rjrisetattr)rrqrcrJrvs rrkzInMemoryStateStore._assign_stepLsY c4  CL  g,CCH Iz2    We$s)AA)r0N)rrrr rErr"__annotations__rr4r:rsstrrrM classmethodrUrrrWrarrOrnrpr`rkrrrr&r&4s<'V!,W .g. ((  W    ."2.tCH~.`%##CH~%#;K%# &%#%#N .$"?  =E"c"HSM""H"rsu*??/%*'   w f67# #2 )9i @g%)g%r