o fz@sdZddlmZddlZddlZddlZddlZddlZddl m Z ddl m Z ddl mZddlmZmZmZmZddlZddlmZmZdd lmZmZd d lmZmZd d lmZd d lmZmZddl m!Z!ddl"m#Z#m$Z$m%Z%m&Z&ddl'm(Z(m)Z)m*Z*ddl+m,Z,ddl-m.Z.m/Z/ddl0m1Z1ddl2m3Z3ddl4m5Z5ddl6m7Z7m8Z8m9Z9m:Z:ddl;mm?Z?ej@rd dlAmBZCd dlAmDZDmEZEd dlAmFZGd dlHmIZIneZJeKZCeKZGeKjLZMGdddeNZOed eCeGfd!Gd"d#d#e ZPd\d*d+ZQd]d1d2ZRd^d8d9ZSd_dd?ZUdadCdDZVd ddEdbdMdNZWdcdOdPZXGdQdRdRZYGdSdTdTZZdddVdWZ[dddXdYZ\dedZd[Z]dS)fz"Private logic for creating models.) annotationsN)ABCMeta)partial) FunctionType)AnyCallableGenericNoReturn)PydanticUndefinedSchemaSerializer)dataclass_transform deprecated)PydanticUndefinedAnnotationPydanticUserError)create_schema_validator)GenericBeforeBaseModelWarningPydanticDeprecatedSince20) ConfigWrapper)DecoratorInfosPydanticDescriptorProxyget_attribute_from_basesunwrap_wrapped_function)collect_model_fieldsis_valid_field_nameis_valid_privateattr_name)GenerateSchema)PydanticGenericMetadataget_model_typevars_map)set_model_mocks)CallbackGetCoreSchemaHandler)generate_pydantic_signature)get_cls_types_namespace is_annotated is_classvarparent_frame_namespace)ClassAttributeSafeGetItemProxy)ValidateCallWrapper)Field) FieldInfoModelPrivateAttr) PrivateAttr BaseModelcs"eZdZdZd fdd ZZS) _ModelNamespaceDictz{A dictionary subclass that intercepts attribute setting on model classes and warns about overriding of decorators. kstrvobjectreturnNonecsL||d}|r||urt|trtd|d|jjdt||S)N`z"` overrides an existing Pydantic `z ` decorator) get isinstancerwarningswarndecorator_infodecorator_reprsuper __setitem__)selfr1r3existing __class__^/var/www/NoticeGen/venv/lib/python3.10/site-packages/pydantic/_internal/_model_construction.pyr?6s z_ModelNamespaceDict.__setitem__)r1r2r3r4r5r6)__name__ __module__ __qualname____doc__r? __classcell__rDrDrBrEr01sr0T)kw_only_defaultfield_specifierscseZdZ   d*d+fdd Zejsd,ddZed-ddZd.fdd Z e d/d d!Z e e d"dd#d0d%d&Zd1fd(d) ZZS)2ModelMetaclassNTcls_namer2basestuple[type[Any], ...] namespacedict[str, Any]__pydantic_generic_metadata__PydanticGenericMetadata | None#__pydantic_reset_parent_namespace__bool_create_model_module str | Nonekwargsrr5typec sZ|r||\}} } t|||} | j|d<t|| j| |} | s#| r.wrapped_model_post_initmodel_post_init__class_vars____private_attributes__rr.zClasses should inherit from `BaseModel` before generic classes (e.g. `typing.Generic[T]`) for pydantic generics to work properly. stacklevel__pydantic_base_init__FrS parametersrD__parameters__c3s|]}|vVqdSNrD.0x)rfrDrE sz)ModelMetaclass.__new__..)RootModelRootTypec3s|] }|vr|VqdSrhrDri)parent_parametersrDrErlsz, cSg|]}|jqSrDrFrirDrDrE z*ModelMetaclass.__new__..zS 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 ]): ...`.cSsg|]}t|qSrD)r2rirDrDrErqsztyping.Generic[]zJAll parameters must be present on typing.Generic; you should inherit from .cSrorDrprirDrDrErqrrz- Note: `typing.Generic` must go last: `class (z): ...`))originargsrf__pydantic_parent_namespace____hash__) raise_errorstypes_namespacecreate_model_modulecSsi|]\}}||jqSrD)info)rjr1r3rDrDrE sz*ModelMetaclass.__new__..r@r/r\rr5r6)5_collect_bases_datar for_model config_dictinspect_namespace ignored_typesget_model_post_initr]r>__new__mainr/__mro__rindexr:r;rgetattr__init____pydantic_custom_init__r`__pydantic_post_init__rbuild__pydantic_decorators__rSr8all root_modelrmtuplejoinrF TypeError__pydantic_complete__items __set_name__build_lenient_weakvaluedictr&rxr9dictunpack_lenient_weakvaluedictr#set_model_fieldsfrozenset_default_hash_funccomplete_model_classcomputed_fieldsmodel_computed_fieldsset_deprecated_descriptors__pydantic_init_subclass__)mcsrNrOrQrSrUrWrYbase_field_names class_varsbase_private_attributesconfig_wrapperprivate_attributesr_clsr/mrormmissing_parametersparameters_str error_messagecombined_parametersgeneric_type_label bases_strnameobjparent_namespacer{rB)r^rfrnrEr@s      $         zModelMetaclass.__new__itemcCs(|jd}|r||vr||St|)zNThis is necessary to keep attribute access working for class attribute access.rb)__dict__r8AttributeError)r@rrrDrDrE __getattr__s  zModelMetaclass.__getattr__rwdict[str, object]cOstSrh)r0)rrwrYrDrDrE __prepare__szModelMetaclass.__prepare__instancecst|do t|S)zsAvoid calling ABC _abc_subclasscheck unless we're pretty sure. See #3829 and python/cpython#92810 __pydantic_validator__)hasattrr>__instancecheck__)r@rrBrDrErsz ModelMetaclass.__instancecheck__6tuple[set[str], set[str], dict[str, ModelPrivateAttr]]cCspddlm}t}t}i}|D]"}t||r2||ur2|t|di||j||jq|||fS)Nrr. model_fields) rr/set issubclassupdaterkeysrarb)rOr/ field_namesrrbaserDrDrErs    z"ModelMetaclass._collect_bases_dataEThe `__fields__` attribute is deprecated, use `model_fields` instead.)categorydict[str, FieldInfo]cCstdt|jS)Nr)r:r;rrr@rDrDrE __fields__ szModelMetaclass.__fields__ list[str]cs$tt}d|vr|d|S)Nr)listr>__dir__remove)r@ attributesrBrDrErs zModelMetaclass.__dir__)NTN)rNr2rOrPrQrRrSrTrUrVrWrXrYrr5rZ)rr2r5r)rwrrYrr5r)rrr5rV)rOrPr5r)r5r)r5r)rFrGrHrtyping TYPE_CHECKINGr classmethodrr staticmethodrpropertyr rrrJrDrDrBrErM>s"&    rMr@r/r\rr5r6cCsTt|dddur(i}|jD]\}}|}|tur|||<qt|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. __pydantic_private__N)rrbr get_defaultr object_setattr)r@r\pydantic_privater private_attrdefaultrDrDrEr]s r]rQrRrOrPCallable[..., Any] | NonecCs8d|vr|dSddlm}t|d}||jur|SdS)zaGet the `model_post_init` method from the namespace or the class bases, or `None` if not defined.r`rr.N)rr/rr`)rQrOr/r`rDrDrEr*s   rrbase_class_varsset[str]base_class_fieldsdict[str, ModelPrivateAttr]c sddlm}mm}|t}i}|di}d|vsd|vr#tdt} t| D]\} } | dks8| dkr9q,t | t rR| j |dkrRd |vrR| j |d rRq,t | |s]| jj d krc| | q,t | r| d rutd | d t| rtdd| d| d | || <|| =q,t | |rt| s| dpd} td| d| d | d rq,t| r| |vst|| s|| d|| <|| =q,| |vrq,| |vr| |vrtd| dddt | |rtd| dddtd| d| d| dddq,| D]O\} }t| rQ| |vrQ| | vrQt|sQ||vrQt|ddd krQt|rLt|^}}tfdd |Dd}|durL||| <q||| <q|S)!aIterate over the namespace and: * gather private attributes * check for items which look like fields but are not (e.g. have no annotation) and warn. Args: namespace: The attribute dictionary of the class to be created. ignored_types: A tuple of ignore types. base_class_vars: A set of base class class variables. base_class_fields: A set of base class fields. Returns: A dict contains private attributes info. Raises: TypeError: If there is a `__root__` field in model. NameError: If private attribute name is invalid. PydanticUserError: - If a field does not have a type annotation. - If a field on base class was overridden by a non-annotated attribute. r)r+r,r-__annotations____root__zUTo define root models, use `pydantic.RootModel` rather than a field called '__root__'r[__pydantic_extra__rGrH functools__zXPrivate attributes must not use dunder names; use a single underscore prefix instead of rtzJPrivate attributes must not use valid field names; use sunder names, e.g. _z instead of my_fieldz>Fields 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']`.Nc3s|] }t|r|VqdSrh)r9)rjr3r,rDrErlsz$inspect_namespace..)fieldsr+r,r-default_ignored_typesr8rrrrr9rZrGrH startswithrCadd NameErrorrlstriprr%rrr$typing_extensionsget_argsnext)rQrrrr+r-all_ignored_typesrraw_annotations ignored_namesvar_namevaluesuggested_nameann_nameann_typermetadatarrDrrEr6s               rrtype[BaseModel]cCs@t|d}t|}|dtjhvst|dd|jkr||_dSdS)Nry__code__)rmake_hash_funcr4ryrr)rrObase_hash_func new_hash_funcrDrDrErs   rcs0|jr tj|jnddd fdd }|S) NcSsdS)NrrD)rrDrDrEsz make_hash_func..r@rr5intcs6zt|jWStytt|jYSwrh)hashrKeyErrorr(rgetterrDrE hash_funcs  z!make_hash_func..hash_func)r@rr5r)roperator itemgetterr)rrrDrrErs rrrr{c Cslt|}t|||||d\}}||_|j||D]}|j|d}|dur3|jtur3t |||jqdS)a.Collect and set `cls.model_fields` and `cls.__class_vars__`. Args: cls: BaseModel or dataclass. bases: Parents of the class, generally `cls.__bases__`. config_wrapper: The config wrapper instance. types_namespace: Optional extra namespace to look for types in. ) typevars_mapN) rrrrarrbpoprr setattr) rrOrr{r rrr1rrDrDrErs  r)rzr|rNr2rzrVdict[str, Any] | Noner|rXc Cs6t|}t|||}tt|jdd|dd}|jr%d|jvr%t||dSz|||} Wn!t yN} z|r8t||d| j dWYd} ~ dSd} ~ ww| |} z| | } Wn|j ykt||YdSw| |_t| ||pv|j|j|r|dnd | |j|_t| | |_d |_td t|j|j|d |_d S) 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. cls_name: The model or dataclass name. config_wrapper: The config wrapper instance. raise_errors: Whether to raise errors. types_namespace: Optional extra namespace to look for types in. 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`. F)from_dunder_get_core_schemaunpack)ref_modemodelr7N create_modelr/T __signature__)initrr)rrr!rgenerate_schema defer_buildexperimental_defer_build_moder __get_pydantic_core_schema__rr core_config clean_schemaCollectedInvalid__pydantic_core_schema__rrGrHplugin_settingsrr __pydantic_serializer__rr'r"rrr) rrNrrzr{r|r  gen_schemahandlerschemaerrDrDrErs^      rcCs|jD]\}}|j}dur t|}|||t|||q|jD]%\}}|j}durKtt|j dsKt||j }|||t|||q&dS)z8Set data descriptors on the class for deprecated fields.N__deprecated__) rrdeprecation_message_DeprecatedFieldDescriptorrr rrrwrapped_property)rfield field_infomsgdesccomputed_field_inforDrDrEr<s     rc@sFeZdZUdZded<ddd d ZdddZddddZd ddZdS)!r$aMData 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. r2 field_nameNr(r%property | Noner5r6cCs||_||_dSrh)r(r%)r@r(r%rDrDrErZs z#_DeprecatedFieldDescriptor.__init__rrrcCs ||_dSrh)r+)r@rrrDrDrEr^ z'_DeprecatedFieldDescriptor.__set_name__rBaseModel | Noneobj_typetype[BaseModel] | NonercCsJ|dur t|jtj|jtjdd|jdur|j||S|j |jS)Nrrc) rr+r:r;r(builtinsDeprecationWarningr%__get__r)r@rr/rDrDrEr3as    z"_DeprecatedFieldDescriptor.__get__rr cCs t|jrh)rr+)r@rrrDrDrE__set__nr-z"_DeprecatedFieldDescriptor.__set__rh)r(r2r%r,r5r6)rrrr2r5r6)rr.r/r0r5r)rrrrr5r ) rFrGrHrIrrrr3r4rDrDrDrEr$Os     r$c@s.eZdZdZd ddZdddZdd d Zd 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`). rrcCs"|dur d|_dSt||_dSrh)_wrweakrefref)r@rrDrDrErs z_PydanticWeakRef.__init__r5cCs|jdurdS|Srh)r6rrDrDrE__call__s z_PydanticWeakRef.__call__4tuple[Callable, tuple[weakref.ReferenceType | None]]cCs t|ffSrh)r5rrDrDrE __reduce__s z_PydanticWeakRef.__reduce__N)rr)r5r)r5r:)rFrGrHrIrr9r;rDrDrDrEr5rs   r5dc CsR|durdSi}|D]\}}zt|}Wn ty!|}Ynw|||<q |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)rr5r)r<resultr1r3proxyrDrDrErs   rcCsP|durdSi}|D]\}}t|tr!|}|dur |||<q |||<q |S)zAInverts the transform performed by `build_lenient_weakvaluedict`.N)rr9r5)r<r=r1r3rDrDrErs  rcCsddlm}ttttt|tfS)NrComputedFieldInfo)rr@rrrrrr)r?rDrDrErs rr)rQrRrOrPr5r) rQrRrrPrrrrr5r)rrrOrPr5r6)rrr5r) rrrOrPrrr{rRr5r6)rrrNr2rrrzrVr{r r|rXr5rV)rrr5r6)r<r r5r )r5rP)^rI __future__r _annotationsr1rrr:r7abcrrrtypesrrrrr r pydantic_corer r r r errorsrrplugin._schema_validatorrrr_configr _decoratorsrrrr_fieldsrrr_generate_schemar _genericsrr _mock_val_serr _schema_generation_sharedr! _signaturer" _typing_extrar#r$r%r&_utilsr'r(_validate_callr)rrr*PydanticModelFieldr+r,r-PydanticModelPrivateAttrrr/r2r4 __setattr__rrr0rMr]rrrrrrrr$r5rrrrDrDrDrEsp               Z  v # U# #