a
    y{Jh                     @  sz  U d Z ddlmZ ddlZddlZddlZddlZddlmZm	Z	 ddlm
Z
mZ ddlZddlZddlmZ ddlmZmZmZmZmZmZmZmZmZmZ dd	lmZ dd
lmZmZ ddlm Z  ddl!m"Z"m#Z# ddl$m%Z%m&Z&m'Z'm(Z(m)Z) ddlm*Z* ej+rddl,m-Z- ddl.m/Z/ ddlm0Z0m1Z1m2Z2 ddlm3Z3m4Z4 ddl5m6Z6m7Z7 ddl8m9Z: ddl;m<Z<m=Z=m>Z> ddl;m?Z@ ejAejBeCe
f ddf ZDejEdddZFdZGdeHd< ne*ZIdZJejKZLG dd dejMdZNejOdddePddd d!d"d#d$d!d%d&d'd(d)	d*d+ZQejOddePddd,d!d"d#d-d!d%d&d'd.d)	d/d+ZQdddddddd0d!d"d#d1d#d%d&d2d'd.d3
d4d+ZQeePZRdS )5zLogic for creating models.    )annotationsN)copydeepcopy)AnyClassVarPydanticUndefined   )
_config_decorators_fields_forward_ref	_generics_mock_val_ser_model_construction_repr_typing_extra_utils)getattr_migration)GetCoreSchemaHandlerGetJsonSchemaHandler)
ConfigDict)PydanticUndefinedAnnotationPydanticUserError)DEFAULT_REF_TEMPLATEGenerateJsonSchemaJsonSchemaModeJsonSchemaValuemodel_json_schema)PydanticDeprecatedSince20)	Signature)Path)
CoreSchemaSchemaSerializerSchemaValidator)LiteralUnpack)AbstractSetIntStrMappingIntStrAny)Protocol)ComputedFieldInfo	FieldInfoModelPrivateAttr)FieldModel	BaseModel)boundz<set[int] | set[str] | dict[int, Any] | dict[str, Any] | Noneztyping_extensions.TypeAliasIncEx)r/   create_modelc                      s"  e Zd ZU dZejrded< ded< ded< ded	< d
ed< ded< ded< ded< ded< ded< ded< ded< ded< ded< ded< eddZd ed!< eddZ	d"ed#< eddZ
d ed$< n,i Ze Zejd%d&d'd(Zejd%d)d'd(Zd*Ze ZdZdZd+d,d-d.d/Zd0e_ed1d2d3d4Zed d2d5d6Zed"d2d7d8Zedd:d;d+d<d=d>d?Zd9dd@d<d dAd<dBdCdDZ dEd9d9dddddd0dF	dGdHdHdAdAdAdAdAdAdIdJ
dKdLZ!d9d9d9dddddd0dM	dNdHdHdAdAdAdAdAdAdOdP
dQdRZ"ed0e#e$dSfdAdOdTdUdIdVdWdXZ%edYdOdZd[d\Z&d+d,d]d^d_Z'edd0d`d9dadAdAdbd dcdddedfZ(ed9d9d9dgd:d+dcdcd d<dhdidjZ)ed9d9dkd:dldcd d<dmdndoZ*ed9d9dkd:d+dcd d<dpdqdrZ+edsdtdudvdwdxZ,edudydzd{d|d}Z-ed+d,d~ddZ.dddddZ/d<d<dddZ0d d<dd<dddZ1ejsZdOd+d fddZ2dOd+d,dddZ3dOd+dddZ4dOd+d,dddZ5dd2ddZ6dd,dddZ7d+dAdddZ8ejrddddZ9dd2ddZ:dOd2ddZ;dd2ddZ<e=j>j?Z?e=j>j@Z@e=j>jAZAe=j>jBZBdOd2ddZCeeDjEdeFddd2ddZGeeDjEdeFdd"d2ddZHeDjEdeFdd9d9ddddddHdHdAdAdAdAddddZIeDjEdeFdd9d9ddddeJeJddHdHdAdAdAdAddAd+dOd
ddZKeeDjEdeFdd:d+d<dÜddńZLeeDjEdeFdd9dd9ddȜd:dddOddAd<d̜dd΄ZMeeDjEdeFdd9dd9ddȜd:dddOddAd<dќddӄZNeeDjEdeFdd:d+d<dÜddքZOeeDjEdeFddd:d;d+d<d=ddلZPeDjEdeFdd9d9d9ddۜd<ddddAd<dޜddZQeeDjEdeFdd0e#fdAdOddddZReeDjEdeFdd0e#ddAdOd+dOdddZSeeDjEdeFdd:d+d<dddZTeeDjEdeFdd+d,dddZUeDjEdeFdd+d+d+dddZVeDjEdeFdd+d+d+dddZWeeDjEdeFdd+d+d+dddZXeDjEdeFdd+d+d+dddZY  ZZS (  r/   a}  Usage docs: https://docs.pydantic.dev/2.5/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.
    zClassVar[ConfigDict]model_configzClassVar[dict[str, FieldInfo]]model_fieldszClassVar[set[str]]__class_vars__z%ClassVar[dict[str, ModelPrivateAttr]]__private_attributes__zClassVar[Signature]__signature__zClassVar[bool]__pydantic_complete__zClassVar[CoreSchema]__pydantic_core_schema__Z__pydantic_custom_init__z$ClassVar[_decorators.DecoratorInfos]__pydantic_decorators__z+ClassVar[_generics.PydanticGenericMetadata]__pydantic_generic_metadata__zClassVar[dict[str, Any] | None]__pydantic_parent_namespace__z+ClassVar[None | Literal['model_post_init']]__pydantic_post_init____pydantic_root_model__zClassVar[SchemaSerializer]__pydantic_serializer__zClassVar[SchemaValidator]__pydantic_validator__F)initdict[str, Any] | None__pydantic_extra__zset[str]__pydantic_fields_set____pydantic_private__zXPydantic models should inherit from BaseModel, BaseModel cannot be instantiated directly	validatorzbase-model-instantiated)Z
