!h@dZddlmZddlZddlZddlZddlZddlZddl Z ddl m Z ddl m Z mZmZddlmZddlmZmZmZmZmZmZddlmZmZdd lmZmZmZmZm Z dd l!m"Z"d d l#m$Z$m%Z%d d l&m'Z'd dlm(Z(m)Z)ddl*m+Z+ddl,m-Z-m.Z.m/Z/m0Z0ddl1m2Z2m3Z3m4Z4ddl5m6Z6m7Z7ddl8m9Z9m:Z:ddl;mm?Z?ddl@mAZAddlBmCZCddlDmEZEmFZFmGZGmHZHddlImJZJmKZKejLrd dlMmNZOd dlMmPZPmQZQd dlMmRZSd dlTmUZUne)ZVeWZOeWZSeWjXZYGdd eZZ[d!d"dVd'Z\ed(eOeSe\f)Gd*d+e Z]dWd0Z^dXd6Z_dYd<Z`dZd?Zad[d@Zbd\dEZcd(dddFd]dKZdd^dLZeGdMdNZfGdOdPZgd_dSZhd_dTZie d`dUZjdS)az"Private logic for creating models.) annotationsN)ABCMeta)cachepartialwraps) FunctionType)AnyCallableGenericLiteralNoReturncast)PydanticUndefinedSchemaSerializer) TypeAliasTypedataclass_transform deprecatedget_args get_origin)typing_objects)PydanticUndefinedAnnotationPydanticUserError)create_schema_validator)GenericBeforeBaseModelWarningPydanticDeprecatedSince20) ConfigWrapper)DecoratorInfosPydanticDescriptorProxyget_attribute_from_basesunwrap_wrapped_function)collect_model_fieldsis_valid_field_nameis_valid_privateattr_name)GenerateSchemaInvalidSchemaError)PydanticGenericMetadataget_model_typevars_map)import_cached_base_modelimport_cached_field_info)set_model_mocks) NsResolver)generate_pydantic_signature)_make_forward_refeval_type_backportis_classvar_annotationparent_frame_namespace)LazyClassAttributeSafeGetItemProxy)Field) FieldInfoModelPrivateAttr) PrivateAttr) BaseModelc$eZdZdZd fd ZxZS) _ModelNamespaceDictz{A dictionary subclass that intercepts attribute setting on model classes and warns about overriding of decorators. kstrvobjectreturnNonec||d}|r>||ur:t|tr%tjd|d|jjdt||S)N`z"` overrides an existing Pydantic `z ` decorator) get isinstancer warningswarndecorator_infodecorator_reprsuper __setitem__)selfr<r>existing __class__s `c:\xampp_lite_8_4\www\timesheet\venv\Lib\site-packages\pydantic/_internal/_model_construction.pyrKz_ModelNamespaceDict.__setitem__<s}D))  x))jCZ.[.[) Mvavv8CZCivvv w w www""1a((()r<r=r>r?r@rA)__name__ __module__ __qualname____doc__rK __classcell__rNs@rOr;r;7sG))))))))))rPr;FinitrXLiteral[False]r@r cdS)zOnly for typing purposes. Used as default value of `__pydantic_fields_set__`, `__pydantic_extra__`, `__pydantic_private__`, so they could be ignored when synthesizing the `__init__` signature. NrWs rO NoInitFieldr\DsrPT)kw_only_defaultfield_specifiersceZdZ d'd(fd Zejsd)dZed*dZd+fd Z d,fd Z e d-dZ e ed d!d.d#Ze d/d$Zd0fd& ZxZS)1ModelMetaclassNTcls_namer=basestuple[type[Any], ...] namespacedict[str, Any]__pydantic_generic_metadata__PydanticGenericMetadata | None#__pydantic_reset_parent_namespace__bool_create_model_module str | Nonekwargsr r@typec  |r||\}} } tj|||} | j|d<t || j| |} | s| r=t ||!td2fd } | |d <n t|d <| |d <i| | |d <td tj ||||fi|}t}|j }t|vrT|t||kr#t!jt%ddt'|jdd |_|j|jurdnd |_i|_t3j||_|r ||_n?t'|diddt'|ddprrt=fdDsddlm }tCfdD}|vr<|vr8d"d|D}|j#d|d|j#d|d}nm|z}d"d |D}d!|d"}d#|d$}t|vr4d"d%|D|gz}|d&|j#d'|d(z }tI|ddd)|_d|_%| &D]\}}|'|||r tQtS|_*t'|d*d}tW|tXrt[|}t]|+}t_|| |,d-|jj0&D|_1| j2rtg|nti|| d||.| j5rd/|vrtm||t||j7di||Sd0D]}|8|d|d1i9tj ||||fi|S)3aMetaclass for creating Pydantic models. Args: cls_name: The name of the class to be created. bases: The base classes of the class to be created. namespace: The attribute dictionary of the class to be created. __pydantic_generic_metadata__: Metadata for generic models. __pydantic_reset_parent_namespace__: Reset parent namespace. _create_model_module: The module of the class to be created, if created by `create_model`. **kwargs: Catch-all for any other keyword arguments. Returns: The new class created by the metaclass. model_configNrLr9contextr r@rAc@t||||dS)zWe need to both initialize private attributes and call the user-defined model_post_init method. N)init_private_attributes)rLrporiginal_model_post_inits rOwrapped_model_post_initz7ModelMetaclass.__new__..wrapped_model_post_initxs. 0g>>>00w?????rPmodel_post_init__class_vars____private_attributes__type[BaseModel]zClasses should inherit from `BaseModel` before generic classes (e.g. `typing.Generic[T]`) for pydantic generics to work properly.r stacklevel__pydantic_base_init__Frf parametersr[__parameters__c3 K|]}|vV dSNr[).0xr|s rO z)ModelMetaclass.__new__..s(?k?kTUZ?k?k?k?k?k?krP)RootModelRootTypec3$K|] }|v|V dSrr[)rrparent_parameterss rOrz)ModelMetaclass.__new__..s..c.cQQbHbHbqHbHbHbHb.c.crPz, cg|] }|j Sr[rQrrs rO z*ModelMetaclass.__new__..s3[3[3[1AJ3[3[3[rPzS is a subclass of `RootModel`, but does not include the generic type identifier(s) zL in its parameters. You should parametrize RootModel directly, e.g., `class z (RootModel[z ]): ...`.c,g|]}t|Sr[)r=rs rOrz*ModelMetaclass.__new__..s3X3X3XqCFF3X3X3XrPztyping.Generic[]zJAll parameters must be present on typing.Generic; you should inherit from .cg|] }|j Sr[rrs rOrz*ModelMetaclass.__new__..s2M2M2M!1:2M2M2MrPz- Note: `typing.Generic` must go last: `class (z): ...`))originargsr|__pydantic_parent_namespace__)parent_namespace)config_wrapper ns_resolverc$i|] \}}||jSr[inforr<r>s rO z*ModelMetaclass.__new__..s-000"a16000rP raise_errorsrcreate_model_module__hash__)__pydantic_fields_set____pydantic_extra____pydantic_private____annotations__rLr9rpr r@rA):_collect_bases_datar for_model config_dictinspect_namespace ignored_typesget_model_post_initrrrrrJ__new__r*__mro__r indexrFrGrgetattr__init____pydantic_custom_init__ru__pydantic_post_init____pydantic_setattr_handlers__rbuild__pydantic_decorators__rfrDall root_modelrtuplejoinrQ TypeError__pydantic_complete__items __set_name__build_lenient_weakvaluedictr2rrEdictunpack_lenient_weakvaluedictr-set_model_fieldscomputed_fields__pydantic_computed_fields__ defer_buildr,complete_model_classfrozenset_default_hash_func__pydantic_init_subclass__popclear)!mcsrarbrdrfrhrjrlbase_field_names class_varsbase_private_attributesrprivate_attributesrtcls BaseModel_mrormissing_parametersparameters_str error_messagecombined_parametersgeneric_type_label bases_strnameobjrr instance_slotrsr|rrNs! @@@rOrzModelMetaclass.__new__Ps:6 Z NDGD[D[\aDbDb A j*A*4UIvNNN(6(BIn %!2>7EU"" " K%< K+>y%+P+P(+7344@@@@@54@4KI/003JI/0*4I& '2c5L2cPb2cI. /(/%''/#xPY*d*d]c*d*deeC133J+C#~~#))G"4"4syy7L7L"L"L 1B ! 07s|E]_d/e/e+eC (+z/IIIO`  &13C -*8*>s*C*CC '-. 4Q11$+C1PRT$U$U$Y$YZfhj$k$k!$S*:DAAVEV #3"3#3C?k?k?k?kYj?k?k?k>>>>>)..c.c.c.c*.c.c.c)c)c&(,===BS[eBeBe*.3[3[HZ3[3[3[)\)\"|JJ-JJWZWcJJp~JJJ& /@BT.T+)-3X3XDW3X3X3X)Y)Y-P~-P-P-P*N8JNNN&#%// )- 2M2Mu2M2M2MQcPd2d(e(eI) rPSP\ r r_h r r rM$M222#",551 ).C %05577 , , c  d++++2 j4OPfPhPh4i4i16=cCbdh6i6i *D11 R#?@P#Q#Q $6FGGGK S[ Y Y Y Y00&)&A&Q&W&W&Y&Y000C ,)  $$$$%"!& +(< $ 29)D)D%c5111 7E#sOO 6 @ @ @ @ @J"i    ! MM+R 0 0 6 6 8 8 8"577?3%MMfMM MrPitemcp|jd}|r ||vr||St|)zNThis is necessary to keep attribute access working for class attribute access.rw)__dict__rDAttributeError)rLrrs rO __getattr__zModelMetaclass.__getattr__ sE!%!2!23K!L!L ! 0d.@&@&@)$// && &rPrdict[str, object]ctSr)r;)rrrls rO __prepare__zModelMetaclass.__prepare__s"$$$rPinstancecft|do t|S)zsAvoid calling ABC _abc_instancecheck unless we're pretty sure. See #3829 and python/cpython#92810 r)hasattrrJ__instancecheck__)rLrrNs rOrz ModelMetaclass.__instancecheck__. x!:;;c@Y@YZb@c@ccrPsubclass type[Any]cft|do t|S)zsAvoid calling ABC _abc_subclasscheck unless we're pretty sure. See #3829 and python/cpython#92810 r)rrJ__subclasscheck__)rLrrNs rOrz ModelMetaclass.__subclasscheck__rrP6tuple[set[str], set[str], dict[str, ModelPrivateAttr]]cjt}t}t}i}|D]}t||rn||urj|t |di||j||j|||fS)N__pydantic_fields__)r*set issubclassupdaterkeysrvrw)rbr9 field_namesrrbases rOrz"ModelMetaclass._collect_bases_data#s,.. # "uu :< G GD$ ** Gt9/D/D""741F#K#K#P#P#R#RSSS!!$"5666"))$*EFFFJ(:::rPEThe `__fields__` attribute is deprecated, use `model_fields` instead.)categorydict[str, FieldInfo]c\tjdtdt|diS)Nrrryr)rFrGrrrLs rO __fields__zModelMetaclass.__fields__2s;  S %    t2B777rPct|dsdStd|j}td|DS)zWhether the fields where successfully collected (i.e. type hints were successfully resolves). This is a private attribute, not meant to be used outside Pydantic. rFrc3$K|] }|jV dSr) _complete)r field_infos rOrz>ModelMetaclass.__pydantic_fields_complete__..Gs%OOJ:'OOOOOOrP)rrrrvalues)rL field_infoss rO__pydantic_fields_complete__z+ModelMetaclass.__pydantic_fields_complete__<sX t233 5143KLL OO+:L:L:N:NOOOOOOrP list[str]ctt}d|vr|d|S)Nr)listrJ__dir__remove)rL attributesrNs rOrzModelMetaclass.__dir__IsC%''//++,, : % %   l + + +rP)NTN)rar=rbrcrdrerfrgrhrirjrkrlr r@rm)rr=r@r )rr rlr r@r)rr r@ri)rrr@ri)rbrcr@r)r@r)r@ri)r@r)rQrRrSrtyping TYPE_CHECKINGr classmethodrrr staticmethodrpropertyrrrrrUrVs@rOr`r`NsIM48+/uNuNuNuNuNuNuNn  ' ' ' ' '%%%[%dddddddddddd ; ; ;\ ;ZWbfggg888hgX8 P P PX PrPr`rLr9rprAct|ddVi}|jD]'\}}|}|tur|||<(t |d|dSdS)a This function is meant to behave like a BaseModel method to initialise private attributes. It takes context as an argument since that's what pydantic-core passes when calling it. Args: self: The BaseModel instance. context: The context. rN)rrwr get_defaultrobject_setattr)rLrppydantic_privater private_attrdefaults rOrrrrPst+T22:"&"="C"C"E"E 1 1 D,"..00G///)0 &t35EFFFFF ;:rPrdrerbrcCallable[..., Any] | Nonecpd|vr|dSt}t|d}||jur|SdS)zaGet the `model_post_init` method from the namespace or the class bases, or `None` if not defined.ruN)r*r!ru)rdrbr9rus rOrrbsPI%%*++(**I.u6GHHOi77787rPrbase_class_varsset[str]base_class_fieldsdict[str, ModelPrivateAttr]c ddlmm}t}|t z}i}|di}d|vsd|vrt dt} t| D] \} } | dks| dkrt| tr6| j |dkr%d |vr!| j |d r^t| |s| jj d kr| | t| rY| d rt#d | d t%| rt#dd| zd| d | || <|| =t| |rFields must not use names with leading underscores; e.g., use )rzField z defined on a base class was overridden by a non-annotated attribute. All field definitions, including overrides, require a type annotation.zmodel-field-overridden)codez requires a type annotationzmodel-field-missing-annotationz)A non-annotated attribute was detected: `z = z3`. All model fields require a type annotation; if `z` is not meant to be a field, you may be able to resolve this error by annotating it as a `ClassVar` or updating `model_config['ignored_types']`.NFT) is_argumentis_class)globalnslocalnsc3<K|]}t||VdSr)rE)rr>r7s rOrz$inspect_namespace..s3$\$\1JqJZ<[<[$\Q$\$\$\$\$\$\rP)%fieldsr7r8r+default_ignored_typesrDrrrrrErmrRrS startswithrNadd NameErrorr$lstripr%r1rrrr=sys _getframer0r/ f_globalsf_localsr is_annotatedrrnext)rdrrrr8r6all_ignored_typesrraw_annotations ignored_namesvar_namevaluesuggested_nameann_nameann_typeframermetadatarr7s @rOrrnsm476666666(**I%(=(?(??68mm$5r::O_$$ i(?(?oppp!eeM  1 122;;% ~ % %5I)I)I  ud # #8  Il$;;;)++"--i.GHH,  0 1 10 U_5OS^5^5^   h ' ' '  / 0 0- ""4(( PBJPPP%X.. [/2X~[[MU[[[,1 x ((## y ) ) 2Eh2O2O %__S11?ZNJ,JJz make_hash_func..slmrPrLr r@intc t|jS#t$r-tt|jcYSwxYwr)hashrKeyErrorr4)rLgetters rO hash_funcz!make_hash_func..hash_funcsm At}--.. . A A A / >>??@@ @ @ @  As 4AA)rLr r@rA)roperator itemgetterr)rrFrEs @rOr;r;s\EHE\ mX #"9">">"@"@ A AbmbmFAAAAAA rPrrrNsResolver | Nonect|}t||||\}}||_|j||D]C}|j|d}|$|jturt|||jDdS)zCollect and set `cls.__pydantic_fields__` and `cls.__class_vars__`. Args: cls: BaseModel or dataclass. config_wrapper: The config wrapper instance. ns_resolver: Namespace resolver to use when getting model annotations. ) typevars_mapN) r)r#rrvrrwrrrsetattr)rrrrKr#rr<r3s rOrrs*#..L-c>;]ijjjFJ$Cj)))  + +*..q$77  6G!G!G CEM * * * + +rPrrrirrkc t|}t|||} ||}n4#t$r'}|rt |d|jdYd}~dSd}~wwxYw||j} ||}n #t$rt |YdSwxYwd|j j D|_ t|||_t!|||p|j|j|rdnd| |j|_t+|| |_d|_t1d t3t4|j|j|j|j |_dS) aFinish building a model class. This logic must be called after class has been created since validation functions must be bound and `get_type_hints` requires a class object. Args: cls: BaseModel or dataclass. config_wrapper: The config wrapper instance. raise_errors: Whether to raise errors. ns_resolver: The namespace resolver instance to use during schema building. create_model_module: The module of the class to be created, if created by `create_model`. Returns: `True` if the model is successfully completed, else `False`. Raises: PydanticUndefinedAnnotation: If `PydanticUndefinedAnnotation` occurs in`__get_pydantic_core_schema__` and `raise_errors=True`. rCNF)titlec$i|] \}}||jSr[rrs rOrz(complete_model_class..fs 'r'r'rda16'r'r'rrP create_modelr9T __signature__)rXr#validate_by_nameextra) r)r&generate_schemarr,r core_configrQ clean_schemar'rrrrset_deprecated_descriptors__pydantic_core_schema__rrRrSplugin_settings__pydantic_validator__r__pydantic_serializer__rr3rr.rrrRrSrQ) rrrrrrK gen_schemaschemaerUs rOrr2s6*#..LJ ++C00 &   ]]]]+++uuuuu  !,,3<,@@K((00 uu (s'rc>Y>i>o>o>q>q'r'r'rC$s####)C !8 -s~ ->;&""C#36;"G"GC $C + '*+< &      C 4s'8 A)A$$A)BB;:B;c|jD]D\}}|jx}6t|}|||t |||E|jD]l\}}|jx}^tt|j ds-c22D   c5 ) ) ) C % % %&)&F&L&L&N&N&&""'; ;S H34G4XYY[kll I.c3F3WXXD   c5 ) ) ) C % % %&&rPcBeZdZUdZded<ddd ZddZdddZddZdS)rbaWRead-only data descriptor used to emit a runtime deprecation warning before accessing a deprecated field. Attributes: msg: The deprecation message to be emitted. wrapped_property: The property instance if the deprecated field is a computed field, or `None`. field_name: The name of the field being deprecated. r= field_nameNrercproperty | Noner@rAc"||_||_dSr)rerc)rLrercs rOrz#_DeprecatedFieldDescriptor.__init__s 0rPrrxrc||_dSr)ri)rLrrs rOrz'_DeprecatedFieldDescriptor.__set_name__s rPrBaseModel | Noneobj_typetype[BaseModel] | Noner c&|6|j|jd|St|jt j|jtjd|j|j||S|j |jS)Nrry) rc__get__rrirFrGrebuiltinsDeprecationWarningr)rLrrns rOrqz"_DeprecatedFieldDescriptor.__get__s ;$0,44T8DDD 11 1 dh ;JJJJ  ,(00h?? ?|DO,,rPr3r c*t|jr)rri)rLrr3s rO__set__z"_DeprecatedFieldDescriptor.__set__sT_---rPr)rer=rcrjr@rA)rrxrr=r@rA)rrmrnror@r )rr r3r r@r ) rQrRrSrTrrrrqrur[rPrOrbrbsOOO11111 - - - - -......rPrbc*eZdZdZd dZd dZd dZd S) _PydanticWeakRefaWrapper for `weakref.ref` that enables `pickle` serialization. Cloudpickle fails to serialize `weakref.ref` objects due to an arcane error related to abstract base classes (`abc.ABC`). This class works around the issue by wrapping `weakref.ref` instead of subclassing it. See https://github.com/pydantic/pydantic/issues/6763 for context. Semantics: - If not pickled, behaves the same as a `weakref.ref`. - If pickled along with the referenced object, the same `weakref.ref` behavior will be maintained between them after unpickling. - If pickled without the referenced object, after unpickling the underlying reference will be cleared (`__call__` will always return `None`). rr cN| d|_dStj||_dSr)_wrweakrefref)rLrs rOrz_PydanticWeakRef.__init__s) ;DHHH{3''DHHHrPr@c<|jdS|Sr)ryrs rO__call__z_PydanticWeakRef.__call__s 8 488:: rP4tuple[Callable, tuple[weakref.ReferenceType | None]]c&t|ffSr)rwrs rO __reduce__z_PydanticWeakRef.__reduce__s$$&&**rPN)rr )r@r )r@r~)rQrRrSrTrr}rr[rPrOrwrwsZ (((( ++++++rPrwddict[str, Any] | Nonec|dSi}|D]-\}} t|}n#t$r|}YnwxYw|||<.|S)aXTakes an input dictionary, and produces a new value that (invertibly) replaces the values with weakrefs. We can't just use a WeakValueDictionary because many types (including int, str, etc.) can't be stored as values in a WeakValueDictionary. The `unpack_lenient_weakvaluedict` function can be used to reverse this operation. N)rrwr)rresultr<r>proxys rOrrsv yt F 1 $Q''EE   EEE q Ms1 AAc|dSi}|D]1\}}t|tr|}||||<,|||<2|S)zAInverts the transform performed by `build_lenient_weakvaluedict`.N)rrErw)rrr<r>s rOrrsiyt F 1 a) * * A}q F1II MrPcddlm}tttt t |tg}tj dkr| tjt|S)Nr)ComputedFieldInfo) ) r#rrr rr r rr) version_infoappendrr)rrs rOr$r$sg****** M 7""V1222   rP)rXrYr@r r)rdrerbrcr@r) rdrerrcrrrrr@r)rrxrbrcr@rA)rrxr@r )rrxrrrrIr@rA) rrxrrrrirrIrrkr@ri)rrxr@rA)rrr@r)r@rc)krT __future__r _annotationsrrrGr)rrFrzabcrrrrrtypesrr r r r r r pydantic_corerrtyping_extensionsrrrrrtyping_inspectionrerrorsrrplugin._schema_validatorrrr_configr _decoratorsrr r!r"_fieldsr#r$r%_generate_schemar&r' _genericsr(r) _import_utilsr*r+ _mock_val_serr,_namespace_utilsr- _signaturer. _typing_extrar/r0r1r2_utilsr3r4rr#r5PydanticModelFieldr6r7r8PydanticModelPrivateAttrmainr9rsr? __setattr__r rr;r\r`rrrrrr;rrrWrbrwrrr$r[rPrOrs((222222 ++++++++++BBBBBBBBBBBBBBBB========bbbbbbbbbbbbbb,,,,,,CCCCCCCC>>>>>>OOOOOOOO""""""ssssssssssssYYYYYYYYYY@@@@@@@@FFFFFFFFMMMMMMMM******((((((333333 98888888  (44444444444444@@@@@@       3%vxx# ) ) ) ) )$ ) ) )!T=OQikv