o "ch#@srdZddlmZddlZddlZddlZddlmZm Z ddlm Z m Z ddl m Z mZmZmZddlmZdd lmZdd lmZmZdd lmZd d lmZmZd dlmZd dlmZm Z d dl!m"Z"d dl#m$Z$d dl%m&Z&d dl'm(Z(d dl)m*Z*ej+rddl,m-Z.ddl/m0Z0ddl1m2Z2Gddde.ej3Z4neZ5  d2d3d"d#Z6d$dd%d&d4d,d-Z7d5d0d1Z8dS)6z0Private logic for creating pydantic dataclasses.) annotationsN)partialwraps)AnyClassVar) ArgsKwargsSchemaSerializerSchemaValidator core_schema) TypeGuard)PydanticUndefinedAnnotation)PluggableSchemaValidatorcreate_schema_validator)PydanticDeprecatedSince20)_config _decorators)collect_dataclass_fields)GenerateSchemaInvalidSchemaError)get_standard_typevars_map)set_dataclass_mocks) NsResolver)generate_pydantic_signature)LazyClassAttribute)DataclassInstance) ConfigDict) FieldInfoc@sXeZdZUdZded<ded<ded<ded <d ed <d ed <ded<edddZdS)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__returnboolcCsdSN)clsr*r*]/home/air/goalskill/back/venv/lib/python3.10/site-packages/pydantic/_internal/_dataclasses.py__pydantic_fields_complete__:sz.PydanticDataclass.__pydantic_fields_complete__N)r'r()__name__ __module__ __qualname____doc____annotations__ classmethodr-r*r*r*r,r%s  rr+type[StandardDataclass] ns_resolverNsResolver | Noneconfig_wrapper_config.ConfigWrapper | Noner'NonecCs"t|}t||||d}||_dS)zCollect and set `cls.__pydantic_fields__`. Args: cls: The class. ns_resolver: Namespace resolver to use when getting dataclass annotations. config_wrapper: The config wrapper instance, defaults to `None`. )r5 typevars_mapr7N)rrr$)r+r5r7r:fieldsr*r*r,set_dataclass_fieldsCs   r<TF) raise_errorsr5 _force_build type[Any]_config.ConfigWrapperr=r(r>c s|j}ddd }|jd |_||_|j|_t|||d |s(|jr(t|d St|d r3t dt t |}t |||d}t dtt||j|j|jdd|_z||} Wn tyv} z|rat|d| jdWYd} ~ d Sd} ~ ww|j|jd} z|| } Wntyt|Yd Swtd|}| |_t| ||j|jd| |j |_!t"| | |_#|j$rt%|j&dfdd } | 'd||_&d|_(dS) 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`. ns_resolver: The namespace resolver instance to use when collecting dataclass fields and during schema building. _force_build: Whether to force building the dataclass, no matter if [`defer_build`][pydantic.config.ConfigDict.defer_build] is set. 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. __dataclass_self__rargsrkwargsr'r9c_s"d}|}|jjt|||ddS)NT) self_instance)r&validate_pythonr)rArBrC__tracebackhide__sr*r*r,__init__xsz$complete_dataclass..__init__z .__init__)r7F__post_init_post_parse__zVSupport for `__post_init_post_parse__` has been dropped, the method will not be called)r5r: __signature__T)initr;validate_by_nameextra is_dataclass`N)titleztype[PydanticDataclass] dataclassinstancefieldstrvaluecs|||dSr))validate_assignment)rRrSrU validatorr*r,validated_setattrsz-complete_dataclass..validated_setattr)rArrBrrCrr'r9)rRrrSrTrUrTr'r9))rHr0 config_dictr r< defer_buildrhasattrwarningswarnDeprecationWarningrrrrrr$rLrMrJgenerate_schemar name core_configr. clean_schemartypingcastr"rr/plugin_settingsr&rr%rVr __setattr____get__r!) r+r7r=r5r> original_initrHr: gen_schemaschemaerbrYr*rWr,complete_dataclassWst       rm_cls"TypeGuard[type[StandardDataclass]]cCs2t|ot|d ot|jtt|diS)aBReturns 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. ```python 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&r2) dataclassesrNr\set__dataclass_fields__ issupersetgetattr)rnr*r*r,is_builtin_dataclasss  ru)NN)r+r4r5r6r7r8r'r9) r+r?r7r@r=r(r5r6r>r(r'r()rnr?r'ro)9r1 __future__r _annotationsrprdr] functoolsrrrr pydantic_corerrr r typing_extensionsr errorsr plugin._schema_validatorrrrrr_fieldsr_generate_schemarr _genericsr _mock_val_serr_namespace_utilsr _signaturer_utilsr TYPE_CHECKING _typeshedrStandardDataclassconfigrr;rProtocolrr_r<rmrur*r*r*r,sD              u