val_or_sercode
serializer)__dict__rD   rC   rE   r   None)datareturnc                 K  s   d}| j j|| d dS )aj  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.

        `__init__` 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@   Zvalidate_python)Z__pydantic_self__rK   __tracebackhide__ rO   ?/var/www/shaz/venv/lib/python3.9/site-packages/pydantic/main.py__init__   s    
zBaseModel.__init__Tzdict[str, ComputedFieldInfo])rL   c                 C  s   dd | j j D S )zGet the computed fields of this model instance.

        Returns:
            A dictionary of computed field names and their corresponding `ComputedFieldInfo` objects.
        c                 S  s   i | ]\}}||j qS rO   )info.0kvrO   rO   rP   
<dictcomp>       z3BaseModel.model_computed_fields.<locals>.<dictcomp>)r:   Zcomputed_fieldsitemsselfrO   rO   rP   model_computed_fields   s    zBaseModel.model_computed_fieldsc                 C  s   | j S )zGet extra fields set during validation.

        Returns:
            A dictionary of extra fields, or `None` if `config.extra` is not set to `"allow"`.
        )rC   rZ   rO   rO   rP   model_extra   s    zBaseModel.model_extrac                 C  s   | j S )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.
        )rD   rZ   rO   rO   rP   model_fields_set   s    zBaseModel.model_fields_setNtype[Model]zset[str] | Noner.   )cls_fields_setvaluesrL   c                 K  s*  |  | }i }i }| j D ]Z\}}|jrF|j|v rF||j||< q||v r^||||< q| s|jdd||< q|du rt| }|	| d}| j
