o if3@sUdZddlmZddlZddlZddlZddlZddlm Z ddl m Z ddl m Z ddlmZmZmZmZmZddlmZmZmZmZdd lmZmZd d lmZd d lmZd d l m!Z!m"Z"d dlm#Z#ddl$m%Z%m&Z&ddl'm(Z(ddl)m*Z*m+Z+ddl,m-Z-ddl.m/Z/ddl0m1Z1ddl2m3Z3ddl4m5Z5erddl6m7Z8d dl9m:Z:Gddde8eZ; dd-d.Z=d?d0d1Z>d@d5d6Z?e@eAejBefZCd7eDd8<e dAd:d;ZEdS)Bz0Private logic for creating pydantic dataclasses.) annotationsN) Generator)contextmanager)partial) TYPE_CHECKINGAnyClassVarProtocolcast) ArgsKwargsSchemaSerializerSchemaValidator core_schema) TypeAliasTypeIs)PydanticUndefinedAnnotation) FieldInfo)PluggableSchemaValidatorcreate_schema_validator)PydanticDeprecatedSince20)_config _decorators)collect_dataclass_fields)GenerateSchemaInvalidSchemaError)get_standard_typevars_map)set_dataclass_mocks) NsResolver)generate_pydantic_signature)LazyClassAttribute)DataclassInstance) ConfigDictc@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]Z__pydantic_decorators__zClassVar[dict[str, FieldInfo]]__pydantic_fields__zClassVar[SchemaSerializer]__pydantic_serializer__z4ClassVar[SchemaValidator | PluggableSchemaValidator]__pydantic_validator__returnboolcCsdSNclsr.r.Y/home/kim/smarthome/.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__ classmethodr2r.r.r.r1r$(s  r$r0type[StandardDataclass]config_wrapper_config.ConfigWrapper ns_resolverNsResolver | Noner+NonecCs"t|}t||||d}||_dS)zCollect and set `cls.__pydantic_fields__`. Args: cls: The class. config_wrapper: The config wrapper instance. ns_resolver: Namespace resolver to use when getting dataclass annotations. )r< typevars_mapr:N)rrr()r0r:r<r?fieldsr.r.r1set_dataclass_fieldsAs   rATF) raise_errorsr< _force_build type[Any]rBr,rCc Csj|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!| | |_"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__r$argsrkwargsr+r>c_s"d}|}|jjt|||ddS)NT)Z self_instance)r*Zvalidate_pythonr )rErFrGZ__tracebackhide__sr.r.r1__init__vsz$complete_dataclass..__init__z .__init__)r:r<FZ__post_init_post_parse__zVSupport for `__post_init_post_parse__` has been dropped, the method will not be called)r<r? __signature__T)initr@validate_by_nameextra is_dataclass`N)titleztype[PydanticDataclass] dataclass)rEr$rFrrGrr+r>)$rIr5Z config_dictr%rAZ defer_buildrhasattrwarningswarnrrrr!rr r(rLrMrJZgenerate_schemarname core_configr3Z clean_schemarr r'rr4Zplugin_settingsr*r r)r&) r0r:rBr<rCZ original_initrIr?Z gen_schemaZschemaerVr.r.r1complete_dataclassUsn       rXTypeIs[type[StandardDataclass]]cCsd|jvo t|d S)afReturns `True` if the class is a stdlib dataclass and *not* a Pydantic dataclass. Unlike the stdlib `dataclasses.is_dataclass()` function, this does *not* include subclasses of a dataclass that are themselves not dataclasses. Args: cls: The class. Returns: `True` if the class is a stdlib dataclass, `False` otherwise. __dataclass_fields__r*)__dict__rRr/r.r.r1is_stdlib_dataclasss r\pydantic_fieldrdataclasses.Field[Any]cCsbd|i}tjdkr|jdur|j|d<tjdkr|jrd|d<|jdur)|j|d<tjdi|S) Ndefault)docr` Tkw_onlyreprr.)sys version_info descriptionrerf dataclassesfield)r]Z field_argsr.r.r1as_dataclass_fields   rlrDcFieldsGenerator[None]c csg}|jddD]G}|jdi}dd|D}|rQ|||f|D]'\}}tt|j}t|}t j dkrC|j rCd|_ |j durL|j |_ |||<q)q zdVW|D]\} } | D]\}} | | |<qaqYdS|D]\} } | D]\}} | | |<qwqow)aTemporarily patch the stdlib dataclasses bases of `cls` if the Pydantic `Field()` function is used. When creating a Pydantic dataclass, it is possible to inherit from stdlib dataclasses, where the Pydantic `Field()` function is used. To create this Pydantic dataclass, we first apply the stdlib `@dataclass` decorator on it. During the construction of the stdlib dataclass, the `kw_only` and `repr` field arguments need to be understood by the stdlib *during* the dataclass construction. To do so, we temporarily patch the fields dictionary of the affected bases. For instance, with the following example: ```python {test="skip" lint="skip"} import dataclasses as stdlib_dc import pydantic import pydantic.dataclasses as pydantic_dc @stdlib_dc.dataclass class A: a: int = pydantic.Field(repr=False) # Notice that the `repr` attribute of the dataclass field is `True`: A.__dataclass_fields__['a'] #> dataclass.Field(default=FieldInfo(repr=False), repr=True, ...) @pydantic_dc.dataclass class B(A): b: int = pydantic.Field(repr=False) ``` When passing `B` to the stdlib `@dataclass` decorator, it will look for fields in the parent classes and reuse them directly. When this context manager is active, `A` will be temporarily patched to be equivalent to: ```python {test="skip" lint="skip"} @stdlib_dc.dataclass class A: a: int = stdlib_dc.field(default=Field(repr=False), repr=False) ``` !!! note This is only applied to the bases of `cls`, and not `cls` itself. The reason is that the Pydantic dataclass decorator "owns" `cls` (in the previous example, `B`). As such, we instead modify the fields directly (in the previous example, we simply do `setattr(B, 'b', as_dataclass_field(pydantic_field))`). !!! note This approach is far from ideal, and can probably be the source of unwanted side effects/race conditions. The previous implemented approach was mutating the `__annotations__` dict of `cls`, which is no longer a safe operation in Python 3.14+, and resulted in unexpected behavior with field ordering anyway. rNrZcSsBi|]\}}t|jtr|jjdus|jjs|jjdur||qS)NT) isinstancer_rrirerf).0 field_namerkr.r.r1 s  z%patch_base_fields..rcT) __mro__r[getitemsappendr rr_copyrgrhrerf) r0Zoriginal_fields_listbaseZ dc_fieldsZ&dc_fields_with_pydantic_field_defaultsrqrkr_Z new_dc_fieldr@Zoriginal_fieldsZoriginal_fieldr.r.r1patch_base_fieldss:7       ryr-)r0r9r:r;r<r=r+r>) r0rDr:r;rBr,r<r=rCr,r+r,)r0rDr+rY)r]rr+r^)r0rDr+rn)Fr6 __future__rZ _annotationsrwrjrgrScollections.abcr contextlibr functoolsrtypingrrrr r Z pydantic_corer r r rZtyping_extensionsrrerrorsrr@rZplugin._schema_validatorrrrrr_fieldsrZ_generate_schemarrZ _genericsrZ _mock_val_serrZ_namespace_utilsr _signaturer Z_utilsr!Z _typeshedr"ZStandardDataclassconfigr#r$rArXr\rldictstrFieldrmr7ryr.r.r.r1sN                 l