g> xdZddlmZddlZddlZddlZddlmZm Z m Z m Z m Z m Z mZddlmZddlmZmZmZddlmZmZmZmZdd lmZdd lmZdd lmZdd l m!Z!dd l"m#Z#m$Z$m%Z%er ddl&m'Z'ddl(m)Z)dZ*e dZ+ej,dkreeej-e#e%feddddddddddd dHd(Z.eej-e#e%feddddddddddd dId,Z.n`eej-e#e%feddddddddd-dJd.Z.eej-e#e%feddddddddd-dKd/Z.eej-e#e%f dLddddddddddd dMd2Z.ee/Z0d3ej,cxkrd4krnndNd9Z1e1ej2_3ddd:dd;dOdCZ4dPdGZ5dS)Qz7Provide an enhanced dataclass that performs validation.) annotationsN) TYPE_CHECKINGAnyCallableGenericNoReturnTypeVaroverload)warn)Literal TypeGuarddataclass_transform)_config _decorators_namespace_utils _typing_extra) _dataclasses)getattr_migration) ConfigDict)PydanticUserError)Field FieldInfo PrivateAttr)PydanticDataclass)MappingNamespace) dataclassrebuild_dataclass_T )field_specifiersFT. initrepreqorder unsafe_hashfrozenconfigvalidate_on_initkw_onlyslotsr%Literal[False]r&boolr'r(r)r*r+ ConfigDict | type[object] | Noner, bool | Noner-r.return-Callable[[type[_T]], type[PydanticDataclass]]c dSNr$s R/var/www/html/mpstechhub/venv/lib/python3.11/site-packages/pydantic/dataclasses.pyrrs  _clstype[_T]type[PydanticDataclass]c dSr6r7) r:r%r&r'r(r)r*r+r,r-r.s r8rr/s #&#r9r%r&r'r(r)r*r+r,cdSr6r7r>s r8rrBs  r9cdSr6r7) r:r%r&r'r(r)r*r+r,s r8rrQs #&#r9type[_T] | NoneGCallable[[type[_T]], type[PydanticDataclass]] | type[PydanticDataclass]c  |dus Jd|dus Jdtjdkr| | d ni dd  d fd } || n | |S)aUsage docs: https://docs.pydantic.dev/2.10/concepts/dataclasses/ A decorator used to create a Pydantic-enhanced dataclass, similar to the standard Python `dataclass`, but with added validation. This function should be used similarly to `dataclasses.dataclass`. Args: _cls: The target `dataclass`. init: Included for signature compatibility with `dataclasses.dataclass`, and is passed through to `dataclasses.dataclass` when appropriate. If specified, must be set to `False`, as pydantic inserts its own `__init__` function. repr: A boolean indicating whether to include the field in the `__repr__` output. eq: Determines if a `__eq__` method should be generated for the class. order: Determines if comparison magic methods should be generated, such as `__lt__`, but not `__eq__`. unsafe_hash: Determines if a `__hash__` method should be included in the class, as in `dataclasses.dataclass`. frozen: Determines if the generated class should be a 'frozen' `dataclass`, which does not allow its attributes to be modified after it has been initialized. If not set, the value from the provided `config` argument will be used (and will default to `False` otherwise). config: The Pydantic config to use for the `dataclass`. validate_on_init: A deprecated parameter included for backwards compatibility; in V2, all Pydantic dataclasses are validated on init. kw_only: Determines if `__init__` method parameters must be specified by keyword only. Defaults to `False`. slots: Determines if the generated class should be a 'slots' `dataclass`, which does not allow the addition of new attributes after instantiation. Returns: A decorator that accepts a class as its argument and returns a Pydantic `dataclass`. Raises: AssertionError: Raised if `init` is not `False` or `validate_on_init` is `False`. Fz7pydantic.dataclasses.dataclass only supports init=Falsez-validate_on_init=False is no longer supportedr )r-r.cls type[Any]r3Nonec |jD]}t|dg}|D]}t||d}t|ts)d|i}tjdkr |jrd|d<|jdur |j|d<t||tj di||j di|_ |||j |<dS) aMake sure that stdlib `dataclasses` understands `Field` kwargs like `kw_only` To do that, we simply change `x: int = pydantic.Field(..., kw_only=True)` into `x: int = dataclasses.field(default=pydantic.Field(..., kw_only=True), kw_only=True)` __annotations__Ndefaultr Tr-r&r7)__mro__getattr isinstancersys version_infor-r&setattr dataclassesfield__dict__getrH)rDannotation_clsr field_name field_value field_argss r8make_pydantic_fields_compatiblez2dataclass..make_pydantic_fields_compatibles"k J JN".2CRHHK) J J %c:t<< !+y99%.{#; #w..;3F.,0Jy)#4//)4)9Jv&Z):)H)HZ)H)HIII<##$566>*,C'2=j2I#J//- J  J Jr9r<c ddlm}||rtd|jdd|}t d|jD}|s2 0t |d r td |jd td   nt|d d}tj |}tj |}|j}t!j|rLd}|f}t%|t&rt&|j} || fz}t+j|j|}| * } |jr td|jdtd n |jpd} t1j|fd | d}||_||_|j|_|j|_d|_t!j||d|S)zCreate a Pydantic dataclass from a regular dataclass. Args: cls: The class to create the Pydantic dataclass from. Returns: A Pydantic dataclass. r)is_model_classz(Cannot create a Pydantic dataclass from z" as it is already a Pydantic modelzdataclass-on-model)codec3>K|]}tj|VdSr6)rP is_dataclass).0bases r8 z6dataclass..create_dataclass..s- Z ZD!9$!?!? Z Z Z Z Z Zr9N__pydantic_config__z[`config` is set via both the `dataclass` decorator and `__pydantic_config__` for dataclass zK. The `config` specification from `dataclass` decorator will take priority.)category stacklevelzN`frozen` is set via both the `dataclass` decorator and `config` for dataclass zW.This is not recommended. The `frozen` specification on `dataclass` will take priority.FT)r%r&r'r(r)r*) raise_errors)_internal._utilsrZr__name__any __bases__hasattrr UserWarningrKr ConfigWrapperrDecoratorInfosbuild__doc___pydantic_dataclassesis_builtin_dataclass issubclassr__parameters__types new_classr*rPr__pydantic_decorators__ __module__ __qualname____pydantic_complete__complete_dataclass)rDrZ original_clshas_dataclass_base config_dictconfig_wrapper decorators original_docbases generic_basefrozen_r+r'r*kwargsrXr(r&r)s r8create_dataclassz#dataclass..create_dataclasss 544444 >#   #k3<kkk)   ! Z ZCM Z Z ZZZ! f&8WSJ_=`=`&8 ]nqnz]]]$     !' 2ffEZ\`8a8a  .{;; /55c:: { 5c : : 7 L FE#w'' 0&s'9: //#,66C'',,,  G$ meheqmmm( %+4uG#   #      '1#" %0'4$)! 0nSXYYYY r9N)rDrEr3rF)rDrEr3r<)rMrN)r:r%r&r'r(r)r*r+r,r-r.rrrXs `````` @@r8rras\ 5===S=== 5 ( ( (*Y ( ( ( 7""$u55!J!J!J!JF[[[[[[[[[[[[[z $|  1A1A$1G1GGr9)r!)r! argsrrrc td)a9This function does nothing but raise an error that is as similar as possible to what you'd get if you were to try calling `InitVar[int]()` without this monkeypatch. The whole purpose is just to ensure typing._type_check does not error if the type hint evaluates to `InitVar[]`. z 'InitVar' object is not callable) TypeError)rrs r8 _call_initvarr s :;;;r9rb)forcere_parent_namespace_depth_types_namespacerDrrerintrMappingNamespace | Nonec$|s |jrdSd|jvrt|d||}n!|dkrtj|dpi}ni}t j|}tj|tj |j d||d S) axTry to rebuild the pydantic-core schema for the dataclass. This may be necessary when one of the annotations is a ForwardRef which could not be resolved during the initial attempt to build the schema, and automatic rebuilding fails. This is analogous to `BaseModel.model_rebuild`. Args: cls: The class to rebuild the pydantic-core schema for. force: Whether to force the rebuilding of the schema, defaults to `False`. raise_errors: Whether to raise errors, defaults to `True`. _parent_namespace_depth: The depth level of the parent namespace, defaults to 2. _types_namespace: The types namespace, defaults to `None`. Returns: Returns `None` if the schema is already "complete" and rebuilding was not required. If rebuilding _was_ required, returns `True` if rebuilding was successful, otherwise `False`. N__pydantic_core_schema__rT) parent_depthr)parent_namespaceF)check)re ns_resolver _force_build) ryrRdelattrrparent_frame_namespacer NsResolverrprzrrlra)rDrrerr rebuild_nsrs r8rr*s4 S.t!S\11/000#% 1 $ $"9G^fjkkkqoq  "-#K ! 3 c5UCCC!     r9class_rE"TypeGuard[type[PydanticDataclass]]c` d|jvotj|S#t$rYdSwxYw)zWhether a class is a pydantic dataclass. Args: class_: The class. Returns: `True` if the class is a pydantic dataclass, `False` otherwise. __pydantic_validator__F)rRrPr]AttributeError)rs r8is_pydantic_dataclassrbsG'6?:_{?WX^?_?__ uus  --)r%r/r&r0r'r0r(r0r)r0r*r0r+r1r,r2r-r0r.r0r3r4)r:r;r%r/r&r0r'r0r(r0r)r0r*r2r+r1r,r2r-r0r.r0r3r<)r%r/r&r0r'r0r(r0r)r0r*r2r+r1r,r2r3r4)r:r;r%r/r&r0r'r0r(r0r)r0r*r2r+r1r,r2r3r<r6)r:rAr%r/r&r0r'r0r(r0r)r0r*r2r+r1r,r2r-r0r.r0r3rB)rrrrr3r) rDr<rr0rer0rrrrr3r2)rrEr3r)6ro __future__r _annotationsrPrMrttypingrrrrrr r warningsr typing_extensionsr r r _internalrrrrrrp _migrationrr+rerrorsrfieldsrrr_internal._dataclassesr_internal._namespace_utilsr__all__rrNrQrrg __getattr__rInitVar__call__rrr7r9r8rsD==222222 UUUUUUUUUUUUUUUUUUEEEEEEEEEELLLLLLLLLLLL<<<<<<))))))%%%%%%1111111111=999999<<<<<< * WT]]w;+