ddkri }| D ]\}	}
|
||	< qn
|	| t|d| t|d| | jst|d| | jr|d n| js&t|d	d |S )
aS  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.
        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)Zcall_default_factoryNextraallowrI   rD   rC   rE   )__new__r4   rY   aliaspopZis_requiredget_defaultsetkeysupdater3   get_object_setattrr>   r=   model_post_init)r`   ra   rb   mZfields_valuesdefaultsnamefieldZ_extrarU   rV   rO   rO   rP   model_construct   s8    


zBaseModel.model_construct)rk   deepbool)r[   rk   rt   rL   c                C  s   |r|   n|  }|r| jddkrl| D ]8\}}|| jv rN||j|< q0|jdu r^i |_||j|< q0n|j| |j	|
  |S )a  Usage docs: https://docs.pydantic.dev/2.5/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.
        rc   rd   N)__deepcopy____copy__r3   rl   rY   r4   rI   rC   rk   rD   rj   )r[   rk   rt   copiedrU   rV   rO   rO   rP   
model_copy   s    

zBaseModel.model_copypython)	modeincludeexcludeby_aliasexclude_unsetexclude_defaultsexclude_none
round_tripwarningszLiteral['json', 'python'] | strr1   zdict[str, Any])
r{   r|   r}   r~   r   r   r   r   r   rL   c       	   
      C  s    | j j| |||||||||	d
S )a  Usage docs: https://docs.pydantic.dev/2.5/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 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 have not been explicitly set.
            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.
        )	r{   r~   r|   r}   r   r   r   r   r   )r?   Z	to_python)
r[   r{   r|   r}   r~   r   r   r   r   r   rO   rO   rP   
model_dump  s    !zBaseModel.model_dump	indentr|   r}   r~   r   r   r   r   r   z
int | Nonestr)
r   r|   r}   r~   r   r   r   r   r   rL   c       	   
      C  s$   | j j| |||||||||	d
 S )aI  Usage docs: https://docs.pydantic.dev/2.5/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. 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   )r?   to_jsondecode)
r[   r   r|   r}   r~   r   r   r   r   r   rO   rO   rP   model_dump_jsonA  s    zBaseModel.model_dump_jsonZ
validationztype[GenerateJsonSchema]r   )r~   ref_templateschema_generatorr{   rL   c                 C  s   t | ||||dS )a  Generates 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.
        )r~   r   r   r{   )r   )r`   r~   r   r   r{   rO   rO   rP   r   m  s    
zBaseModel.model_json_schemaztuple[type[Any], ...])paramsrL   c                 C  s>   t | tjstddd |D }d|}| j d| dS )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.c                 S  s$   g | ]}t |tr|nt|qS rO   )
isinstancer   r   Zdisplay_as_typerT   paramrO   rO   rP   
<listcomp>  rX   z5BaseModel.model_parametrized_name.<locals>.<listcomp>, [])
issubclasstypingGeneric	TypeErrorjoin__name__)r`   r   Zparam_namesZparams_componentrO   rO   rP   model_parametrized_name  s
    
z!BaseModel.model_parametrized_name)_BaseModel__contextrL   c                 C  s   dS )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.
        NrO   )r[   r   rO   rO   rP   rn     s    zBaseModel.model_post_init   )forceraise_errors_parent_namespace_depth_types_namespaceintzbool | None)r   r   r   r   rL   c          	      C  s   |s| j rdS d| jv r"t| d |dur4| }nZ|dkrvtj|dpJi }t| jpZi }i ||}t	|| _nt| j}t
| |}i | jddi}tj| | jtj|dd||dS dS )	a1  Try 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`.
        Nr9   r   )Zparent_depthZdefer_buildF)check)r   types_namespace)r8   rI   delattrr   r   Zparent_frame_namespacer   Zunpack_lenient_weakvaluedictr<   Zbuild_lenient_weakvaluedictZget_cls_types_namespacer3   Zcomplete_model_classr   r
   ConfigWrapper)	r`   r   r   r   r   r   Zframe_parent_nsZcls_parent_nsconfigrO   rO   rP   model_rebuild  s0    



zBaseModel.model_rebuildstrictfrom_attributescontext)r`   objr   r   r   rL   c                C  s   d}| j j||||dS )a  Validate 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.
        Tr   rM   )r`   r   r   r   r   rN   rO   rO   rP   model_validate  s    zBaseModel.model_validater   r   zstr | bytes | bytearray)r`   	json_datar   r   rL   c                C  s   d}| j j|||dS )a  Usage docs: https://docs.pydantic.dev/2.5/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   )r@   Zvalidate_json)r`   r   r   r   rN   rO   rO   rP   model_validate_json  s    zBaseModel.model_validate_json)r`   r   r   r   rL   c                C  s   d}| j j|||dS )aR  Validate 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   )r@   Zvalidate_strings)r`   r   r   r   rN   rO   rO   rP   model_validate_strings  s    z BaseModel.model_validate_stringstype[BaseModel]r   r"   )_BaseModel__source_BaseModel__handlerrL   c                 C  s"   d| j v r| jd s| jS ||S )a  Hook 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`.
        r9   origin)rI   r;   r9   )r`   r   r   rO   rO   rP   __get_pydantic_core_schema__,  s    

z&BaseModel.__get_pydantic_core_schema__r   r   )_BaseModel__core_schemar   rL   c                 C  s   ||S )ac  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.
        rO   )r`   r   r   rO   rO   rP   __get_pydantic_json_schema__D  s    z&BaseModel.__get_pydantic_json_schema__)kwargsrL   c                 K  s   dS )a  This 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.
        NrO   r`   r   rO   rO   rP   __pydantic_init_subclass__]  s    z$BaseModel.__pydantic_init_subclass__z!type[Any] | tuple[type[Any], ...]z3type[BaseModel] | _forward_ref.PydanticRecursiveRef)typevar_valuesrL   c           
   	     s  t | |}|d ur|S | tu r(tdt| ds@t|  d| jd sdtj| jvrdt|  dt	|t
st|f}t | | tt| jd | t    r r| }t | || n| jd }|s|}nt
 fdd|D }| jd	 p| }||}t
d
d t   D }t ||}	|	d urJ|	W  d    S t | |||}|d urv|W  d    S z|jdd W n ty   Y n0 t ||||}t | |||| W d    n1 s0    Y  |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 classargsc                 3  s   | ]}t | V  qd S N)r   Zreplace_types)rT   argZtypevars_maprO   rP   	<genexpr>  rX   z.BaseModel.__class_getitem__.<locals>.<genexpr>r   c                 S  s   i | ]
}|d qS r   rO   r   rO   rO   rP   rW     rX   z/BaseModel.__class_getitem__.<locals>.<dictcomp>   )r   )r   Zget_cached_generic_type_earlyr/   r   hasattrr;   r   r   	__bases__r   tupleZcheck_parameters_countdictzipr   Zall_identicalrj   rb   Zset_cached_generic_typer   Ziter_contained_typevarsZgeneric_recursion_self_typeZget_cached_generic_type_later   r   Zcreate_generic_submodel)
r`   r   cachedZsubmodelZparent_argsr   r   Z
model_namer   Zmaybe_self_typerO   r   rP   __class_getitem__p  sP    





