a Df2 @sUdZddlmZddlZddlZddlZddlZddlZddl m Z m Z ddlm Z m Z m Z mZmZmZmZmZmZddlZddlZddlmZddlmZdd lmZmZmZmZmZmZmZm Z m!Z!m"Z"dd l#m$Z$dd l%m&Z&m'Z'dd l(m)Z)m*Z*dd l+m,Z,ddl-m.Z.m/Z/ddl0m1Z1m2Z2m3Z3m4Z4m5Z5ddlm6Z6edddZ7eee8e fddfZ9eee:ee8e e:e fe e8e fdfZ;dem?Z?ddl@mAZAddlmBZBmCZCmDZDddlmEZEddlFmGZGmHZHddlImJZKddlLmMZMmNZNmOZOddlLmPZQne6ZRdZSejTZUGdddejVd ZWejXdddeYddd!d"d#d$d%d"d&d'd(d)d* d+d,ZZejXddeYddd-d"d#d$d.d"d&d'd(d/d* d0d,ZZdddddddd1d"d#d$d2d$d&d'd3d(d/d4 d5d,ZZe$eYZ[dS)6zLogic for creating models.) annotationsN)copydeepcopy) AnyClassVarDict GeneratorLiteralSetTupleTypeVarUnionPydanticUndefined) TypeAlias) _config _decorators_fields _forward_ref _generics _mock_val_ser_model_construction_repr _typing_extra_utils)getattr_migration) AliasChoices AliasPath)GetCoreSchemaHandlerGetJsonSchemaHandler) ConfigDict)PydanticUndefinedAnnotationPydanticUserError)DEFAULT_REF_TEMPLATEGenerateJsonSchemaJsonSchemaModeJsonSchemaValuemodel_json_schema)PydanticDeprecatedSince20Model BaseModel)boundrIncEx) Signature)Path) CoreSchemaSchemaSerializerSchemaValidator)Unpack)AbstractSetIntStrMappingIntStrAny)Protocol)ComputedFieldInfo FieldInfoModelPrivateAttr)Field)r+ create_modelcs8eZdZUdZejrded<ded<ded<ded <d ed <d ed <ded<ded<ded<ded<ded<ded<ded<ded<ded<ded<ed d!Zd"ed#<ed d!Z d$ed%<ed d!Z d"ed&<n4iZ iZ e Zd'Zejd(d)d*d+Zejd(d,d*d+Zd-ZeZd Zd Zd.d/d0d1d2Zd3e_ed"d4d5d6Zed$d4d7d8Zedd9d:d.d;d<d=d>Z d'd d?d;d"d@d;dAdBdCZ!dDd'd'd'd d d d d d3d dE dFdGdGd"d@d@d@d@d@dHd@dIdJ dKdLZ"d'd'd'd'd d d d d d3d dM dNdGdGd"d@d@d@d@d@dHd@dOdP dQdRZ#ed3e$e%dSfd@dOdTdUdIdVdWdXZ&edYdOdZd[d\Z'd.d/d]d^d_Z(ed d3d`d'dad@d@dbd"dcdddedfZ)ed'd'd'dgd9d.dcdcd"d;dhdidjZ*ed'd'dkd9dldcd"d;dmdndoZ+ed'd'dkd9d.dcd"d;dpdqdrZ,edsdtdudvdwdxZ-edudydzd{d|d}Z.ed.d/d~ddZ/dddddZ0d;d;dddZ1dd;dd;dddZ2ejsdOd.dfdd Z3dOd.d/dddZ4dOd.dddZ5dOd.d/dddZ6dd4ddZ7dd/dddZ8ejsd.d@dddZ9ejrddddZ:dd4ddZ;dOd4ddZj?j@Z@e>j?jAZAe>j?jBZBe>j?jCZCdOd4ddZDeeEjFdd'ddd4ddZGeeEjFdd'dd$d4ddZHeEjFdd'dd'd'd d d d ddGdGd@d@d@d@ddddZIeEjFdd'dd'd'd d d d eJeJddGdGd@d@d@d@dd@d.dOd ddZKeeEjFdd'dd9d.d;dÜddńZLeeEjFdd'dd'dd'd dȜd9dddOdd@d;d̜dd΄ZMeeEjFdd'dd'dd'd dȜd9dddOdd@d;dќddӄZNeeEjFdd'dd9d.d;dÜddքZOeeEjFdd'ddd9d:d.d;d<ddلZPeEjFdd'dd'd'd'd dۜd;dddd@d;dޜddZQeeEjFdd'dd3e$fd@dOddddZReeEjFdd'dd3e$dd@dOd.dOdddZSeeEjFdd'dd9d.d;dddZTeeEjFdd'dd.d/dddZUeEjFdd'dd.d.d.dddZVeEjFdd'dd.d.d.dddZWeeEjFdd'dd.d.d.dddZXeEjFdd'dd.d.d.dddZYZZS(r+a}Usage docs: https://docs.pydantic.dev/2.7/concepts/models/ A base class for creating Pydantic models. Attributes: __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 set. __pydantic_private__: Instance attribute with the values of private attributes set on the model instance. zClassVar[ConfigDict] model_configzClassVar[dict[str, FieldInfo]] model_fieldsz&ClassVar[dict[str, ComputedFieldInfo]]model_computed_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)initdict[str, Any] | None__pydantic_extra__zset[str]__pydantic_fields_set____pydantic_private__NzXPydantic models should inherit from BaseModel, BaseModel cannot be instantiated directlyZ validatorzbase-model-instantiated)Z val_or_sercode serializer)__dict__rNrMrOrNone)datareturncKsd}|jj||ddS)a/Create a new model by parsing and validating input data from keyword arguments. Raises [`ValidationError`][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model. `self` is explicitly positional-only to allow `self` as a field name. T)Z self_instanceNrJZvalidate_python)selfrT__tracebackhide__rYZ/nfs/NAS7/SABIOD/METHODE/ermites/ermites_venv/lib/python3.9/site-packages/pydantic/main.py__init__s zBaseModel.__init__T)rUcCs|jS)zGet extra fields set during validation. Returns: A dictionary of extra fields, or `None` if `config.extra` is not set to `"allow"`. )rMrWrYrYrZ model_extraszBaseModel.model_extracCs|jS)zReturns the set of fields that have been explicitly 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. )rNr\rYrYrZmodel_fields_setszBaseModel.model_fields_set type[Model]zset[str] | Noner*)cls _fields_setvaluesrUcKs||}i}t}|jD]\}}|jdurV|j|vrV||j||<||||vr|jdurt|jt r||jj n|jg}|D]f} t| t r| |vr|| ||<||qqt| t r| |} | tur| ||<||qq||vr||vr||||<||q|s|jdd||<q|durD|}|jddkrhdd|Dnd} t|d|t|d ||jst|d | |jr|dt|d r|jdur|D] \} } | |jvr| |j| <qn|jst|d d|S) a_Creates 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. !!! note `model_construct()` generally respects the `model_config.extra` setting on the provided model. That is, if `model_config.extra == 'allow'`, then all extra passed values are added to the model instance's `__dict__` and `__pydantic_extra__` fields. If `model_config.extra == 'ignore'` (the default), then all extra passed values are ignored. Because no validation is performed with a call to `model_construct()`, having `model_config.extra == 'forbid'` does not result in an error if extra values are passed, but they will be ignored. 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. NT)Zcall_default_factoryextraallowcSsi|]\}}||qSrYrY.0kvrYrYrZ z-BaseModel.model_construct..rRrNrMrO)__new__setr=itemsaliaspopaddZvalidation_alias isinstancerchoicesstrrZsearch_dict_for_pathrZ is_required get_defaultr<get_object_setattrrHrGmodel_post_inithasattrrOr@)r`rarbmZ fields_values fields_setnamefieldZvalidation_aliasesrnvalueZ_extrargrhrYrYrZmodel_constructs\          &      zBaseModel.model_construct)updatedeepbool)rWrrrUcCs|r |n|}|r|jddkrl|D]8\}}||jvrN||j|<q0|jdur^i|_||j|<q0n |j||j | |S)aUsage docs: https://docs.pydantic.dev/2.7/concepts/serialization/#model_copy Returns 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. rcrdN) __deepcopy____copy__r<rurmr=rRrMrrNkeys)rWrrcopiedrgrhrYrYrZ model_copys     zBaseModel.model_copypython) modeincludeexcludecontextby_alias exclude_unsetexclude_defaults exclude_none round_tripwarningsserialize_as_anyzLiteral['json', 'python'] | strr-z'bool | Literal['none', 'warn', 'error']zdict[str, Any]) rrrrrrrrrrrrUc Cs$|jj|||||||||| | | d S)aUsage docs: https://docs.pydantic.dev/2.7/concepts/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 output will only contain JSON serializable types. If mode is 'python', the output may contain non-JSON-serializable Python objects. include: A set of fields to include in the output. exclude: A set of fields to exclude from the output. context: Additional context to pass to the serializer. by_alias: Whether to use the field's alias in the dictionary key if defined. exclude_unset: Whether to exclude fields that have not been explicitly set. exclude_defaults: Whether to exclude fields that are set to their default value. exclude_none: Whether to exclude fields that have a value of `None`. round_trip: If True, dumped values should be valid as input for non-idempotent types such as Json[T]. warnings: How to handle serialization errors. False/"none" ignores them, True/"warn" logs errors, "error" raises a [`PydanticSerializationError`][pydantic_core.PydanticSerializationError]. serialize_as_any: Whether to serialize fields with duck-typing serialization behavior. Returns: A dictionary representation of the model. ) rrrrrrrrrrr)rIZ to_python) rWrrrrrrrrrrrrYrYrZ model_dump5s&zBaseModel.model_dump indentrrrrrrrrrrz int | Noners) rrrrrrrrrrrrUc Cs(|jj|||||||||| | | d S)a-Usage docs: https://docs.pydantic.dev/2.7/concepts/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. exclude: Field(s) to exclude from the JSON output. context: Additional context to pass to the serializer. 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 are set to their default value. exclude_none: Whether to exclude fields that have a value of `None`. round_trip: If True, dumped values should be valid as input for non-idempotent types such as Json[T]. warnings: How to handle serialization errors. False/"none" ignores them, True/"warn" logs errors, "error" raises a [`PydanticSerializationError`][pydantic_core.PydanticSerializationError]. serialize_as_any: Whether to serialize fields with duck-typing serialization behavior. Returns: A JSON string representation of the model. r)rIto_jsondecode) rWrrrrrrrrrrrrYrYrZmodel_dump_jsonjs$zBaseModel.model_dump_jsonZ validationztype[GenerateJsonSchema]r&)r ref_templateschema_generatorrrUcCst|||||dS)aGenerates a JSON schema for a model class. Args: by_alias: Whether to use attribute aliases or not. ref_template: The reference template. schema_generator: To override the logic used to generate the JSON schema, as a subclass of `GenerateJsonSchema` with your desired modifications mode: The mode in which to generate the schema. Returns: The JSON schema for the given model class. )rrrr)r()r`rrrrrYrYrZr(s zBaseModel.model_json_schemaztuple[type[Any], ...])paramsrUcCs>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|qSrY)rqrsrZdisplay_as_typerfparamrYrYrZ rjz5BaseModel.model_parametrized_name.., []) issubclasstypingGeneric TypeErrorjoin__name__)r`rZ param_namesZparams_componentrYrYrZmodel_parametrized_names   z!BaseModel.model_parametrized_name)_BaseModel__contextrUcCsdS)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. NrY)rWrrYrYrZrwszBaseModel.model_post_init)force raise_errors_parent_namespace_depth_types_namespaceintz bool | None)rrrrrUc Cs|s|jrdSd|jvr"t|d|dur4|}nZ|dkrvtj|dpJi}t|jpZi}i||}t ||_n t|j}t ||}i|j ddi}tj ||j tj|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`. NrCr)Z parent_depthZ defer_buildF)check)rtypes_namespace)rBrRdelattrrrZparent_frame_namespacerZunpack_lenient_weakvaluedictrFZbuild_lenient_weakvaluedictZget_cls_types_namespacer<Zcomplete_model_classrr ConfigWrapper) r`rrrrrZframe_parent_nsZ cls_parent_nsconfigrYrYrZ model_rebuilds0       zBaseModel.model_rebuildstrictfrom_attributesr)r`objrrrrUcCsd}|jj||||dS)aValidate a pydantic model instance. Args: obj: The object to validate. strict: Whether to enforce types strictly. 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. TrrV)r`rrrrrXrYrYrZmodel_validateszBaseModel.model_validaterrzstr | bytes | bytearray)r` json_datarrrUcCsd}|jj|||dS)aUsage docs: https://docs.pydantic.dev/2.7/concepts/json/#json-parsing Validate 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. Tr)rJZ validate_json)r`rrrrXrYrYrZmodel_validate_json+szBaseModel.model_validate_json)r`rrrrUcCsd}|jj|||dS)aRValidate the given object contains string data against the Pydantic model. Args: obj: The object contains string data to validate. strict: Whether to enforce types strictly. context: Extra variables to pass to the validator. Returns: The validated Pydantic model. Tr)rJZvalidate_strings)r`rrrrXrYrYrZmodel_validate_stringsFsz BaseModel.model_validate_stringstype[BaseModel]rr0)sourcehandlerrUcCs"d|jvr|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`. rCorigin)rRrErC)r`rrrYrYrZ__get_pydantic_core_schema__\s  z&BaseModel.__get_pydantic_core_schema__r r') core_schemarrUcCs||S)a_Hook 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. rY)r`rrrYrYrZ__get_pydantic_json_schema__tsz&BaseModel.__get_pydantic_json_schema__)kwargsrUcKsdS)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. NrYr`rrYrYrZ__pydantic_init_subclass__sz$BaseModel.__pydantic_init_subclass__z!type[Any] | tuple[type[Any], ...]z3type[BaseModel] | _forward_ref.PydanticRecursiveRef)typevar_valuesrUc st||}|dur|S|tur(tdt|ds@t|d|jdsdtj|jvrdt|dt |t st|f}t ||t t |jd|trˆr|}t|||n|jd}|s|}nt fdd|D}|jd p|}||}t d d tD}t||} | durJ| WdSt||||}|durv|WdSz|jd d WntyYn0t||||}t|||||Wdn1s0Y|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|VqdSN)rZ replace_types)rfargZ typevars_maprYrZ rjz.BaseModel.__class_getitem__..rcSsi|] }|dqSrrYrrYrYrZrirjz/BaseModel.__class_getitem__..)r)rZget_cached_generic_type_earlyr+rrxrErr __bases__rqtupleZcheck_parameters_countdictziprZ all_identicalrrbZset_cached_generic_typerZiter_contained_typevarsZgeneric_recursion_self_typeZget_cached_generic_type_laterr"Zcreate_generic_submodel) r`rcachedZsubmodelZ parent_argsrrZ model_namerZmaybe_self_typerYrrZ__class_getitem__sP        2zBaseModel.__class_getitem__)rWrUcCst|}||}t|dt|jt|dt|jt|dt|jt|dr\|jdurjt|ddnt|ddd|j D|S)z$Returns a shallow copy of the model.rRrMrNrONcSsi|]\}}|tur||qSrYrrerYrYrZrirjz&BaseModel.__copy__..) typerkrvrrRrMrNrxrOrm)rWr`ryrYrYrZrs zBaseModel.__copy__zdict[int, Any] | None)rWmemorUcCst|}||}t|dt|j|dt|dt|j|dt|dt|jt|drd|j durrt|ddn$t|dtdd|j D|d|S) z!Returns a deep copy of the model.rR)rrMrNrONcSsi|]\}}|tur||qSrYrrerYrYrZrirjz*BaseModel.__deepcopy__..) rrkrvrrRrMrrNrxrOrm)rWrr`ryrYrYrZrs zBaseModel.__deepcopy__)itemrUc s6t|d}||vr||}t|dr6||t|Sz |j|WSty}z&tt|jd||WYd}~n d}~00nzt|d}Wntyd}Yn0|rz ||WSty}z&tt|jd||WYd}~n d}~00n2t|j |rt |Stt|jd|dS)Nr@__get__ object has no attribute rM) object__getattribute__rxrrrOKeyErrorAttributeErrorr __class__super)rWrZprivate_attributes attributeexcpydantic_extrarrYrZ __getattr__ s*   2   2 zBaseModel.__getattr__)r{r}rUc Cs||jvr4t|d|jjd|jjd|dn\t|s|jdusR||jvr`t|||n,|j|}t |dr| ||n ||j|<dS| ||t |j|d}t |tr| ||n|jddr|j|||n|jddkr||jvrtd |jjd |d n|jddkr||jvr|jrZ||jvrZ||j|<n:zt ||Wnty||j|<Yn0t|||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__validate_assignmentrcrd"z" object has no field ")r?rrrris_valid_field_namerOr@rvrxr _check_frozengetattrrqpropertyr<rurJrr= ValueErrorr]rMrRrNrp)rWr{r}rattrrYrYrZ __setattr__-sD         zBaseModel.__setattr__c Cs||jvrz|j|}t|dr,||dSz|j|=WdStyx}z&tt|jd||WYd}~n d}~00||d||j vrt ||nZ|j dur||j vr|j |=n.)rRrMrNrO)rOrmrRrMrN)rWprivaterYrYrZ __getstate__szBaseModel.__getstate__)staterUcCsDt|d|dt|d|dt|d|dt|d|ddS)NrNrMrOrR)rv)rWrrYrYrZ __setstate__szBaseModel.__setstate__)otherrUcCst|tr|jdp|j}|jdp*|j}||krXt|ddt|ddkrX|j|jks\dS|j|jkrldSt|j }|j |kr|j |krdS|rt j |ndd}z||j||jkWSt yt |j}t |j}||||kYS0ntSdS)NrrOFTcSstjSr)rZ _SENTINEL_rYrYrZrjz"BaseModel.__eq__..)rqr+rErrrMrRrr=roperator itemgetterrrZSafeGetItemProxyNotImplemented)rWr self_typeZ other_typer=getterZself_fields_proxyZother_fields_proxyrYrYrZ__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. NrYrrYrYrZ__init_subclass__szBaseModel.__init_subclass__TupleGeneratorccs6dd|jDEdH|j}|r2|EdHdS)zSo `dict(model)` works.cSs"g|]\}}|ds||fqSr) startswithrerYrYrZrrjz&BaseModel.__iter__..N)rRrmrM)rWrcrYrYrZ__iter__szBaseModel.__iter__cCs|d|ddS)N(r)) __repr_name__ __repr_str__r\rYrYrZ__repr__szBaseModel.__repr__z_repr.ReprArgsc#sjD](\}}j|}|r |jr ||fVq ztd}WntyZd}Yn0|dur|dd|DEdHfddjDEdHdS)NrMcss|]\}}||fVqdSrrYrerYrYrZrrjz*BaseModel.__repr_args__..c3s&|]\}}|jr|t|fVqdSr)reprrrer\rYrZrrj) rRrmr=rurrrrr>)rWrgrhr|rrYr\rZ __repr_args__s     zBaseModel.__repr_args__cCs |dS)N )rr\rYrYrZ__str__ szBaseModel.__str__EThe `__fields__` attribute is deprecated, use `model_fields` instead.categoryzdict[str, FieldInfo]cCstjdtd|jS)Nrr)rwarnr)r=r\rYrYrZ __fields__ szBaseModel.__fields__MThe `__fields_set__` attribute is deprecated, use `model_fields_set` instead.cCstjdtd|jS)Nrr)rrr)rNr\rYrYrZ__fields_set__s zBaseModel.__fields_set__:The `dict` method is deprecated; use `model_dump` instead.rrrrrrztyping.Dict[str, Any])rrrrrrrUcCs$tjdtd|j||||||dS)Nr rr!)rrr)r)rWrrrrrrrYrYrZr#s zBaseModel.dict?The `json` method is deprecated; use `model_dump_json` instead.)rrrrrrencodermodels_as_dictz"typing.Callable[[Any], Any] | None) rrrrrrr#r$ dumps_kwargsrUc KsPtjdtd|turtd|tur.td| r:td|j||||||dS)Nr"rzMThe `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.r!)rrr)rrr) rWrrrrrrr#r$r%rYrYrZjson8s"zBaseModel.jsonCThe `parse_obj` method is deprecated; use `model_validate` instead.)r`rrUcCstjdtd||S)Nr'rrrr)rr`rrYrYrZ parse_objXszBaseModel.parse_objThe `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 | bytes str | NonezDeprecatedParseProtocol | None)r`br-r.r/r0rUc Cstjdtdddlm}z|j|||||d}Wnttfy}ztddl} t |t r^d} n&t || j rpd} nt |trd } nd } t | t|d |d } t j|j| gWYd}~n d}~00||S) Nr+rrparser/r-r.r0rzvalue_error.unicodedecodezvalue_error.jsondecodeZ value_errorZ type_error)Z__root__r)rrr) deprecatedr4Zload_str_bytesrrr&rqUnicodeDecodeErrorJSONDecodeErrorrZPydanticCustomErrorrsrrrr) r`r2r-r.r/r0r4rrr&Ztype_strrrYrYrZ parse_raw`s8     (zBaseModel.parse_rawThe `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)r`pathr-r.r/r0rUcCs8tjdtdddlm}|j|||||d}||S)Nr:rrr3r5)rrr)r6r4Z load_filer*)r`r;r-r.r/r0r4rrYrYrZ parse_files zBaseModel.parse_fileqThe `from_orm` method is deprecated; set `model_config['from_attributes']=True` and use `model_validate` instead.cCs2tjdtd|jdds(tddd||S)Nr=rrzHYou must set the config attribute `from_attributes=True` to use from_ormrP)rrr)r<rur#rr)rYrYrZfrom_ormszBaseModel.from_ormDThe `construct` method is deprecated; use `model_construct` instead.cKs"tjdtd|jfd|i|S)Nr@rra)rrr)r~)r`rarbrYrYrZ constructszBaseModel.constructThe `copy` method is deprecated; use `model_copy` instead. See the docstring of `BaseModel.copy` for details about how to handle `include` and `exclude`.)rrrrz+AbstractSetIntStr | MappingIntStrAny | Noneztyping.Dict[str, Any] | None)rWrrrrrUc Cs tjdtdddlm}t|j|dd||ddfi|p:i}|jdurPd}ndd |jD}|j durtd}nR|j }t |j D]} | |vr| | qt |D]} | |j vr| | || <q|r|j |B} n t|j } |r| t|8} |j||| |||d S) aReturns a copy of the model. !!! warning "Deprecated" 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. rBrrcopy_internalsF)to_dictrrrrNcSsi|]\}}|tur||qSrYrrerYrYrZrirjz"BaseModel.copy..)r)rrr)r6rDr_iterrOrmrMrlistrorNrrl_copy_and_set_values) rWrrrrrDrbrrcrgrzrYrYrZrs<#          zBaseModel.copyCThe `schema` method is deprecated; use `model_json_schema` instead.)rrrUcCstjdtd|j||dS)NrIrrr)rrr)r()r`rrrYrYrZschemaszBaseModel.schemaWThe `schema_json` method is deprecated; use `model_json_schema` and json.dumps instead.rJ)rrr%rUcKsBtjdtdddl}ddlm}|j|j||dfd|i|S)NrLrrr)pydantic_encoderrJdefault)rrr)r&Zdeprecated.jsonrMdumpsr()r`rrr%r&rMrYrYrZ schema_json$s  zBaseModel.schema_jsonBThe `validate` method is deprecated; use `model_validate` instead.)r`r}rUcCstjdtd||S)NrQrr()r`r}rYrYrZvalidate:szBaseModel.validateLThe `update_forward_refs` method is deprecated; use `model_rebuild` instead.)localnsrUcKs*tjdtd|rtd|jdddS)NrSrz,`localns` arguments are not longer accepted.T)r)rrr)rr)r`rTrYrYrZupdate_forward_refsBszBaseModel.update_forward_refsHThe private method `_iter` will be removed and should no longer be used.)rrrUcOs2tjdtdddlm}|j|g|Ri|S)NrVrrrC)rrr)r6rDrFrWrrrDrYrYrZrFPs  zBaseModel._iterWThe private method `_copy_and_set_values` will be removed and should no longer be used.cOs2tjdtdddlm}|j|g|Ri|S)NrXrrrC)rrr)r6rDrHrWrYrYrZrH\s  zBaseModel._copy_and_set_valuesMThe private method `_get_value` will be removed and should no longer be used.cOs2tjdtdddlm}|j|g|Ri|S)NrYrrrC)rrr)r6rD _get_value)r`rrrDrYrYrZrZis  zBaseModel._get_valueRThe private method `_calculate_keys` will be removed and should no longer be used.cOs2tjdtdddlm}|j|g|Ri|S)Nr[rrrC)rrr)r6rD_calculate_keysrWrYrYrZr\ws  zBaseModel._calculate_keys)N)N)N)[r __module__ __qualname____doc__r TYPE_CHECKING__annotations___FieldrMrNrOr=r>rZDecoratorInfosrDrFrZ MockValSerrJrI __slots__r!r<rBrHr[Z__pydantic_base_init__rr]r^ classmethodr~rrrr$r%r(rrwrrrrrrrrrrrrrrrrr r rrrrZRepresentationrrZ __pretty__Z __rich_repr__rtyping_extensionsr6rrrrr&r*r9r<r?rArrKrPrRrUrFrHrZr\ __classcell__rYrYrrZr+Bs   P(8(37@ + 7   &  "/ "  G      ) metaclass) __config__r___base__r]__validators____cls_kwargs__rszConfigDict | Noner1rSzdict[str, classmethod] | NonerLrr) __model_namerhr_rir]rjrkfield_definitionsrUcKsdSrrYrlrhr_rir]rjrkrmrYrYrZr;s r;)rhr_r]rjrkz%type[Model] | tuple[type[Model], ...]r_cKsdSrrYrnrYrYrZr;s )rhr_rir]rjrkrcz,type[Model] | tuple[type[Model], ...] | Noneztuple[str, ...] | None) rlrhr_rir]rjrkrcrmrUc Ks|durtdt|durB|dur0tdddt|tsV|f}nttjdt f}|p\i}i} i} | D]\} } t | std| dtt| trtd | } z | \} }Wn2t y}ztd d d|WYd}~n d}~00nLt| r.t| ^} }}d d lm}t||s8tdd dn d| } }| rF| | | <|| | <qn|durntd }|jd}| |d}|r|d|i|r|||| |rt|j|d<t|}tj|||d\}}}||ur||d<||||||fd|d|S)a2Usage docs: https://docs.pydantic.dev/2.7/concepts/models/#dynamic-model-creation Dynamically creates and returns a new Pydantic model, in other words, `create_model` dynamically creates a subclass of [`BaseModel`][pydantic.BaseModel]. Args: __model_name: The name of the newly created model. __config__: The configuration of the new model. __doc__: The docstring of the new model. __base__: The base class or classes for the new model. __module__: The name of the module that the model belongs to; if `None`, the value is taken from `sys._getframe(1)` __validators__: A dictionary of methods that validate fields. __cls_kwargs__: A dictionary of keyword arguments for class creation, such as `metaclass`. __slots__: Deprecated. Should not be passed to `create_model`. **field_definitions: Attributes of the new model. They should be passed in the format: `=(, )`, `=(, )`, or `typing.Annotated[, ]`. Any additional metadata in `typing.Annotated[, , ...]` will be ignored. Returns: The new [model][pydantic.BaseModel]. 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-baser>r*z3fields may not start with an underscore, ignoring "rztuple[str, Any]z4Field definitions should be a `(, )`.zcreate-model-field-definitionsr)r8z, ]r)rar]r_r<)kwds__orig_bases__F)Z#__pydantic_reset_parent_namespace__Z_create_model_module)rrRuntimeWarningr#rqrrcastTyper+rmrrrrZ is_annotatedreget_argsfieldsr8sys _getframe f_globalsrrrZ config_dicttypes resolve_bases prepare_class)rlrhr_rir]rjrkrcrmrurf_nameZf_defZ f_annotationZf_valueerr8f namespaceresolved_basesmetansrorYrYrZr;s%                     )\r_ __future__rZ _annotationsrrvryrrrrrrrrr r r r r rrerr _internalrrrrrrrrrrZ _migrationraliasesrrZannotated_handlersrr rr!errorsr"r#Z json_schemar$r%r&r'r(r)r*rsr rr-rar`inspectr.pathlibr/r0r1r2r3Z_internal._utilsr4r5Zdeprecated.parser6ZDeprecatedParseProtocolrur7r8r9r:rbDeprecationWarning__all__Zobject_setattrrvZModelMetaclassr+overloadrr;rrYrYrYrZs ,  0    2    M$$$u