U nj%@sdZddlmZddlZddlZddlZddlmZm Z ddlm Z m Z ddl m Z mZmZmZddlmZdd lmZdd lmZmZdd lmZd d lmZmZd dlmZd dlmZd dl m!Z!d dl"m#Z#d dl$m%Z%d dl&m'Z'd dl(m)Z)d dl*m+Z+ej,rFddl-m.Z/ddl0m1Z1ddl2m3Z3Gddde/ej4Z5neZ6d/dddddd d!Z7d"dd#d$d%d&d'dd'd'd(d)d*Z8d%d+d,d-d.Z9dS)0z0Private logic for creating pydantic dataclasses.) annotationsN)partialwraps)AnyClassVar) ArgsKwargsSchemaSerializerSchemaValidator core_schema) TypeGuard)PydanticUndefinedAnnotation)PluggableSchemaValidatorcreate_schema_validator)PydanticDeprecatedSince20)_config _decorators)collect_dataclass_fields)GenerateSchema)get_standard_typevars_map)set_dataclass_mocks) NsResolver)CallbackGetCoreSchemaHandler)generate_pydantic_signature)LazyClassAttribute)DataclassInstance) ConfigDict) FieldInfoc@sJeZdZUdZded<ded<ded<ded <d ed <d ed <ded<dS)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]Z__pydantic_decorators__zClassVar[dict[str, FieldInfo]]__pydantic_fields__zClassVar[SchemaSerializer]__pydantic_serializer__z4ClassVar[SchemaValidator | PluggableSchemaValidator]__pydantic_validator__N)__name__ __module__ __qualname____doc____annotations__r+r+C/tmp/pip-unpacked-wheel-zvl9l234/pydantic/_internal/_dataclasses.pyr&s  rztype[StandardDataclass]zNsResolver | Nonez_config.ConfigWrapper | NoneNone)cls ns_resolverconfig_wrapperreturncCs"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`. )r/ typevars_mapr0N)rrr#)r.r/r0r2fieldsr+r+r,set_dataclass_fieldsAs r4TF) raise_errorsr/ _force_buildz type[Any]z_config.ConfigWrapperbool)r.r0r5r/r6r1c s|j}ddddddd}|jd|_||_|j|_t|||d|s^|jr^t||jd St|d rtt d t t |}t |||d }td tt||j|j|jdd|_t|dd} z6| r| |tt|jd d|dd} n|j|d d} WnJtk r8} z*|r t||jd| jdWYd Sd} ~ XYnX|j|jd} z|| } Wn(|jk r~t||jdYd SXtd|}| |_t | ||j!|jd| |j"|_#t$| | |_%|j&rt'|j(dddddfdd } | )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. rrr-)__dataclass_self__argskwargsr1c_s"d}|}|jjt|||ddS)NT)Z self_instance)r%Zvalidate_pythonr)r8r9r:Z__tracebackhide__sr+r+r,__init__vsz$complete_dataclass..__init__z .__init__)r0FZ__post_init_post_parse__zVSupport for `__post_init_post_parse__` has been dropped, the method will not be called)r/r2 __signature__T)initr3populate_by_nameextra is_dataclassZ__get_pydantic_core_schema__N)Zfrom_dunder_get_core_schemaunpack)Zref_mode`)titlezall referenced typesztype[PydanticDataclass]Z dataclassstr)instancefieldvaluer1cs|||dS)N)validate_assignment)rFrGrHZ validatorr+r,validated_setattrsz-complete_dataclass..validated_setattr)+r<r(Z config_dictr r4Z defer_buildrr&hasattrwarningswarnDeprecationWarningrrrrrr#r?r@r=getattrrZgenerate_schemar name core_configZ clean_schemaZCollectedInvalidtypingcastr"rr'Zplugin_settingsr%rr$rIr __setattr____get__r!)r.r0r5r/r6Z original_initr<r2Z gen_schemaZget_core_schemaZschemaerRrKr+rJr,complete_dataclassUs          rXz"TypeGuard[type[StandardDataclass]])_clsr1cCs2t|o0t|d o0t|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%r*) dataclassesrArLsetZ__dataclass_fields__ issupersetrP)rYr+r+r,is_builtin_dataclasss   r])NN):r) __future__rZ _annotationsrZrSrM functoolsrrrrZ pydantic_corerrr r Ztyping_extensionsr errorsr Zplugin._schema_validatorrrrrr_fieldsrZ_generate_schemarZ _genericsrZ _mock_val_serrZ_namespace_utilsrZ_schema_generation_sharedr _signaturer_utilsr TYPE_CHECKINGZ _typeshedrZStandardDataclassconfigrr3rProtocolrrOr4rXr]r+r+r+r,sD