2zBaseModel.__class_getitem__)r[   rL   c                 C  s   t | }||}t|dt| j t|dt| j t|dt| j | jdu r`t|dd nt|ddd | j D  |S )z$Returns a shallow copy of the model.rI   rC   rD   NrE   c                 S  s   i | ]\}}|t ur||qS rO   r   rS   rO   rO   rP   rW     rX   z&BaseModel.__copy__.<locals>.<dictcomp>)	typere   rm   r   rI   rC   rD   rE   rY   )r[   r`   ro   rO   rO   rP   rw     s    

zBaseModel.__copy__zdict[int, Any] | None)r[   memorL   c                 C  s   t | }||}t|dt| j|d t|dt| j|d t|dt| j | jdu rht|dd n$t|dtdd | j	 D |d |S )	z!Returns a deep copy of the model.rI   )r   rC   rD   NrE   c                 S  s   i | ]\}}|t ur||qS rO   r   rS   rO   rO   rP   rW     rX   z*BaseModel.__deepcopy__.<locals>.<dictcomp>)
r   re   rm   r   rI   rC   r   rD   rE   rY   )r[   r   r`   ro   rO   rO   rP   rv     s    

zBaseModel.__deepcopy__)itemrL   c              
     s:  t | d}||v r|| }t|dr6|| t| S z| j| W S  ty } z&tt| jd||W Y d }~n
d }~0 0 nzt | d}W n ty   d }Y n0 |d urz
|| W S  ty  } z&tt| jd||W Y d }~n
d }~0 0 n2t| j	|rt
 |S tt| jd|d S )Nr6   __get__ object has no attribute rC   )object__getattribute__r   r   r   rE   KeyErrorAttributeErrorr   	__class__super)r[   r   Zprivate_attributes	attributeexcpydantic_extrar   rO   rP   __getattr__  s*    
2


2zBaseModel.__getattr__)rq   valuerL   c              	   C  s  || j v r4t|d| jj d| jj d| dn\t|s| jd u sR|| jvr`t| || n,| j| }t	|dr|
| | n
|| j|< d S | || t| j|d }t|tr|
| | n| jdd r| j| || n| jddkr|| jvrtd	| jj d
| d	n| jddkr|| jvr| jrZ|| jv rZ|| j|< n:zt| | W n ty   || j|< Y n0 t| || n|| j|< | j| d S )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_assignmentrc   rd   "z" object has no field ")r5   r   r   r   r   is_valid_field_namerE   r6   rm   r   r   _check_frozengetattrr   propertyr3   rl   r@   r   r4   
ValueErrorr]   rC   rI   rD   add)r[   rq   r   r   attrrO   rO   rP   __setattr__  sD    






zBaseModel.__setattr__c              
   C  s   || j v rz| j | }t|dr,||  d S z| j|= W d S  tyx } z&tt| jd||W Y d }~n
