Ji',ddlmZddlmZmZmZddlmZddlm Z m Z ddl m Z m Z mZmZmZGdde ZGdd eZGd d eZGd d eZGddeZGddeZGddeZGddeZGddeZe eZy)) annotations) dict_items dict_keys dict_values)Enum)AnyType) BaseModel ConfigDictField PrivateAttrmodel_serializerceZdZUdZedZeeZde d<dfd Z dfd Z dfd Z dd Z dd Zddd Zdd Zd dZd!dZd"dZd#dZd$dZd%dZd&dZedd'dZxZS)( DictLikeModela Base Pydantic model class that mimics a dict interface for dynamic fields. Known, typed fields behave like regular Pydantic attributes. Any extra keyword arguments are stored in an internal dict and can be accessed through both attribute and mapping semantics. This hybrid model enables flexible event payloads while preserving validation for declared fields. PrivateAttr: _data (dict[str, Any]): Underlying Python dict for dynamic fields. T)arbitrary_types_allowed)default_factorydict[str, Any]_datac Zi}i}i}|jD]<\}}||jjvr|||<$||jvr|||<8|||<>t |di||jD]\}}t ||||r|jj|yy)zc __init__. NOTE: fields and private_attrs are pulled from params by name. N) items __class__ model_fields__private_attributes__super__init__ __setattr__rupdate) selfparamsfields private_attrsdatakv private_attrvaluers b/var/www/html/BankruptcyAI-uat/bankruptcy-ai/venv/lib/python3.12/site-packages/workflows/events.pyrzDictLikeModel.__init__#s LLN DAqDNN///q d111#$ a Q   "6"#0#6#6#8 5 L% G  e 4 5  JJ  d # c||jvs||jjvrt||S||j vr&t d|jjd|d|j |S)N'z' object has no attribute ')rrrr __getattr__rAttributeError__name__)r_DictLikeModel__namers r(r,zDictLikeModel.__getattr__:s| d11 14447&v. .TZZ'$//00KF8STU::f% %r)c||jvs||jjvrt|||y|j j ||yN)rrrrrr __setitem__)rnamer'rs r(rzDictLikeModel.__setattr__GsE 4.. .$$..:U:U2U G e , JJ " "4 /r)c |j|Sr1rrkeys r( __getitem__zDictLikeModel.__getitem__Mszz#r)c"||j|<yr1r5)rr7r's r(r2zDictLikeModel.__setitem__Ps 3r)c:|jj||Sr1)rget)rr7defaults r(r;zDictLikeModel.getSszz~~c7++r)c||jvSr1r5r6s r( __contains__zDictLikeModel.__contains__Vsdjj  r)c6|jjSr1)rkeysrs r(r@zDictLikeModel.keysYszz  r)c6|jjSr1)rvaluesrAs r(rCzDictLikeModel.values\szz  ""r)c6|jjSr1)rrrAs r(rzDictLikeModel.items_szz!!r)c,t|jSr1)lenrrAs r(__len__zDictLikeModel.__len__bs4::r)c,t|jSr1)iterrrAs r(__iter__zDictLikeModel.__iter__esDJJr)c|jSr1r5)rargskwargss r(to_dictzDictLikeModel.to_dicths zzr)cy)z.Make test `if event:` pass on Event instances.TrrAs r(__bool__zDictLikeModel.__bool__ksr)wrapmodecL||}|jr|j|d<|S)Nrr5rhandlerr#s r(custom_model_dumpzDictLikeModel.custom_model_dumpos$t} :: JJDM r)r r)r/strreturnr)r3rYr'rrZNone)r7rYrZr)r7rYr'rrZr[r1)r7rYr<rrZr)r7rYrZbool)rZz'dict_keys[str, Any]')rZz'dict_values[str, Any]')rZz'dict_items[str, Any]')rZintrZr)rLrrMrrZr)rZr\rVrrZr)r. __module__ __qualname____doc__r model_configr dictr__annotations__rr,rr8r2r;r>r@rCrrGrJrNrPrrW __classcell__rs@r(rrs d;L'=E>=$. &0  ,!!#" 6"#r)rc$eZdZdZdfd ZxZS)Eventa Base class for all workflow events. Events are light-weight, serializable payloads passed between steps. They support both attribute and mapping access to dynamic fields. Examples: Subclassing with typed fields: ```python from pydantic import Field class CustomEv(Event): score: int = Field(ge=0) e = CustomEv(score=10) print(e.score) ``` See Also: - [StartEvent][workflows.events.StartEvent] - [StopEvent][workflows.events.StopEvent] - [InputRequiredEvent][workflows.events.InputRequiredEvent] - [HumanResponseEvent][workflows.events.HumanResponseEvent] c $t|di|y)Nrrr)rr rs r(rzEvent.__init__s "6"r)rX)r.r`rarbrrfrgs@r(ririxs4##r)riceZdZdZy) StartEventz9Implicit entry event sent to kick off a `Workflow.run()`.Nr.r`rarbrr)r(rmrmsCr)rmceZdZUdZedZded<ddfd ZddZe ddZ e d dd Z dd Z dd ZxZS) StopEventaTerminal event that signals the workflow has completed. The `result` property contains the return value of the workflow run. When a custom stop event subclass is used, the workflow result is that event instance itself. Examples: ```python # default stop event: result holds the value return StopEvent(result={"answer": 42}) ``` Subclassing to provide a custom result: ```python class MyStopEv(StopEvent): pass @step async def my_step(self, ctx: Context, ev: StartEvent) -> MyStopEv: return MyStopEv(result={"answer": 42}) N)r<r_resultc (t|dd|i|y)Nrqrrk)rresultrMrs r(rzStopEvent.__init__s 2262r)c|jS)zBThis can be overridden by subclasses to return the desired result.rqrAs r( _get_resultzStopEvent._get_results ||r)c"|jSr1)rvrAs r(rszStopEvent.results!!r)rQrRcL||}|j|j|d<|S)NrsrurUs r(rWzStopEvent.custom_model_dumps't} << #!\\DN r)ci|j|j}|jDcgc] \}}|d|}}}dj|}|jj d|dScc}}w)N=z, ())r model_dumprjoinrr.)rrr$r%partsdict_strs r(__repr__zStopEvent.__repr__sy8 8doo&78 *:**:*:*<=$!QA3au==99U#..))*!H:Q77>sA4c,t|jSr1)rYrqrAs r(__str__zStopEvent.__str__s4<<  r)r1)rsrrMrrZr[r^r_)rZrY)r.r`rarbr rqrerrvpropertyrsrrWrrrfrgs@r(rprpsZ.t,GS,3""6"#8!r)rpceZdZdZy)InputRequiredEventaEmitted when human input is required to proceed. Automatically written to the event stream if returned from a step. If returned from a step, it does not need to be consumed by other steps and will pass validation. It's expected that the caller will respond to this event and send back a [HumanResponseEvent][workflows.events.HumanResponseEvent]. Use this directly or subclass it. Typical flow: a step returns `InputRequiredEvent`, callers consume it from the stream and send back a [HumanResponseEvent][workflows.events.HumanResponseEvent]. Examples: ```python from workflows.events import InputRequiredEvent, HumanResponseEvent class HITLWorkflow(Workflow): @step async def my_step(self, ev: StartEvent) -> InputRequiredEvent: return InputRequiredEvent(prefix="What's your name? ") @step async def my_step(self, ev: HumanResponseEvent) -> StopEvent: return StopEvent(result=ev.response) ``` Nrnrr)r(rrsr)rceZdZdZy)HumanResponseEventagCarries a human's response for a prior input request. If consumed by a step and not returned by another, it will still pass validation. Examples: ```python from workflows.events import InputRequiredEvent, HumanResponseEvent class HITLWorkflow(Workflow): @step async def my_step(self, ev: StartEvent) -> InputRequiredEvent: return InputRequiredEvent(prefix="What's your name? ") @step async def my_step(self, ev: HumanResponseEvent) -> StopEvent: return StopEvent(result=ev.response) ``` Nrnrr)r(rrsr)rceZdZdZy)InternalDispatchEventa InternalDispatchEvent is a special event type that exposes processes running inside workflow, even if the user did not explicitly expose them by setting, e.g., `ctx.write_event_to_stream(`. Examples: ```python wf = ExampleWorkflow() handler = wf.run(message="Hello, who are you?") async for ev in handler.stream_event(expose_internal=True): if isinstance(ev, InternalDispatchEvent): print(type(ev), ev) ``` Nrnrr)r(rrs   r)rceZdZdZdZdZy) StepState preparingrunning not_runningN)r.r`ra PREPARINGRUNNING NOT_RUNNINGrr)r(rrsIGKr)rceZdZUdZedZded<edZded<ed Zded <ed Z ded <ed dZ ded<y)StepStateChangeda StepStateChanged is a special event type that exposes internal changes in the state of the event, including whether the step is running or in progress, what worker it is running on and what events it takes as input and output, as well as changes in the workflow state. Attributes: name (str): Name of the step step_state (StepState): State of the step ("running", "not_running", "in_progress", "not_in_progress", "exited") worker_id (str): ID of the worker that the step is running on input_event_name (str): Name of the input event output_event_name (Optional[str]): Name of the output event context_state (dict[str, Any]): Snapshot of the current workflow state zName of the step) descriptionrYr3zXState of the step ('running', 'not_running', 'in_progress', 'not_in_progress', 'exited')r step_statez,ID of the worker that the step is running on worker_idzName of the input eventinput_event_namezName of the output eventN)rr<z str | Noneoutput_event_name) r.r`rarbr r3rerrrrrr)r(rr!sg "45D#5!nJ 'UVIsV!.GHcH$).%zr)rN) __future__r_collections_abcrrrenumrtypingrr pydanticr r r r rrrirmrprrrrr EventTyperr)r(rs#??bIbJ#M#>DD6!6!r:* E $  ,0 K r)