jF"dZddlmZddlZddlZddlZddlmZm Z ddlm Z m Z m Z ddl mZmZmZmZddlmZdd lmZdd lmZmZdd lmZd d lmZmZmZd dlmZd dl m!Z!d dl"m#Z#d dl$m%Z%d dl&m'Z'd dl(m)Z)ejTr8ddl+m,Z,ddl-m.Z.Gddej^Z0Gdde0ej^Z1neZ2 d d dZ3dd d!dZ4d"dZ5y)#z0Private logic for creating pydantic dataclasses.) annotationsN)partialwraps)AnyCallableClassVar) ArgsKwargsSchemaSerializerSchemaValidator core_schema) TypeGuard)PydanticUndefinedAnnotation)PluggableSchemaValidatorcreate_schema_validator)PydanticDeprecatedSince20)_config _decorators _typing_extra)collect_dataclass_fields)GenerateSchema)get_standard_typevars_map)set_dataclass_mocks)CallbackGetCoreSchemaHandler)generate_pydantic_signature) ConfigDict) FieldInfoc4eZdZUded<ded<ded<d dZy) StandardDataclasszClassVar[dict[str, Any]]__dataclass_fields__z ClassVar[Any]__dataclass_params__zClassVar[Callable[..., None]] __post_init__cyN)selfargskwargss l/home/oem/CyberBrain26-unified/dev-env/.venv/lib/python3.12/site-packages/pydantic/_internal/_dataclasses.py__init__zStandardDataclass.__init__'s N)r(objectr)r-returnNone)__name__ __module__ __qualname____annotations__r+r&r,r*r r "s66++44 r,r cXeZdZUdZded<ded<ded<ded <d ed <d ed <ded<y)PydanticDataclassaiA protocol containing attributes only available once a class has been decorated as a Pydantic dataclass. Attributes: __pydantic_config__: Pydantic-specific configuration settings for the dataclass. __pydantic_complete__: Whether dataclass building is completed, or if there are still undefined fields. __pydantic_core_schema__: The pydantic-core schema used to build the SchemaValidator and SchemaSerializer. __pydantic_decorators__: Metadata containing the decorators defined on the dataclass. __pydantic_fields__: Metadata about the fields defined on the dataclass. __pydantic_serializer__: The pydantic-core SchemaSerializer used to dump instances of the dataclass. __pydantic_validator__: The pydantic-core SchemaValidator used to validate instances of the dataclass. zClassVar[ConfigDict]__pydantic_config__zClassVar[bool]__pydantic_complete__z ClassVar[core_schema.CoreSchema]__pydantic_core_schema__z$ClassVar[_decorators.DecoratorInfos]__pydantic_decorators__zClassVar[dict[str, FieldInfo]]__pydantic_fields__zClassVar[SchemaSerializer]__pydantic_serializer__z4ClassVar[SchemaValidator | PluggableSchemaValidator]__pydantic_validator__N)r0r1r2__doc__r3r&r,r*r5r5*s3 21--"BB!EE;;!;; TTr,r5cFt|}t||||}||_y)zCollect and set `cls.__pydantic_fields__`. Args: cls: The class. types_namespace: The types namespace, defaults to `None`. config_wrapper: The config wrapper instance, defaults to `None`. ) typevars_mapconfig_wrapperN)rrr:)clstypes_namespacer@r?fieldss r*set_dataclass_fieldsrDEs'-S1L %c?ft uF$Cr,T) raise_errorsc  t|drtjdt|t j |}t |||t|}t|||}t|j|j|d}dd}|jd|_ ||_ |j|_||_t!|d d} |r+||t#t%|j&d |d } n|j'|d } |j1|} |j3| } t7j8d|}| |_t=| ||j>|jd| |j@x|_! tE| | |_#|jHr5tK|jLd fd } | jOd||_&d|_(y#t($r2} |rt+||j,d| j.dYd} ~ y d} ~ wwxYw#|j4$rt+||j,dYy wxYw)aFinish building a pydantic dataclass. This logic is called on a class which has already been wrapped in `dataclasses.dataclass()`. This is somewhat analogous to `pydantic._internal._model_construction.complete_model_class`. Args: cls: The class. config_wrapper: The config wrapper instance. raise_errors: Whether to raise errors, defaults to `True`. types_namespace: The types namespace. Returns: `True` if building a pydantic dataclass is successfully completed, `False` otherwise. Raises: PydanticUndefinedAnnotation: If `raise_error` is `True` and there is an undefined annotations. __post_init_post_parse__zVSupport for `__post_init_post_parse__` has been dropped, the method will not be calledN)r@T)initrCr@ is_dataclasscZd}|}|jjt|||y)NT) self_instance)r<validate_pythonr )__dataclass_self__r(r)__tracebackhide__ss r*r+z$complete_dataclass..__init__s.     00D&1IYZ0[r,z .__init____get_pydantic_core_schema__F)from_dunder_get_core_schemaunpack)ref_mode`zall referenced typesztype[PydanticDataclass] dataclassc,j|||yr%)validate_assignment)instancefieldvalue validators r*validated_setattrz-complete_dataclass..validated_setattrs  ) )(E5 Ar,)rMr5r(rr)rr.r/)rXrrYstrrZr]r.r/))hasattrwarningswarnDeprecationWarningrmerge_cls_and_parent_nsrDrrrr+r:r2 config_dictr6 __signature__getattrrrgenerate_schemarrr0name core_config clean_schemaCollectedInvalidtypingcastr8rr1plugin_settingsr<r r;rWr __setattr____get__r7)rAr@rErBr? gen_schemasigr+get_core_schemaschemaerhr\r[s @r*complete_dataclassruWsM2s./ dfx '??DonM,S1LJ & \\&&%  C\ #//0 :HCL,88CCc#A4HO $,J66TYZ%F //QV/WF!,,S1K((0 ++/ 5C$*C -DS^^S%5%5{KQ_QoQo.C#36;"GC)) s  B  B,33D#> $C E '  C166(!}=   & &C/EFs+ AGH H&(HH&IIc tj|xrGt|d xr8t|jj tt |diS)a>Returns True if a class is a stdlib dataclass and *not* a pydantic dataclass. We check that - `_cls` is a dataclass - `_cls` does not inherit from a processed pydantic dataclass (and thus have a `__pydantic_validator__`) - `_cls` does not have any annotations that are not dataclass fields e.g. ```py import dataclasses import pydantic.dataclasses @dataclasses.dataclass class A: x: int @pydantic.dataclasses.dataclass class B(A): y: int ``` In this case, when we first check `B`, we make an extra check and look at the annotations ('y'), which won't be a superset of all the dataclass fields (only the stdlib fields i.e. 'x') Args: cls: The class. Returns: `True` if the class is a stdlib dataclass, `False` otherwise. r<r3) dataclassesrIr^setr! issupersetre)_clss r*is_builtin_dataclassr{sZ>   & a67 7 a )) * 5 5c'$HY[]:^6_ `r,)NN)rAztype[StandardDataclass]rBdict[str, Any] | Noner@z_config.ConfigWrapper | Noner.r/) rA type[Any]r@z_config.ConfigWrapperrEboolrBr|r.r~)rzr}r.z"TypeGuard[type[StandardDataclass]])6r= __future__r _annotationsrwrkr_ functoolsrrrrr pydantic_corer r r r typing_extensionsr errorsrplugin._schema_validatorrrrrrr_fieldsr_generate_schemar _genericsr _mock_val_serr_schema_generation_sharedr _signaturer TYPE_CHECKINGconfigrrCrProtocolr r5rarDrur{r&r,r*rs62 $** (0X011-,0.C3 #"FOOU-vU03 .237% %*%1% %, l l)l l + l  l^"r,