d }~0 0 | |d  || j	v rt
| | nZ| jd ur|| jv r| j|= n<zt
| | W n* ty   tt| jd|Y n0 d S )N
__delete__r   )r6   r   r   rE   r   r   r   r   r   r4   r   __delattr__rC   )r[   r   r   r   rO   rO   rP   r   &  s&    



0

zBaseModel.__delattr__c                 C  sX   | j dd rd}nt| j|ddr.d}nd S ||f|d}tj| jj|gd S )NfrozenZfrozen_instanceFZfrozen_fieldr   locinput)	r3   rl   r   r4   pydantic_coreValidationErrorfrom_exception_datar   r   )r[   rq   r   typerrorrO   rO   rP   r   @  s    zBaseModel._check_frozenzdict[Any, Any]c                 C  s0   | j }|rdd | D }| j| j| j|dS )Nc                 S  s   i | ]\}}|t ur||qS rO   r   rS   rO   rO   rP   rW   Q  rX   z*BaseModel.__getstate__.<locals>.<dictcomp>)rI   rC   rD   rE   )rE   rY   rI   rC   rD   )r[   privaterO   rO   rP   __getstate__N  s    zBaseModel.__getstate__)staterL   c                 C  sD   t | d|d  t | d|d  t | d|d  t | d|d  d S )NrD   rC   rE   rI   )rm   )r[   r   rO   rO   rP   __setstate__Y  s    zBaseModel.__setstate__)otherrL   c                 C  s^   t |trV| jd p| j}|jd p(|j}||koT| j|jkoT| j|jkoT| j|jkS tS d S )Nr   )r   r/   r;   r   rI   rE   rC   NotImplemented)r[   r   Z	self_typeZ
other_typerO   rO   rP   __eq___  s    



zBaseModel.__eq__zUnpack[ConfigDict])r   c                 K  s   dS )a  This 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.
            NrO   r   rO   rO   rP   __init_subclass__u  s    zBaseModel.__init_subclass__TupleGeneratorc                 c  s6   dd | j  D E dH  | j}|r2| E dH  dS )zSo `dict(model)` works.c                 S  s"   g | ]\}}| d s||fqS )_)
