a h@s4dZddlmZddlZddlZddlZddlZddlZddl 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 d eZZ[d!d"d#d$d%d&d'Z\ed(eOeSe\fd)Gd*d+d+e Z]d,d$d-d.d/d0Z^d1d2d3d4d5d6Z_d1d2d7d7d8d9d:d;Z`dd?Zad||ur>t|tr>td|d|jjdt||S)N`z"` overrides an existing Pydantic `z ` decorator) get isinstancerwarningswarnZdecorator_infoZdecorator_reprsuper __setitem__)selfr=r>existing __class__b/var/www/html/assistant/venv/lib/python3.9/site-packages/pydantic/_internal/_model_construction.pyrF<s z_ModelNamespaceDict.__setitem__)__name__ __module__ __qualname____doc__rF __classcell__rKrKrIrLr97sr9FinitzLiteral[False]r)rSr?cCsdS)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. NrKrRrKrKrL NoInitFieldDsrTT)Zkw_only_defaultZfield_specifiersc seZdZd+ddddddd d d fd d Zejs@dd dddZed d ddddZd ddfdd Z dddfdd Z e dddddZ e ed dd!d"d#d$d%Ze dd#d&d'Zd(d#fd)d* ZZS),ModelMetaclassNTr:tuple[type[Any], ...]dict[str, Any]zPydanticGenericMetadata | Nonebool str | Nonertype)cls_namebases namespace__pydantic_generic_metadata__#__pydantic_reset_parent_namespace___create_model_modulekwargsr?c s|rd||\}} } t|||} | j|d<t|| j| |} | sF| rt||durtddddfdd } | |d <nt|d <| |d <i| | |d <t d t j ||||fi|}t }|j }t|vr|t||krtjtd ddt|jdd |_|j|jurdnd |_i|_t||_|rF||_n.wrapped_model_post_initmodel_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 stacklevelZ__pydantic_base_init__Fr^ parametersrK__parameters__c3s|]}|vVqdSNrK.0x)rnrKrL z)ModelMetaclass.__new__..)RootModelRootTypec3s|]}|vr|VqdSrprKrq)parent_parametersrKrLrtruz, cSsg|] }|jqSrKrMrqrKrKrL ruz*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|qSrK)r:rqrKrKrLryruztyping.Generic[]zJAll parameters must be present on typing.Generic; you should inherit from .cSsg|] }|jqSrKrxrqrKrKrLryruz- Note: `typing.Generic` must go last: `class (z): ...`))originargsrn__pydantic_parent_namespace__)parent_namespace)config_wrapper ns_resolvercSsi|]\}}||jqSrKinforrr=r>rKrKrL sz*ModelMetaclass.__new__.. raise_errorsrcreate_model_module__hash__)Z__pydantic_fields_set____pydantic_extra____pydantic_private____annotations__):_collect_bases_datarZ for_modelZ config_dictinspect_namespace ignored_typesget_model_post_initrrer rE__new__r)__mro__r indexrCrDrgetattr__init__Z__pydantic_custom_init__rhZ__pydantic_post_init__Z__pydantic_setattr_handlers__rbuild__pydantic_decorators__r^rAallZ root_modelrvtuplejoinrM TypeError__pydantic_complete__items __set_name__build_lenient_weakvaluedictr1rrBdictunpack_lenient_weakvaluedictr,set_model_fieldscomputed_fields__pydantic_computed_fields__Z defer_buildr+complete_model_classfrozenset_default_hash_funcZ__pydantic_init_subclass__popclear)Zmcsr[r\r]r^r_r`raZbase_field_names class_varsZbase_private_attributesrprivate_attributesrgclsZ BaseModel_mrorvZmissing_parametersZparameters_str error_messageZcombined_parametersZgeneric_type_labelZ bases_strnameobjrrZ instance_slotrI)rfrnrwrLrPs       $          zModelMetaclass.__new__)itemr?cCs,|jd}|r ||vr ||St|dS)zNThis is necessary to keep attribute access working for class attribute access.rjN)__dict__rAAttributeError)rGrrrKrKrL __getattr__ s  zModelMetaclass.__getattr__zdict[str, object])r~rar?cOstSrp)r9)rr~rarKrKrL __prepare__szModelMetaclass.__prepare__)instancer?cst|dot|S)zsAvoid calling ABC _abc_instancecheck unless we're pretty sure. See #3829 and python/cpython#92810 r)hasattrrE__instancecheck__)rGrrIrKrLrsz ModelMetaclass.__instancecheck__z type[Any])subclassr?cst|dot|S)zsAvoid calling ABC _abc_subclasscheck unless we're pretty sure. See #3829 and python/cpython#92810 r)rrE__subclasscheck__)rGrrIrKrLrsz ModelMetaclass.__subclasscheck__z6tuple[set[str], set[str], dict[str, ModelPrivateAttr]])r\r?cCsjt}t}t}i}|D]D}t||r||ur|t|di||j||jq|||fS)N__pydantic_fields__)r)set issubclassupdaterkeysrirj)r\r8 field_namesrrbaserKrKrLr#s z"ModelMetaclass._collect_bases_dataEThe `__fields__` attribute is deprecated, use `model_fields` instead.)categorydict[str, FieldInfo]r?cCstjdtddt|diS)Nrrrlr)rCrDrrrGrKrKrL __fields__2s zModelMetaclass.__fields__cCs0t|dsdStd|j}tdd|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. rFrcss|] }|jVqdSrp)Z _complete)rr field_inforKrKrLrtGruz>ModelMetaclass.__pydantic_fields_complete__..)rr rrvalues)rGZ field_infosrKrKrL__pydantic_fields_complete__<s  z+ModelMetaclass.__pydantic_fields_complete__z list[str]cs$tt}d|vr |d|S)Nr)listrE__dir__remove)rG attributesrIrKrLrIs zModelMetaclass.__dir__)NTN)rMrNrOrtyping TYPE_CHECKINGr classmethodrrr staticmethodrpropertyrrrrrQrKrKrIrLrUNs&"8  rUr8r<rccCsPt|dddurLi}|jD] \}}|}|tur|||<qt|d|dS)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)rrjr get_defaultrobject_setattr)rGrdZpydantic_privater private_attrdefaultrKrKrLrePs  rerWrVzCallable[..., Any] | None)r]r\r?cCs2d|vr|dSt}t|d}||jur.|SdS)zaGet the `model_post_init` method from the namespace or the class bases, or `None` if not defined.rhN)r)r rh)r]r\r8rhrKrKrLrbs   rzset[str]zdict[str, ModelPrivateAttr])r]rbase_class_varsbase_class_fieldsr?c s<ddlmm}t}|t}i}|di}d|vs@d|vrHtdt} t| D]\} } | dksZ| dkrxqZqZt | t r| j |dkrd |vr| j |d rqZqZt | |s| jj d kr| | qZqZt | r,| d rtd | d n$t| rtdd| d| d | || <|| =qZt | |rjt| sj| dpPd} td| d| d qZ| d rzqZqZt| r| |vst|| s0t|| d|| <|| =qZ| |vrqZqZ| |vrZ| |vrtd| dddqZt | |rtd| dddqZtd| d| d| dddqZ| D]\} }t| r:| |vr:| | vr:t|s:||vr:t|ddd kr:t |trtd}|durz tt|dd d!|j|jd"}WnttfyYn0t !t"|r*t#|^}}t$fd#d$|Dd}|dur*||| <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)r6r7rZ__root__zUTo define root models, use `pydantic.RootModel` rather than a field called '__root__'rbrrNrO functools__zXPrivate attributes must not use dunder names; use a single underscore prefix instead of r{zJPrivate attributes must not use valid field names; use sunder names, e.g. _z instead of Zmy_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']`.NFT) is_argumentZis_class)globalnslocalnsc3s|]}t|r|VqdSrp)rB)rrr>r6rKrLrtruz$inspect_namespace..)%fieldsr6r7r*default_ignored_typesrArrrrrBrZrNrO startswithrJadd NameErrorr#lstripr$r0r rrr:sys _getframer/r. f_globalsf_localsrZ is_annotatedrrnext)r]rrrr7r5Zall_ignored_typesrZraw_annotations ignored_namesvar_namevalueZsuggested_nameZann_nameZann_typeframermetadatarrKrrLrns                     rrk)rr\r?cCs<t|d}t|}|dtjhvs2t|dd|jkr8||_dS)Nr__code__)r make_hash_funcr;rrr)rr\Zbase_hash_funcZ new_hash_funcrKrKrLrs  r)rr?cs6|jrtj|jndddddfdd }|S)NcSsdS)NrrK)rrKrKrLruz make_hash_func..rint)rGr?cs:zt|jWSty4tt|jYS0dSrp)hashrKeyErrorr3rgetterrKrL hash_funcs z!make_hash_func..hash_func)roperator itemgetterr)rrrKrrLrs rrzNsResolver | None)rrrr?cCsjt|}t||||d\}}||_|j||D]2}|j|d}|dur2|jtur2t |||jq2dS)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"rrirrjrrrsetattr)rrrrrrr=rrKrKrLrs  rrrXrY)rrrrrr?c Cs$t|}t|||}z||}Wn@tyb}z(|r8t|d|jdWYd}~dSd}~00|j|jd} z||}Wnt yt|YdS0dd|j j D|_ t|||_t|||p|j|j|rdnd| |j|_t|| |_d |_td tt|j|j|j|jd |_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. 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`. r@NF)titlecSsi|]\}}||jqSrKrrrKrKrLrfruz(complete_model_class..Z create_modelr8T __signature__)rSrvalidate_by_nameextra) r(r%Zgenerate_schemarr+r core_configrMZ clean_schemar&rrrrset_deprecated_descriptorsZ__pydantic_core_schema__rrNrOZplugin_settingsZ__pydantic_validator__rZ__pydantic_serializer__rr2rr-rrrrr) rrrrrrZ gen_schemaZschemaerrKrKrLr2sX    rcCs|jD]6\}}|j}dur t|}|||t|||q |jD]J\}}|j}durLtt|j dsLt||j }|||t|||qLdS)z8Set data descriptors on the class for deprecated fields.NZ__deprecated__) rrZdeprecation_message_DeprecatedFieldDescriptorrrrrr!wrapped_property)rfieldrmsgdescZcomputed_field_inforKrKrLrs    rc@sfeZdZUdZded<ddddddd Zd ddd d d ZdddddddZddddddZdS)raWRead-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_nameNzproperty | Noner<)r rr?cCs||_||_dSrp)r r)rGr rrKrKrLrsz#_DeprecatedFieldDescriptor.__init__rk)rrr?cCs ||_dSrp)r )rGrrrKrKrLrsz'_DeprecatedFieldDescriptor.__set_name__zBaseModel | Noneztype[BaseModel] | Noner)robj_typer?cCsb|dur*|jdur |jd|St|jtj|jtjdd|jdurV|j||S|j |jS)Nrrl) r__get__rr rCrDr builtinsDeprecationWarningr)rGrr rKrKrLrs   z"_DeprecatedFieldDescriptor.__get__r )rrr?cCst|jdSrp)rr )rGrrrKrKrL__set__sz"_DeprecatedFieldDescriptor.__set__)N)N) rMrNrOrPrrrrrrKrKrKrLrs rc@s:eZdZdZddddZddddZd dd 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`). r)rcCs |durd|_n t||_dSrp)_wrweakrefref)rGrrKrKrLrsz_PydanticWeakRef.__init__rcCs|jdurdS|SdSrp)rrrKrKrL__call__s z_PydanticWeakRef.__call__z4tuple[Callable, tuple[weakref.ReferenceType | None]]cCs t|ffSrp)rrrKrKrL __reduce__sz_PydanticWeakRef.__reduce__N)rMrNrOrPrrrrKrKrKrLrsrzdict[str, Any] | None)dr?c CsR|dur dSi}|D]4\}}z t|}WntyB|}Yn0|||<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)rrr)rresultr=r>proxyrKrKrLrs    rcCsP|dur dSi}|D]2\}}t|trB|}|durJ|||<q|||<q|S)zAInverts the transform performed by `build_lenient_weakvaluedict`.N)rrBr)rrr=r>rKrKrLrs   rrcCs<ddlm}ttttt|tg}tj dkr4| t jt |S)Nr)ComputedFieldInfo) ) rrrrrrrrr version_infoappendrr)rrrKrKrLrs   r)krP __future__rZ _annotationsrrrrrCrabcrrrrrtypesrrr r r r r Z pydantic_corerrZtyping_extensionsrrrrrZtyping_inspectionrerrorsrrZplugin._schema_validatorrrr_configrZ _decoratorsrrr r!_fieldsr"r#r$Z_generate_schemar%r&Z _genericsr'r(Z _import_utilsr)r*Z _mock_val_serr+Z_namespace_utilsr, _signaturer-Z _typing_extrar.r/r0r1_utilsr2r3rrr4ZPydanticModelFieldr5r6r7ZPydanticModelPrivateAttrmainr8rr; __setattr__rrr9rTrUrerrrrrrrrrrrrrKrKrKrLs|                #V%#