B hndh @stUdZddlmZddlZddlZddlZddlmZmZddlm Z m Z ddl Z ddl Z ddl m Z ddlmZmZmZmZmZmZmZmZmZmZmZdd lmZdd lmZdd lmZ dd lm!Z"dd l#m$Z$m%Z%ddl&m'Z'm(Z(m)Z)ddl*m+Z+m,Z,m-Z-m.Z.m/Z/ddlm0Z0ej1rddl2m3Z3ddl4m5Z5ddl m6Z6m7Z7m8Z8ddl m9Z9m:Z:ddl;mZ?e@e e e fZAejBejCeDe fddfZEejFdddZGdZHdeId<ne0ZJdZKejLZMGdddejNdZOejPddeQddd d!d"d#d!d$d%d&d'd(d)d*ZRejPdeQddd+d!d"d,d!d$d%d&d-d(d.d*ZRddeQdddd/d!d"d0d!d$d%d1d&d-d2 d3d*ZReeQZSdS)4zLogic for creating models.) annotationsN)copydeepcopy)AnyClassVar)PydanticUndefined) _annotated_handlers_config _decorators_fields _forward_ref _generics_mock_validator_model_construction_repr _typing_extra_utils)getattr_migration) ConfigDict)copy_internals)parse)PydanticUndefinedAnnotationPydanticUserError)ComputedFieldInfo FieldInfoModelPrivateAttr)DEFAULT_REF_TEMPLATEGenerateJsonSchemaJsonSchemaModeJsonSchemaValuemodel_json_schema)PydanticDeprecatedSince20) Signature)Path) CoreSchemaSchemaSerializerSchemaValidator)LiteralUnpack)AbstractSetIntStrMappingIntStrAny)FieldModel BaseModel)boundzd:d d?d:d@dAdBZdCd7d7dddddd.dD dEdFdFd?d?d?d?d?d?dGdH dIdJZ d7d7d7dddddd.dK dLdFdFd?d?d?d?d?d?dMdN dOdPZ!ed.e"e#dQfd?dMdRdSdGdTdUdVZ$edWdMdXdYdZZ%d)d*d[d\d]Z&edd.d^d7d_d?d?d`d dadbdcddZ'ed7d7d7ded8d)dadad d:dfdgdhZ(ed7d7did8djdad d:dkdldmZ)edndodpdqdrdsZ*edpdtdudvdwdxZ+ed)d*dydzd{Z,d|d}d~ddZ-d:d:dddZ.dd:dd:dddZ/ejs$dMd)dfdd Z0dMd)d*dddZ1dMd)dddZ2dd0ddZ3dd*dddZ4d)d?dddZ5ejrddddZ6dd0ddZ7dMd0ddZ8dd0ddZ9e:j;jZ>e:j;j?Z?dMd0ddZ@eeAjBdeCddd0ddZDeeAjBdeCdd"d0ddZEeAjBdeCdd7d7ddddddFdFd?d?d?d?ddddZFeAjBdeCdd7d7ddddeGeGddFdFd?d?d?d?dd?d)dMd ddZHeeAjBdeCdd8d)d:dddZIeeAjBdeCdd7dd7ddd8dddMdd?d:dŜddDŽZJeeAjBdeCdd7dd7ddd8dddMdd?d:dʜdd̄ZKeeAjBdeCdd8d)d:dddτZLeeAjBdeCddd8d9d)d:d;dd҄ZMeAjBdeCdd7d7d7ddԜd:dddd?d:dלddلZNeeAjBdeCdd.e"fd?dMddۜdd݄ZOeeAjBdeCdd.e"dߜd?dMd)dMdddZPeeAjBdeCdd8d)d:dddZQeeAjBdeCdd)d*dddZReAjBdeCdd)d)d)dddZSeAjBdeCdd)d)d)dddZTeeAjBdeCdd)d)d)dddZUeAjBdeCdd)d)d)dddZVZWS)r.aA base model class for creating Pydantic models. Attributes: model_config: Configuration settings for the model. model_fields: Metadata about the fields defined on the model. This replaces `Model.__fields__` from Pydantic V1. __class_vars__: The names of classvars defined on the model. __private_attributes__: Metadata about the private attributes of the model. __signature__: The signature for instantiating the model. __pydantic_complete__: Whether model 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_custom_init__: Whether the model has a custom `__init__` function. __pydantic_decorators__: Metadata containing the decorators defined on the model. This replaces `Model.__validators__` and `Model.__root_validators__` from Pydantic V1. __pydantic_generic_metadata__: Metadata for generic models; contains data used for a similar purpose to __args__, __origin__, __parameters__ in typing-module generics. May eventually be replaced by these. __pydantic_parent_namespace__: Parent namespace of the model, used for automatic rebuilding of models. __pydantic_post_init__: The name of the post-init method for the model, if defined. __pydantic_root_model__: Whether the model is a `RootModel`. __pydantic_serializer__: The pydantic-core SchemaSerializer used to dump instances of the model. __pydantic_validator__: The pydantic-core SchemaValidator used to validate instances of the model. __pydantic_extra__: An instance attribute with the values of extra fields from validation when `model_config['extra'] == 'allow'`. __pydantic_fields_set__: An instance attribute with the names of fields explicitly specified during validation. __pydantic_private__: Instance attribute with the values of private attributes set on the model instance. zClassVar[ConfigDict] model_configzClassVar[dict[str, FieldInfo]] model_fieldszClassVar[set[str]]__class_vars__z%ClassVar[dict[str, ModelPrivateAttr]]__private_attributes__zClassVar[Signature] __signature__zClassVar[bool]__pydantic_complete__zClassVar[CoreSchema]__pydantic_core_schema__Z__pydantic_custom_init__z$ClassVar[_decorators.DecoratorInfos]__pydantic_decorators__z+ClassVar[_generics.PydanticGenericMetadata]__pydantic_generic_metadata__zClassVar[dict[str, Any] | None]__pydantic_parent_namespace__z+ClassVar[None | Literal['model_post_init']]__pydantic_post_init____pydantic_root_model__zClassVar[SchemaSerializer]__pydantic_serializer__zClassVar[SchemaValidator]__pydantic_validator__F)initzdict[str, Any] | None__pydantic_extra__zset[str]__pydantic_fields_set____pydantic_private__zXPydantic models should inherit from BaseModel, BaseModel cannot be instantiated directlyzbase-model-instantiated)code)__dict__rBrArCrNone)datareturncKsd}|jj||ddS)a1Create a new model by parsing and validating input data from keyword arguments. Raises ValidationError if the input data cannot be parsed to form a valid model. Uses `__pydantic_self__` instead of the more common `self` for the first arg to allow `self` as a field name. T)Z self_instanceN)r?validate_python)Z__pydantic_self__rG__tracebackhide__rK1/tmp/pip-unpacked-wheel-y3jxpnai/pydantic/main.py__init__s zBaseModel.__init__Tzdict[str, ComputedFieldInfo])rHcCsdd|jjDS)zGet the computed fields of this model instance. Returns: A dictionary of computed field names and their corresponding `ComputedFieldInfo` objects. cSsi|]\}}|j|qSrK)info).0kvrKrKrL sz3BaseModel.model_computed_fields..)r9Zcomputed_fieldsitems)selfrKrKrLmodel_computed_fieldsszBaseModel.model_computed_fieldscCs|jS)zGet extra fields set during validation. Returns: A dictionary of extra fields, or `None` if `config.extra` is not set to `"allow"`. )rA)rTrKrKrL model_extraszBaseModel.model_extracCs|jS)zReturns the set of fields that have been set on this model instance. Returns: A set of strings representing the fields that have been set, i.e. that were not filled from defaults. )rB)rTrKrKrLmodel_fields_setszBaseModel.model_fields_setNz type[Model]zset[str] | Noner-)cls _fields_setvaluesrHc Ks4||}i}i}xh|jD]Z\}}|jrH|j|krH||j||<q||kr`||||<q|s|jdd||<qW|dkrt|}| |d}|j ddkri}x(|D]\} } | || <qWn | |t |d|t |d||j st |d||jr|dn|j s0t |d d|S) aSCreates a new instance of the `Model` class with validated data. Creates a new model setting `__dict__` and `__pydantic_fields_set__` from trusted or pre-validated data. Default values are respected, but no other validation is performed. Behaves as if `Config.extra = 'allow'` was set since it adds all passed values Args: _fields_set: The set of field names accepted for the Model instance. values: Trusted or pre-validated data dictionary. Returns: A new instance of the `Model` class with validated data. T)Zcall_default_factoryNextraallowrErBrArC)__new__r3rSaliaspopZ is_required get_defaultsetkeysupdater2get_object_setattrr=r<model_post_init) rXrYrZmZ fields_valuesdefaultsnamefieldZ_extrarPrQrKrKrLmodel_constructs8         zBaseModel.model_construct)rcdeepbool)rTrcrlrHcCs|r |n|}|r|jddkrpxR|D]8\}}||jkrP||j|<q2|jdkr`i|_||j|<q2Wn |j||j | |S)aNReturns a copy of the model. Args: update: Values to change/add in the new model. Note: the data is not validated before creating the new model. You should trust this data. deep: Set to `True` to make a deep copy of the model. Returns: New model instance. r[r\N) __deepcopy____copy__r2rdrSr3rErArcrBrb)rTrcrlcopiedrPrQrKrKrL model_copys     zBaseModel.model_copypython) modeincludeexcludeby_alias exclude_unsetexclude_defaults exclude_none round_tripwarningsz!Literal[('json', 'python')] | strr0zdict[str, Any]) rsrtrurvrwrxryrzr{rHc Cs |jj|||||||||| d S)aUsage docs: https://docs.pydantic.dev/dev-v2/usage/serialization/#modelmodel_dump Generate a dictionary representation of the model, optionally specifying which fields to include or exclude. Args: mode: The mode in which `to_python` should run. If mode is 'json', the dictionary will only contain JSON serializable types. If mode is 'python', the dictionary may contain any Python objects. include: A list of fields to include in the output. exclude: A list of fields to exclude from the output. by_alias: Whether to use the field's alias in the dictionary key if defined. exclude_unset: Whether to exclude fields that are unset or None from the output. exclude_defaults: Whether to exclude fields that are set to their default value from the output. exclude_none: Whether to exclude fields that have a value of `None` from the output. round_trip: Whether to enable serialization and deserialization round-trip support. warnings: Whether to log warnings when invalid fields are encountered. Returns: A dictionary representation of the model. ) rsrvrtrurwrxryrzr{)r>Z to_python) rTrsrtrurvrwrxryrzr{rKrKrL model_dumps!zBaseModel.model_dump) indentrtrurvrwrxryrzr{z int | Nonestr) r}rtrurvrwrxryrzr{rHc Cs$|jj|||||||||| d S)aIUsage docs: https://docs.pydantic.dev/dev-v2/usage/serialization/#modelmodel_dump_json Generates a JSON representation of the model using Pydantic's `to_json` method. Args: indent: Indentation to use in the JSON output. If None is passed, the output will be compact. include: Field(s) to include in the JSON output. Can take either a string or set of strings. exclude: Field(s) to exclude from the JSON output. Can take either a string or set of strings. by_alias: Whether to serialize using field aliases. exclude_unset: Whether to exclude fields that have not been explicitly set. exclude_defaults: Whether to exclude fields that have the default value. exclude_none: Whether to exclude fields that have a value of `None`. round_trip: Whether to use serialization/deserialization between JSON and class instance. warnings: Whether to show any warnings that occurred during serialization. Returns: A JSON string representation of the model. ) r}rtrurvrwrxryrzr{)r>Zto_jsondecode) rTr}rtrurvrwrxryrzr{rKrKrLmodel_dump_json1szBaseModel.model_dump_jsonZ validationztype[GenerateJsonSchema]r)rv ref_templateschema_generatorrsrHcCst|||||dS)aGenerates a JSON schema for a model class. To override the logic used to generate the JSON schema, you can create a subclass of `GenerateJsonSchema` with your desired modifications, then override this method on a custom base class and set the default value of `schema_generator` to be your subclass. Args: by_alias: Whether to use attribute aliases or not. ref_template: The reference template. schema_generator: The JSON schema generator. mode: The mode in which to generate the schema. Returns: The JSON schema for the given model class. )rvrrrs)r!)rXrvrrrsrKrKrLr!]szBaseModel.model_json_schemaztuple[type[Any], ...])paramsrHcCs>t|tjstddd|D}d|}|jd|dS)a}Compute the class name for parametrizations of generic classes. This method can be overridden to achieve a custom naming scheme for generic BaseModels. Args: params: Tuple of types of the class. Given a generic class `Model` with 2 type variables and a concrete model `Model[str, int]`, the value `(str, int)` would be passed to `params`. Returns: String representing the new class where `params` are passed to `cls` as type variables. Raises: TypeError: Raised when trying to generate concrete names for non-generic models. z;Concrete names should only be generated for generic models.cSs$g|]}t|tr|nt|qSrK) isinstancer~rZdisplay_as_type)rOparamrKrKrL sz5BaseModel.model_parametrized_name..z, []) issubclasstypingGeneric TypeErrorjoin__name__)rXrZ param_namesZparams_componentrKrKrLmodel_parametrized_namexs   z!BaseModel.model_parametrized_name)_BaseModel__contextrHcCsdS)zOverride this method to perform additional initialization after `__init__` and `model_construct`. This is useful if you want to do some validation that requires the entire model to be initialized. NrK)rTrrKrKrLrfszBaseModel.model_post_init)force raise_errors_parent_namespace_depth_types_namespaceintz bool | None)rrrrrHcCs|s|jrdS|dk r |}n>|dkrLtj|dp6i}|jp@i}|||_|j}t||}tj||jt j |j dd||dSdS)a1Try to rebuild the pydantic-core schema for the model. 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. Args: force: Whether to force the rebuilding of the model 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`. Nr)Z parent_depthF)check)rtypes_namespace) r7rrZparent_frame_namespacer;Zget_cls_types_namespacerZcomplete_model_classrr ConfigWrapperr2)rXrrrrrZframe_parent_nsZ cls_parent_nsrKrKrL model_rebuilds      zBaseModel.model_rebuild)strictfrom_attributescontext)rXobjrrrrHcCsd}|jj||||dS)aValidate a pydantic model instance. Args: obj: The object to validate. strict: Whether to raise an exception on invalid fields. from_attributes: Whether to extract data from object attributes. context: Additional context to pass to the validator. Raises: ValidationError: If the object could not be validated. Returns: The validated model instance. T)rrr)r?rI)rXrrrrrJrKrKrLmodel_validateszBaseModel.model_validate)rrzstr | bytes | bytearray)rX json_datarrrHcCsd}|jj|||dS)aValidate the given JSON data against the Pydantic model. Args: json_data: The JSON data to validate. strict: Whether to enforce types strictly. context: Extra variables to pass to the validator. Returns: The validated Pydantic model. Raises: ValueError: If `json_data` is not a JSON string. T)rr)r?Z validate_json)rXrrrrJrKrKrLmodel_validate_jsonszBaseModel.model_validate_jsonztype[BaseModel]z(_annotated_handlers.GetCoreSchemaHandlerr%)_BaseModel__source_BaseModel__handlerrHcCs"d|jkr|jds|jS||S)aHook into generating the model's CoreSchema. Args: __source: The class we are generating a schema for. This will generally be the same as the `cls` argument if this is a classmethod. __handler: Call into Pydantic's internal JSON schema generation. A callable that calls into Pydantic's internal CoreSchema generation logic. Returns: A `pydantic-core` `CoreSchema`. r8origin)rEr:r8)rXrrrKrKrL__get_pydantic_core_schema__s  z&BaseModel.__get_pydantic_core_schema__z(_annotated_handlers.GetJsonSchemaHandlerr )_BaseModel__core_schemarrHcCs||S)acHook into generating the model's JSON schema. Args: __core_schema: A `pydantic-core` CoreSchema. You can ignore this argument and call the handler with a new CoreSchema, wrap this CoreSchema (`{'type': 'nullable', 'schema': current_schema}`), or just call the handler with the original schema. __handler: Call into Pydantic's internal JSON schema generation. This will raise a `pydantic.errors.PydanticInvalidForJsonSchema` if JSON schema generation fails. Since this gets called by `BaseModel.model_json_schema` you can override the `schema_generator` argument to that function to change JSON schema generation globally for a type. Returns: A JSON schema, as a Python object. rK)rXrrrKrKrL__get_pydantic_json_schema__sz&BaseModel.__get_pydantic_json_schema__)kwargsrHcKsdS)aThis is intended to behave just like `__init_subclass__`, but is called by `ModelMetaclass` only after the class is actually fully initialized. In particular, attributes like `model_fields` will be present when this is called. This is necessary because `__init_subclass__` will always be called by `type.__new__`, and it would require a prohibitively large refactor to the `ModelMetaclass` to ensure that `type.__new__` was called in such a manner that the class would already be sufficiently initialized. This will receive the same `kwargs` that would be passed to the standard `__init_subclass__`, namely, any kwargs passed to the class definition that aren't used internally by pydantic. Args: **kwargs: Any keyword arguments passed to the class definition that aren't used internally by pydantic. NrK)rXrrKrKrL__pydantic_init_subclass__0sz$BaseModel.__pydantic_init_subclass__z!type[Any] | tuple[type[Any], ...]z3type[BaseModel] | _forward_ref.PydanticRecursiveRef)typevar_valuesrHc st||}|dk r|S|tkr(tdt|ds@t|d|jdsdtj|jkrdt|dt |t st|f}t ||t t |jd|trr|}t|||n|jd}|s|}nt fdd|D}|jd p|}||}t d d tD}t|||} | dk r:| St||||}|dk rX|Sy|jd d Wntk r~YnXt||||}t|||||WdQRX|S)NzAType parameters should be placed on typing.Generic, not BaseModel__parameters__zG cannot be parametrized because it does not inherit from typing.Generic parametersz is not a generic classargsc3s|]}t|VqdS)N)rZ replace_types)rOarg) typevars_maprKrL bsz.BaseModel.__class_getitem__..rcSsi|] }d|qS)NrK)rOrrKrKrLrRgsz/BaseModel.__class_getitem__..)r)rZget_cached_generic_type_earlyr.rhasattrr:rr __bases__rtupleZcheck_parameters_countdictziprZ all_identicalrbrZZset_cached_generic_typerZiter_contained_typevarsZgeneric_recursion_self_typeZget_cached_generic_type_laterrZcreate_generic_submodel) rXrcachedZsubmodelZ parent_argsrrZ model_namerZmaybe_self_typerK)rrL__class_getitem__CsL        zBaseModel.__class_getitem__)rTrHcCst|}||}t|dt|jt|dt|jt|dt|j|jdkr`t|ddnt|ddd|jD|S)z$Returns a shallow copy of the model.rErArBNrCcSsi|]\}}|tk r||qSrK)r)rOrPrQrKrKrLrRsz&BaseModel.__copy__..) typer]rerrErArBrCrS)rTrXrgrKrKrLros  zBaseModel.__copy__zdict[int, Any] | None)rTmemorHcCst|}||}t|dt|j|dt|dt|j|dt|dt|j|jdkrht|ddn$t|dtdd|j D|d|S) z!Returns a deep copy of the model.rE)rrArBNrCcSsi|]\}}|tk r||qSrK)r)rOrPrQrKrKrLrRsz*BaseModel.__deepcopy__..) rr]rerrErArrBrCrS)rTrrXrgrKrKrLrns  zBaseModel.__deepcopy__)itemrHc st|d}||kr||}t|dr6||t|Sy |j|Stk r|}ztt|jd||Wdd}~XYnXnt|d}|dk ry||Stk r}ztt|jd||Wdd}~XYnXn0t|j |rt |Stt|jd|dS)Nr5__get__z object has no attribute rA) object__getattribute__rrrrCKeyErrorAttributeErrorr __class__super)rTrZprivate_attributes attributeexcpydantic_extra)rrKrL __getattr__s$   . .  zBaseModel.__getattr__)rivaluerHc Cs||jkr4t|d|jjd|jjd|dnt|s|jdksR||jkr`t|||n,|j|}t |dr| ||n ||j|<dS|j ddrd|f|d}t j|jj|gt|j|d}t|tr| ||n|j d dr|j|||nz|j d d krB||jkrBtd |jjd |d n@|j d d krl||jkrl||j|<n||j|<|j|dS)Nz is a ClassVar of `zR` and cannot be set on an instance. If you want to set a value on the class, use `.z = value`.__set__frozenZfrozen_instance)rlocinputvalidate_assignmentr[r\"z" object has no field ")r4rrrr is_valid_field_namerCr5rerrr2rd pydantic_coreValidationErrorfrom_exception_datagetattrrpropertyr?rr3 ValueErrorrArErBadd)rTrirrerrorattrrKrKrL __setattr__s6 (       zBaseModel.__setattr__c Cs||jkrx|j|}t|dr,||dSy |j|=Wqtk rt}ztt|jd||Wdd}~XYqXnt||jkrt ||n\|j dk r||j kr|j |=n>yt ||Wn,tk rtt|jd|YnXdS)N __delete__z object has no attribute ) r5rrrCrrrrr3r __delattr__rA)rTrrrrKrKrLrs"     .  zBaseModel.__delattr__zdict[Any, Any]cCs0|j}|rdd|D}|j|j|j|dS)NcSsi|]\}}|tk r||qSrK)r)rOrPrQrKrKrLrRsz*BaseModel.__getstate__..)rErArBrC)rCrSrErArB)rTprivaterKrKrL __getstate__szBaseModel.__getstate__)staterHcCsDt|d|dt|d|dt|d|dt|d|ddS)NrErBrArC)re)rTrrKrKrL __setstate__szBaseModel.__setstate__)otherrHcCs^t|trV|jdp|j}|jdp(|j}||koT|j|jkoT|j|jkoT|j|jkStSdS)Nr)rr.r:rrErCrANotImplemented)rTr self_typeZ other_typerKrKrL__eq__s    zBaseModel.__eq__zUnpack[ConfigDict])rcKsdS)aThis signature is included purely to help type-checkers check arguments to class declaration, which provides a way to conveniently set model_config key/value pairs. ```py from pydantic import BaseModel class MyModel(BaseModel, extra='allow'): ... ``` However, this may be deceiving, since the _actual_ calls to `__init_subclass__` will not receive any of the config arguments, and will only receive any keyword arguments passed during class initialization that are _not_ expected keys in ConfigDict. (This is due to the way `ModelMetaclass.__new__` works.) Args: **kwargs: Keyword arguments passed to the class definition, which set model_config Note: You may want to override `__pydantic_init_subclass__` instead, which behaves similarly but is called *after* the class is fully initialized. NrK)rXrrKrKrL__init_subclass__,szBaseModel.__init_subclass__TupleGeneratorccs|jEdHdS)zSo `dict(model)` works.N)rErS)rTrKrKrL__iter__CszBaseModel.__iter__cCs|d|ddS)N(z, )) __repr_name__ __repr_str__)rTrKrKrL__repr__GszBaseModel.__repr__z_repr.ReprArgsc#sx6jD](\}}j|}|r |jr ||fVq Wj}|dk r^dd|DEdHfddjDEdHdS)Ncss|]\}}||fVqdS)NrK)rOrPrQrKrKrLrQsz*BaseModel.__repr_args__..c3s&|]\}}|jr|t|fVqdS)N)reprr)rOrPrQ)rTrKrLrRs)rErSr3rdrrArU)rTrPrQrjrrK)rTrL __repr_args__Js  zBaseModel.__repr_args__cCs |dS)N )r)rTrKrKrL__str__ZszBaseModel.__str__zEThe `__fields__` attribute is deprecated, use `model_fields` instead.)categoryzdict[str, FieldInfo]cCstdt|jS)NzEThe `__fields__` attribute is deprecated, use `model_fields` instead.)r{warnDeprecationWarningr3)rTrKrKrL __fields__^s zBaseModel.__fields__zMThe `__fields_set__` attribute is deprecated, use `model_fields_set` instead.cCstdt|jS)NzMThe `__fields_set__` attribute is deprecated, use `model_fields_set` instead.)r{rrrB)rTrKrKrL__fields_set__fszBaseModel.__fields_set__z:The `dict` method is deprecated; use `model_dump` instead.)rtrurvrwrxryztyping.Dict[str, Any])rtrurvrwrxryrHcCs"tdt|j||||||dS)Nz:The `dict` method is deprecated; use `model_dump` instead.)rtrurvrwrxry)r{rrr|)rTrtrurvrwrxryrKrKrLrqs zBaseModel.dictz?The `json` method is deprecated; use `model_dump_json` instead.)rtrurvrwrxryencodermodels_as_dictz"typing.Callable[[Any], Any] | None) rtrurvrwrxryrr dumps_kwargsrHc KsNtdt|tk rtd|tk r,td| r8td|j||||||dS)Nz?The `json` method is deprecated; use `model_dump_json` instead.zMThe `encoder` argument is no longer supported; use field serializers instead.zUThe `models_as_dict` argument is no longer supported; use a model serializer instead.z9`dumps_kwargs` keyword arguments are no longer supported.)rtrurvrwrxry)r{rrrrr) rTrtrurvrwrxryrrrrKrKrLjsons zBaseModel.jsonzCThe `parse_obj` method is deprecated; use `model_validate` instead.)rXrrHcCstdt||S)NzCThe `parse_obj` method is deprecated; use `model_validate` instead.)r{rrr)rXrrKrKrL parse_objs zBaseModel.parse_objzThe `parse_raw` method is deprecated; if your data is JSON use `model_validate_json`, otherwise load the data then use `model_validate` instead.utf8) content_typeencodingproto allow_picklez str | bytesz str | Nonez!_deprecated_parse.Protocol | None)rXbrrrrrHc Cstdtytj|||||d}Wnttfk r}zlddl}t|t rRd} n&t||j rdd} nt|trtd} nd} t | t |d|d } t j|j| gWdd}~XYnX||S) NzThe `parse_raw` method is deprecated; if your data is JSON use `model_validate_json`, otherwise load the data then use `model_validate` instead.)rrrrrzvalue_error.unicodedecodezvalue_error.jsondecodeZ value_errorZ type_error)Z__root__)rrr)r{rr_deprecated_parseZload_str_bytesrrrrUnicodeDecodeErrorJSONDecodeErrorrZPydanticCustomErrorr~rrrr) rXrrrrrrrrZtype_strrrKrKrL parse_raws0    $zBaseModel.parse_rawzThe `parse_file` method is deprecated; load the data from file, then if your data is JSON use `model_validate_json`, otherwise `model_validate` instead.z str | Path)rXpathrrrrrHcCs*tdttj|||||d}||S)NzThe `parse_file` method is deprecated; load the data from file, then if your data is JSON use `model_validate_json` otherwise `model_validate` instead.)rrrr)r{rrrZ load_filer)rXrrrrrrrKrKrL parse_fileszBaseModel.parse_filezqThe `from_orm` method is deprecated; set `model_config['from_attributes']=True` and use `model_validate` instead.cCs0tdt|jdds&tddd||S)NzqThe `from_orm` method is deprecated; set `model_config["from_attributes"]=True` and use `model_validate` instead.rzHYou must set the config attribute `from_attributes=True` to use from_orm)rD)r{rrr2rdrr)rXrrKrKrLfrom_orms zBaseModel.from_ormzDThe `construct` method is deprecated; use `model_construct` instead.cKs tdt|jfd|i|S)NzDThe `construct` method is deprecated; use `model_construct` instead.rY)r{rrrk)rXrYrZrKrKrL constructs zBaseModel.constructz8The copy method is deprecated; use `model_copy` instead.)rtrurcrlz+AbstractSetIntStr | MappingIntStrAny | Noneztyping.Dict[str, Any] | None)rTrtrurcrlrHc Cstdtttj|dd||ddf|p*i}|jdkr>d}ndd|jD}|jdkrbd}nZ|j }x$t |jD]}||krx| |qxWx(t |D]}||jkr| |||<qW|r|j | B} n t|j } |r| t|8} tj||| |||dS)aReturns a copy of the model. This method is now deprecated; use `model_copy` instead. If you need `include` or `exclude`, use: ```py data = self.model_dump(include=include, exclude=exclude, round_trip=True) data = {**data, **(update or {})} copied = self.model_validate(data) ``` Args: include: Optional set or mapping specifying which fields to include in the copied model. exclude: Optional set or mapping specifying which fields to exclude in the copied model. update: Optional dictionary of field-value pairs to override field values in the copied model. deep: If True, the values of fields that are Pydantic models will be deep copied. Returns: A copy of the model with included, excluded and updated fields as specified. zThe `copy` method is deprecated; use `model_copy` instead. See the docstring of `BaseModel.copy` for details about how to handle `include` and `exclude`.F)Zto_dictrvrtrurwNcSsi|]\}}|tk r||qSrK)r)rOrPrQrKrKrLrRJsz"BaseModel.copy..)rl)r{rrr_deprecated_copy_internals_iterrCrSrArlistr_rBrbra_copy_and_set_values) rTrtrurcrlrZrr[rPZ fields_setrKrKrLrs2!       zBaseModel.copyzCThe `schema` method is deprecated; use `model_json_schema` instead.)rvrrHcCstdt|j||dS)NzCThe `schema` method is deprecated; use `model_json_schema` instead.)rvr)r{rrr!)rXrvrrKrKrLschemacs zBaseModel.schemazWThe `schema_json` method is deprecated; use `model_json_schema` and json.dumps instead.)rvr)rvrrrHcKs@ddl}tdtddlm}|j|j||dfd|i|S)NrzWThe `schema_json` method is deprecated; use `model_json_schema` and json.dumps instead.r)pydantic_encoder)rvrdefault)rr{rrZdeprecated.jsonr dumpsr!)rXrvrrrr rKrKrL schema_jsonms zBaseModel.schema_jsonzBThe `validate` method is deprecated; use `model_validate` instead.)rXrrHcCstdt||S)NzBThe `validate` method is deprecated; use `model_validate` instead.)r{rrr)rXrrKrKrLvalidates zBaseModel.validatezLThe `update_forward_refs` method is deprecated; use `model_rebuild` instead.)localnsrHcKs(tdt|rtd|jdddS)NzLThe `update_forward_refs` method is deprecated; use `model_rebuild` instead.z,`localns` arguments are not longer accepted.T)r)r{rrrr)rXrrKrKrLupdate_forward_refss zBaseModel.update_forward_refszHThe private method `_iter` will be removed and should no longer be used.)rrrHcOstdttj|f||S)NzHThe private method `_iter` will be removed and should no longer be used.)r{rrrr )rTrrrKrKrLr s zBaseModel._iterzWThe private method `_copy_and_set_values` will be removed and should no longer be used.cOstdttj|f||S)NzXThe private method `_copy_and_set_values` will be removed and should no longer be used.)r{rrrr )rTrrrKrKrLr szBaseModel._copy_and_set_valueszMThe private method `_get_value` will be removed and should no longer be used.cOstdttj|f||S)NzNThe private method `_get_value` will be removed and should no longer be used.)r{rrr _get_value)rXrrrKrKrLrszBaseModel._get_valuezRThe private method `_calculate_keys` will be removed and should no longer be used.cOstdttj|f||S)NzRThe private method `_calculate_keys` will be removed and should no longer be used.)r{rrr_calculate_keys)rTrrrKrKrLrszBaseModel._calculate_keys)N)N)N)Xr __module__ __qualname____doc__r TYPE_CHECKING__annotations___FieldrArBrCr3r ZDecoratorInfosr9rZ MockValidatorr? __slots__rr2r7r=rMZ__pydantic_base_init__rrUrVrW classmethodrkrqr|rrrr!rrfrrrrrrrrornrrrrrrrrrrrZRepresentationrrZ __pretty__Z __rich_repr__rtyping_extensions deprecatedr"rrrrrrrrrrrr rrrr r rr __classcell__rKrK)rrLr.=sn     1&&&!' @'  " ($&$ @   ) metaclass) __config____base__r__validators____cls_kwargs__r~zConfigDict | NonerFz dict[str, AnyClassMethod] | Nonezdict[str, Any] | Nonerztype[BaseModel]) __model_namer"r#rr$r%field_definitionsrHcKsdS)NrK)r&r"r#rr$r%r'rKrKrLr1s r1)r"rr$r%z%type[Model] | tuple[type[Model], ...]z type[Model]cKsdS)NrK)r&r"r#rr$r%r'rKrKrLr1s )r"r#rr$r%rz,type[Model] | tuple[type[Model], ...] | Noneztuple[str, ...] | None) r&r"r#rr$r%rr'rHc Ks|dk rtdt|dk rB|dk r0tdddt|tsV|f}nttjdt f}|p\i}i}i} x| D]\} } t | std| dtt| trtd | } y | \} } Wqt k r}ztd d d|Wdd}~XYqXn d| } } | r| | | <| || <qpW| |d }|r*|||||rJt|j|d <t|}tj|||d\}}}||k r|||d<||||||fddi|S)aDynamically creates and returns a new Pydantic model. Args: __model_name: The name of the newly created model. __config__: The configuration of the new model. __base__: The base class for the new model. __module__: The name of the module that the model belongs to. __validators__: A dictionary of methods that validate fields. __cls_kwargs__: A dictionary of keyword arguments for class creation. __slots__: Deprecated. Should not be passed to `create_model`. **field_definitions: Attributes of the new model. They should be passed in the format: `=(, )` or `=`. For more complex cases, they can be passed in the format: `=` or `=(, )`. Returns: The newly created model. Raises: PydanticUserError: If `__base__` and `__config__` are both passed. Nz.__slots__ should not be passed to create_modelzFto avoid confusion `__config__` and `__base__` cannot be used togetherzcreate-model-config-base)rDr-z3fields may not start with an underscore, ignoring "rztuple[str, Any]z4Field definitions should be a `(, )`.zcreate-model-field-definitions)rrr2)kwds__orig_bases__Z#__pydantic_reset_parent_namespace__F)r{rRuntimeWarningrrrrcastTyper.rSr rrrcr rZ config_dicttypes resolve_bases prepare_class)r&r"r#rr$r%rr'fieldsrf_nameZf_defZ f_annotationZf_valuee namespaceresolved_basesmetansr(rKrKrLr1sR               )Tr __future__rZ _annotationsr-rr{rrrrrrr _internalr r r r r rrrrrrZ _migrationrconfigrrrrrrerrorsrrr0rrrZ json_schemarrrr r!r"rinspectr#pathlibr$r%r&r'r(r)Z_internal._utilsr*r+r,rrZAnyClassMethod GeneratorTupler~rTypeVarr-r0rr__all__Zobject_setattrreZModelMetaclassr.overloadrr1rrKrKrKrLsx  4         $$ $M