startswithrS   rO   rO   rP   r     rX   z&BaseModel.__iter__.<locals>.<listcomp>N)rI   rY   rC   )r[   rc   rO   rO   rP   __iter__  s    zBaseModel.__iter__c                 C  s   |    d| d dS )N(r   ))__repr_name____repr_str__rZ   rO   rO   rP   __repr__  s    zBaseModel.__repr__z_repr.ReprArgsc                 #  s    j  D ](\}} j|}|r
|jr
||fV  q
zt d}W n tyZ   d }Y n0 |d ur|dd | D E d H   fdd j D E d H  d S )NrC   c                 s  s   | ]\}}||fV  qd S r   rO   rS   rO   rO   rP   r     rX   z*BaseModel.__repr_args__.<locals>.<genexpr>c                 3  s&   | ]\}}|j r|t |fV  qd S r   )reprr   rS   rZ   rO   rP   r     rX   )	rI   rY   r4   rl   r  r   r   r   r\   )r[   rU   rV   rr   r   rO   rZ   rP   __repr_args__  s    

zBaseModel.__repr_args__c                 C  s
   |  dS )N )r  rZ   rO   rO   rP   __str__  s    zBaseModel.__str__EThe `__fields__` attribute is deprecated, use `model_fields` instead.)categoryzdict[str, FieldInfo]c                 C  s   t dt | jS )Nr
  )r   warnDeprecationWarningr4   rZ   rO   rO   rP   
__fields__  s    zBaseModel.__fields__MThe `__fields_set__` attribute is deprecated, use `model_fields_set` instead.c                 C  s   t dt | jS )Nr  )r   r  r  rD   rZ   rO   rO   rP   __fields_set__  s    zBaseModel.__fields_set__:The `dict` method is deprecated; use `model_dump` instead.r|   r}   r~   r   r   r   ztyping.Dict[str, Any])r|   r}   r~   r   r   r   rL   c                C  s"   t dt | j||||||dS )Nr  r  )r   r  r  r   )r[   r|   r}   r~   r   r   r   rO   rO   rP   r     s    zBaseModel.dict?The `json` method is deprecated; use `model_dump_json` instead.)r|   r}   r~   r   r   r   encodermodels_as_dictz"typing.Callable[[Any], Any] | None)
r|   r}   r~   r   r   r   r  r  dumps_kwargsrL   c          
      K  sN   t dt |turtd|tur,td|	r8td| j||||||dS )Nr  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.r  )r   r  r  r   r   r   )
r[   r|   r}   r~   r   r   r   r  r  r  rO   rO   rP   json  s    zBaseModel.jsonCThe `parse_obj` method is deprecated; use `model_validate` instead.)r`   r   rL   c                 C  s   t dt | |S )Nr  r   r  r  r   r`   r   rO   rO   rP   	parse_obj  s    zBaseModel.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_typeencodingprotoallow_picklezstr | bytes
str | NonezDeprecatedParseProtocol | None)r`   br  r  r   r!  rL   c             
   C  s   t dt ddlm} z|j|||||d}W n ttfy } ztdd l}	t	|t
r\d}
n&t	||	jrnd}
nt	|tr~d}
nd	}
t|
t|d
|d}tj| j|gW Y d }~n
d }~0 0 | |S )Nr  r	   parser   r  r  r!  r   zvalue_error.unicodedecodezvalue_error.jsondecodeZvalue_errorZ
type_error)Z__root__r   )r   r  r  
deprecatedr%  Zload_str_bytesr   r   r  r   UnicodeDecodeErrorJSONDecodeErrorr   ZPydanticCustomErrorr   r   r   r   r   )r`   r#  r  r  r   r!  r%  r   r   r  Ztype_strr   rO   rO   rP   	parse_raw  s8    


