"j@%SrSSKJr SSKrSSKrSSKrSSKrSSKJrJ r SSK J r J r J r Jr SSKrSSKrSSKJr SSKJr SS KJr S r\"\15rSq\ "S 5r\ "S 5r"S S\\\4\ \5rS SjrS!Sjr S"Sjr!Sq"S\#S'S#Sjr$S$Sjr%S%Sjr&S&Sjr'S'Sjr(S(Sjr)S)Sjr*S*Sjr+S+Sjr,S,Sjr-S-Sjr.S.Sjr/g)/aRegistry-backed serialization for extensible event families. Event classes like [`CustomEvent`][pydantic_ai.messages.CustomEvent] are open families: applications and third-party packages define typed subclasses that must round-trip through the closed `AgentStreamEvent` discriminated union. Like the native tools union (see `AbstractNativeTool.__get_pydantic_core_schema__`), the family's inner tagged union is rebuilt from a registry at schema-generation time, so registered subclasses validate to their own class. Unlike native tools, an unregistered tag doesn't fail validation: it degrades to an "unknown" envelope carrying the raw payload in `data`, which re-flattens on serialization so a downstream consumer that does have the defining module imported recovers the typed event. ) annotationsN)CallableMapping)AnyGenericTypeVaroverload)_utils) is_str_dict) UserError __unknown__ _EventClassT _DefaultTcx^\rSrSrSrS U4SjjrS U4Sjjr\S Sj5r\S Sj5rS U4SjjrSr U=r $) EventRegistry(aOne event family's tag-to-class registry, versioned so schema caches can detect staleness. `event_family_schema` snapshots the registry it builds from, so a schema built before a class registered keeps degrading that class's events to the unknown envelope. That's correct for a schema built once and thrown away, but a consumer that memoizes adapters for the life of a process (e.g. Temporal's payload converter) would keep serving the stale one, making decoding depend on import order. Such consumers key their memo on `event_registry_version()`, which the mutations below bump, so a later registration rebuilds the adapter instead. A registry is only ever mutated by item assignment (registration, from `__init_subclass__`), `del`, and `pop` (test cleanup), which is why those are the ones overridden. `dict`'s bulk mutators would change the registry without bumping the version, leaving a memoizing consumer on a stale adapter; register through class definition rather than reaching for them. c8>[TU]X5 [5 gN)super __setitem___bump_registry_version)selftag event_cls __class__s X/home/mande/repo/quber/.venv/lib/python3.13/site-packages/pydantic_ai/_event_registry.pyrEventRegistry.__setitem__8s C+ c8>[TU]U5 [5 gr)r __delitem__r)rrrs rr!EventRegistry.__delitem__<s C  rcgr)rrs rpopEventRegistry.pop@s03rcgrr$)rrdefaults rr%r&Cs_brc>>[TU]"U/UQ76n[5 U$r)rr%r)rrr(poppedrs rr%r&Fs!S+7+  rr$)rstrrrreturnNone)rr+r,r-)rr+r,r)rr+r(_EventClassT | _DefaultTr,r.)rr+r(rr,r) __name__ __module__ __qualname____firstlineno____doc__rr!r r%__static_attributes__ __classcell__)rs@rrr(s: !!33 bbrrc[S- qg)Nr _registry_versionr$rrrrLs rc[$)zA counter bumped whenever any [`EventRegistry`][] changes. Cache keys that include this are invalidated by a registration, so an adapter built before an event class was imported isn't reused after it is. r7r$rrevent_registry_versionr:Qs rctURUR:H=(a URUR:H$)a Whether `cls` is the same class as `existing` being defined again. A re-run notebook cell, `importlib.reload`, a re-executed docs example, or the class recreation `@dataclass(slots=True)` performs replaces its registration; only genuinely distinct classes conflict. )r0r1)existingclss ris_redefinitionr>Zs/   #.. 0 ^X5J5JcN^N^5^^rzCallable[[], bool] | None_replay_isolation_guardcUqg)uDeclare when class definitions are happening in an isolated re-execution of the app's modules. A durable execution runtime may re-execute application modules in an isolated interpreter view while sharing `pydantic_ai` itself with the host process — Temporal's workflow sandbox does exactly this. The re-executed copy of an event class is a redefinition of the host's, so left alone it would take over the registry, and the host would then decode payloads into a class its own `isinstance` checks (including `@on_event(MyEvent)` filtering) don't recognize. While `guard()` is true, redefinitions keep the class already registered as the family's canonical one. Instances of the re-executed copy still serialize and validate normally: the family schema canonicalizes them (see `event_family_schema`), so application code holds one event class regardless of which side of the boundary it runs on. Nr?)guards rset_replay_isolation_guardrCgs $rc4[SL=(a [5$)zQWhether a redefinition right now should leave the existing registration in place.NrAr$rrkeeps_canonical_registrationrEys "$ . L3J3LLrc [U5nX!Ld[X5(dU$[R"U5nU"S0UVs0sH5oDR(dMUR [ XR 5_M7 snD6nUH?nUR(aM[XTR [ XR 55 MA U$s snf)uRebuild a re-executed copy of `event_cls` as `event_cls` itself, so serialization stays exact. Only a class the registry considers the same one (see `is_redefinition`) is converted. Such a copy comes from re-executing the same module source, so it carries the same fields by construction, and reading them off it by name is exact. This is the exception to the "no `fields()` + `getattr` copying" rule in `agent_docs/index.md`: that rule protects *our own* statically-known types, where Pyright can check field existence and a rename would silently break the copy. `event_cls` is an application-defined subclass resolved at runtime, so there is no static field set to check against, and a rename lands on both copies at once — they are the same source, executed twice. r$)typer> dataclassesfieldsinitnamegetattrsetattr)valuer value_typerIf canonicals r _canonicalizerR~seJoi&L&L    *FWVVVvv;QVVWUFF%;;VVWI vvv Ivvwuff'= >  Ws C $C c^^URRS5mTb[TSS5(ag[R"T5SUU4Sjj5nSUlX lg)aKeep the base event guards running when a subclass defines its own `__post_init__`. A dataclass-generated `__init__` calls only the most-derived `__post_init__`, so a subclass that defines one without calling `super().__post_init__()` would silently skip the family's construction guards (base instantiation, per-instance tag overrides). Wrapping at class definition makes the guards unbypassable; a cooperative `super()` call just re-runs them, which is harmless. __post_init__N_event_guardedFc>>T"U5 T"U/UQ70UD6 T"U5 grr$)rargskwargsbase_post_inituser_post_inits rguarded guard_post_init..guardeds'tt-d-f- trT)rrrWrrXrr,r-)__dict__getrL functoolswrapsrUrT)r=rYr[rZs ` @rguard_post_initras\\\%%o6N9I5!Q!Q__^$%"Grc[[R"U55U-nU(aSR[ U55$S$)zPThe class's own field names that shadow the family's envelope fields, or `None`.z, N)setr own_annotationsjoinsorted)r=reservedshadoweds rshadowed_envelope_fieldsris76))#./(:H*2499VH% &< E! !   rcURSSHJnX!Ld[X!5(d gSUR;aM+[R"U5(dMHUs $ g)aA class between `cls` and `family` that declares payload fields but isn't a dataclass. `@dataclass` only collects fields from bases that are dataclasses themselves, so an intermediate base holding shared fields silently contributes nothing unless it is decorated too: the fields vanish from the payload, the wire, and every consumer, with no error anywhere. Each base is fully built by the time a subclass is being registered, so its decoration can be checked reliably here. r N__dataclass_fields__)rnror]r declares_dataclass_fields)r=rqrrs rundecorated_field_baserys[ AB >D!9!9   "T]] 2   + +D 1 1K  rc \^^^^[RS:a_SSKmTRTR5mTbS UUUU4SjjnUTlO?T[ 0TRRS05ETlOTS0TRETl[TT[R"USS95 g) aRedeclare `tag_field` on the subclass so it defaults to (and serializes as) the registered tag. The annotation is redeclared on the subclass so `@dataclass` (which runs after `__init_subclass__`) picks up the new default. On Python 3.14+ the merge wraps the class's lazy `__annotate__` function instead of materializing `__annotations__`, preserving PEP 649 deferred evaluation for payload fields that reference names defined later in the module. )rNcT>T[0TRTTRU5TS9E$)N)owner)r+call_annotate_functionFormat)format annotationlibr=original_annotate tag_fields rannotate"inject_tag_field..annotates:s#::;LmNbNbciNjru:vr__annotations__r+T)r(kw_only)rintr,zdict[str, Any]) sys version_infor!get_annotate_from_class_namespacer] __annotate__r+r^rrMrHfield)r=r tag_valuerrrs`` @@rinject_tag_fieldrs 7")KKCLLY  (   (C $-c"]S\\5E5EFWY[5\"]C (%G33F3FG CK--iNOrc^^^ [U5m SU UU4Sjjn[RR[ TTU5UR T5[RR [5S9n0nUR5HJup[R"U 5(d[SU RSU<S35e[X 5Xx'ML Xg['[RRXu5$)z]Build the tagged union over an event registry, degrading unregistered tags to `unknown_type`.c>[U5(a4URT5n[U[5(aUT;aU$[$[ UTS5n[U[5(aUT;aU$[UT5(a[$S$r)r r^ isinstancer+ _UNKNOWN_TAGrL)rNr known_tagsr unknown_types r discriminator*event_family_schema..discriminatorsy u  ))I&C#s##z(9  eY- c3  C:$5J)%>>|HDHr serializationz Event class z (registered as z) must be a dataclass.)rNrr, str | None) frozenset pydantic_core core_schema!no_info_before_validator_function_gather_unknown_payloadgenerate_schema#wrap_serializer_function_ser_schema_flatten_unknownitemsrH is_dataclassr r1_canonicalizing_schemartagged_union_schema) handlerregistryrrenvelope_fieldsrunknown_schemachoicesrrrs `` @revent_family_schemars8$J I I#..PP <I -#//SSTdeQN @BG"..*'' 22y5566FsgMcd .gA + +L  $ $ 8 8 PPrc^SU4Sjjn[RRSURT5[RR U5S9$)uThe event class's own schema, serializing a re-executed copy of it as the registered class. Under a `set_replay_isolation_guard`, code on the isolated side holds its own copy of the class while the registry keeps the host's. The copy is the same class by every meaning that matters here — same module, same qualname, same fields — so serializing it as the registered one is exact, and it's what lets both sides use the class they imported. c(>U"[UT55$r)rR)rN serializerrs r serialize)_canonicalizing_schema..serialize+s-y9::rcU$rr$)rNs r(_canonicalizing_schema../serrrNrrz7pydantic_core.core_schema.SerializerFunctionWrapHandlerr,r)rrrrr)rrrs ` rrr"sO;  $ $ F F *#//SST]^ G rc,^^^US1- mSUUU4SjjnU$)uBefore-validator for the unknown-event envelope: move unrecognized payload fields into `data`. The envelope's own `data` slot is synthetic — only this validator ever fills it — so a `data` key on the wire is one of the unknown event's payload fields, not the envelope's, and is gathered like any other. Treating it as the envelope's would let `_flatten_unknown` promote its entries to top-level fields, changing the wire shape of an event whose only payload field is named `data`. datac >[U5(aUR5VVs0sHupUT;dM X_M nnnUR5VVs0sHupUT;dM X_M nnnU(aXCS'[R"STSUR T5<STR S3[ SS9 U$U$s snnfs snnf)NrzUnknown event  z; validating as z. Is the module that defines this event imported? (A serializer built before the event class was defined also treats it as unknown.)) stacklevel)r rwarningswarnr^r/ UserWarning)rNkvenvelopepayloadcarried_fieldsrrs rgather'_gather_unknown_payload..gatherAs u  ).N!~:MHN(- Q .9Ptqt GQ#* MM  1UYYy-A,DDTUaUjUjTkl@A  O OQs B7B7 B=!B=)rNrr,rr$)rrrrrs`` @rrr5s"%x/N MrcU"U5n[U5(dU$[URSS5=n5(a0UEUE$X2S'U$)zaSerializer for the unknown-event envelope: re-flatten `data` so the typed event can be recovered.rN)r r%)rNrdumpedrs rrrTsSU#F v   6::fd33444!$!&!!6N Mr)r,r-)r,r)r<rGr=rGr,bool)rBzCallable[[], bool]r,r-)r,r)rNobjectrrGr,r)r=rGrYzCallable[[Any], None]r,r-)r=rGrgfrozenset[str]r,r)r=rGrqrGr,r)r=rGrqrGr,z type | None)r=rGrr+rr+r,r-) rpydantic.GetCoreSchemaHandlerrzMapping[str, type[Any]]rr+r type[Any]rrr,z$pydantic_core.core_schema.CoreSchema)rrrrr,r)rr+rrrrr,zCallable[[Any], Any]r)0r3 __future__rrHr_rrcollections.abcrrtypingrrrr pydanticrr r exceptionsr rrRESERVED_EVENT_TAGSr8rrdictr+rrr:r>r?rrCrErRrariruryrrrrrr$rrrs> # -22! /d~& K !Dl*+W\-B!H _6:29$$M 6 2= "&P<%Q *%Q&%Q %Q  %Q $ %Q*%QP&"+>L> r