(zBaseModel.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)r`   pathr  r  r   r!  rL   c                C  s6   t dt ddlm} |j|||||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.r	   r$  r&  )r   r  r  r'  r%  Z	load_filer  )r`   r+  r  r  r   r!  r%  r   rO   rO   rP   
parse_file:  s    zBaseModel.parse_filezqThe `from_orm` method is deprecated; set `model_config['from_attributes']=True` and use `model_validate` instead.c                 C  s0   t dt | jdd s&tdd d| |S )NzqThe `from_orm` method is deprecated; set `model_config["from_attributes"]=True` and use `model_validate` instead.r   zHYou must set the config attribute `from_attributes=True` to use from_ormrG   )r   r  r  r3   rl   r   r   r  rO   rO   rP   from_ormY  s    zBaseModel.from_ormDThe `construct` method is deprecated; use `model_construct` instead.c                 K  s    t dt | jf d|i|S )Nr/  ra   )r   r  r  rs   )r`   ra   rb   rO   rO   rP   	constructk  s    zBaseModel.constructz8The copy method is deprecated; use `model_copy` instead.)r|   r}   rk   rt   z+AbstractSetIntStr | MappingIntStrAny | Noneztyping.Dict[str, Any] | None)r[   r|   r}   rk   rt   rL   c             	   C  s  t dt ddlm} t|j| dd||ddfi |p8i }| jdu rNd}ndd | j D }| j	du rrd}nR| j	
 }t| j	D ]}	|	|vr||	 qt|D ]}	|	| j	v r||	||	< q|r| j| B }
n
t| j}
|r|
t|8 }
|j| ||
|||d	S )
a  Returns 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.
        zThe `copy` method is deprecated; use `model_copy` instead. See the docstring of `BaseModel.copy` for details about how to handle `include` and `exclude`.r	   copy_internalsF)to_dictr~   r|   r}   r   Nc                 S  s   i | ]\}}|t ur||qS rO   r   rS   rO   rO   rP   rW     rX   z"BaseModel.copy.<locals>.<dictcomp>)rt   )r   r  r  r'  r2  r   _iterrE   rY   rC   r   listrg   rD   rj   ri   _copy_and_set_values)r[   r|   r}   rk   rt   r2  rb   r   rc   rU   Z
fields_setrO   rO   rP   r   s  s<    $




zBaseModel.copyCThe `schema` method is deprecated; use `model_json_schema` instead.)r~   r   rL   c                 C  s   t dt | j||dS )Nr7  r~   r   )r   r  r  r   )r`   r~   r   rO   rO   rP   schema  s    zBaseModel.schemaWThe `schema_json` method is deprecated; use `model_json_schema` and json.dumps instead.r8  )r~   r   r  rL   c                K  s@   dd l }tdt ddlm} |j| j||dfd|i|S )Nr   r:  r	   )pydantic_encoderr8  default)r  r   r  r  Zdeprecated.jsonr;  dumpsr   )r`   r~   r   r  r  r;  rO   rO   rP   schema_json  s    zBaseModel.schema_jsonBThe `validate` method is deprecated; use `model_validate` instead.)r`   r   rL   c                 C  s   t dt | |S )Nr?  r  )r`   r   rO   rO   rP   validate  s    zBaseModel.validateLThe `update_forward_refs` method is deprecated; use `model_rebuild` instead.)localnsrL   c                 K  s(   t dt |rtd| jdd d S )NrA  z,`localns` arguments are not longer accepted.T)r   )r   r  r  r   r   )r`   rB  rO   rO   rP   update_forward_refs  s    zBaseModel.update_forward_refsHThe private method `_iter` will be removed and should no longer be used.)r   r   rL   c                 O  s0   t dt ddlm} |j| g|R i |S )NrD  r	   r1  )r   r  r  r'  r2  r4  r[   r   r   r2  rO   rO   rP   r4    s    zBaseModel._iterzWThe private method `_copy_and_set_values` will be removed and should no longer be used.c                 O  s0   t dt ddlm} |j| g|R i |S )NzXThe private method  `_copy_and_set_values` will be removed and should no longer be used.r	   r1  )r   r  r  r'  r2  r6  rE  rO   rO   rP   r6    s    zBaseModel._copy_and_set_valueszMThe private method `_get_value` will be removed and should no longer be used.c                 O  s0   t dt ddlm} |j| g|R i |S )NzNThe private method  `_get_value` will be removed and should no longer be used.r	   r1  )r   r  r  r'  r2  
_get_value)r`   r   r   r2  rO   rO   rP   rF    s
    zBaseModel._get_valueRThe private method `_calculate_keys` will be removed and should no longer be used.c                 O  s0   t dt ddlm} |j| g|R i |S )NrG  r	   r1  )r   r  r  r'  r2  _calculate_keysrE  rO   rO   rP   rH    s
    zBaseModel._calculate_keys)N)N)N)[r   
__module____qualname____doc__r   TYPE_CHECKING__annotations___FieldrC   rD   rE   r4   r   ZDecoratorInfosr:   r   Z
MockValSerr@   r?   	__slots__r   r3   r8   r>   rQ   Z__pydantic_base_init__r   r\   r]   r^   classmethodrs   ry   r   r   r   r   r   r   rn   r   r   r   r   r   r   r   r   rw   rv   r   r   r   r   r   r   r   r   r   r  r  r   ZRepresentationr  r  Z
__pretty____rich_repr__r	  typing_extensionsr'  r   r  r  r   r   r  r  r*  r,  r.  r0  r   r9  r>  r@  rC  r4  r6  rF  rH  __classcell__rO   rO   r   rP   r/   <   s  
	1$1$,7@ + &	"/	"J		)	metaclass)
__config__rK  __base__rI  __validators____cls_kwargs__r   zConfigDict | Noner"  rJ   zdict[str, classmethod] | NonerB   r   r   )	__model_namerU  rK  rV  rI  rW  rX  field_definitionsrL   c                K  s   d S r   rO   rY  rU  rK  rV  rI  rW  rX  rZ  rO   rO   rP   r2   (  s    r2   )rU  rK  rI  rW  rX  z%type[Model] | tuple[type[Model], ...]r_   c                K  s   d S r   rO   r[  rO   rO   rP   r2   7  s    )rU  rK  rV  rI  rW  rX  rO  z,type[Model] | tuple[type[Model], ...] | Noneztuple[str, ...] | None)
rY  rU  rK  rV  rI  rW  rX  rO  rZ  rL   c                K  s  |durt dt |durB|dur0tdddt|tsV|f}nttjd t	f}|p\i }i }	i }
|
 D ]\}}t|st d| dt t|trtd	|}z|\}}W q ty } ztd
dd|W Y d}~qd}~0 0 n
d| }}|r||
|< ||	|< qn|du r,td}|jd }|
|d}|rJ|d|i |rZ|| ||	 |rzt|j|d< t|}tj| ||d\}}}||ur||d< || || ||fd|d|S )a+  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 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.
        __slots__: Deprecated. Should not be passed to `create_model`.
        **field_definitions: Attributes of the new model. They should be passed in the format:
            `<name>=(<type>, <default value>)` or `<name>=(<type>, <FieldInfo>)`.

    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 togetherzcreate-model-config-baser-  r.   z3fields may not start with an underscore, ignoring "r   ztuple[str, Any]z4Field definitions should be a `(<type>, <default>)`.zcreate-model-field-definitionsr	   r   )rM  rI  rK  r3   )kwds__orig_bases__F)Z#__pydantic_reset_parent_namespace__Z_create_model_module)r   r  RuntimeWarningr   r   r   r   castTyper/   rY   r   r   r   sys	_getframe	f_globalsrk   r
   r   Zconfig_dicttypesresolve_basesprepare_class)rY  rU  rK  rV  rI  rW  rX  rO  rZ  fieldsr   f_nameZf_defZf_annotationZf_valueef	namespaceresolved_basesmetansr\  rO   rO   rP   r2   F  st    "













)SrK  
__future__r   Z_annotationsra  rd  r   r   r   r   r   r   r   rR  r   	_internalr
   r   r   r   r   r   r   r   r   r   Z
_migrationr   Zannotated_handlersr   r   r   r   errorsr   r   Zjson_schemar   r   r   r   r   r   rL  inspectr    pathlibr!   r"   r#   r$   r%   r&   Z_internal._utilsr'   r(   Zdeprecated.parser)   ZDeprecatedParseProtocolrg  r*   r+   r,   r-   rN  	GeneratorTupler   r   TypeVarr.   r1   rM  r  __all__Zobject_setattrrm   ZModelMetaclassr/   overloadr   r2   r   rO   rO   rO   rP   <module>   s   0         u$$$e