
    +DCf2                      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Zddl	m	Z	m
Z
 ddlmZmZmZmZmZmZmZmZmZ ddlZddlZddlm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)m*Z* ddl+m,Z, ddl-m.Z.m/Z/ ddl0m1Z1m2Z2m3Z3m4Z4m5Z5 ddlm6Z6  edd      Z7eee8ef   ddf   Z9eee:   ee8   ee:ef   ee8ef   df   Z;de<d<   ejz                  r;ddl>m?Z? ddl@mAZA ddlmBZBmCZCmDZD ddlmEZE ddlFmGZGmHZH ddlImJZK ddlLmMZMmNZNmOZO ddlLmPZQ ne6ZRdZSej                  ZU G d dej                         ZWej                  dddeYddd!	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 d'd"       ZZej                  ddeYddd#	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 d(d$       ZZdddddddd%	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 d)d&ZZ e$eY      Z[y)*zLogic for creating models.    )annotationsN)copydeepcopy)	AnyClassVarDict	GeneratorLiteralSetTupleTypeVarUnion)PydanticUndefined)	TypeAlias   )
_config_decorators_fields_forward_ref	_generics_mock_val_ser_model_construction_repr_typing_extra_utils)getattr_migration)AliasChoices	AliasPath)GetCoreSchemaHandlerGetJsonSchemaHandler)
ConfigDict)PydanticUndefinedAnnotationPydanticUserError)DEFAULT_REF_TEMPLATEGenerateJsonSchemaJsonSchemaModeJsonSchemaValuemodel_json_schema)PydanticDeprecatedSince20Model	BaseModel)boundr   IncEx)	Signature)Path)
CoreSchemaSchemaSerializerSchemaValidator)Unpack)AbstractSetIntStrMappingIntStrAny)Protocol)ComputedFieldInfo	FieldInfoModelPrivateAttr)Field)r+   create_modelc                  
    e Zd ZU dZej
                  r~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<   ded<   ded<    ed !      Zd"ed#<    ed !      Z	d$ed%<    ed !      Z
d"ed&<   nAi Zi Z ej                         Zd'Z ej$                  d(d)d*+      Z ej$                  d(d,d*+      Zd-Z e       Zd Zd Zdd.Zd/e_        edd0       Zedd1       Zeddd2       Z d'd d3dd4Z!d5d'd'd'd d d d d d/d d6	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 dd7Z"d'd'd'd'd d d d d d/d d8	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 dd9Z#ed/e$e%d:f	 	 	 	 	 	 	 	 	 dd;       Z&edd<       Z'dd=Z(ed d/d>d'd?	 	 	 	 	 	 	 	 	 dd@       Z)ed'd'd'dA	 	 	 	 	 	 	 	 	 	 	 ddB       Z*ed'd'dC	 	 	 	 	 	 	 	 	 ddD       Z+ed'd'dC	 	 	 	 	 	 	 	 	 ddE       Z,eddF       Z-e	 	 	 	 	 	 ddG       Z.eddH       Z/	 	 	 	 ddIZ0ddJZ1dddKZ2ej
                  sd fdLZ3ddMZ4ddNZ5ddOZ6ddPZ7ddQZ8ej
                  sddRZ9ej
                  rddSZ:ddTZ;ddUZ<ddVZ=e>j~                  j                  Z@e>j~                  j                  ZAe>j~                  j                  ZBe>j~                  j                  ZCddWZDe eEj                  dXd'Y      ddZ              ZGe eEj                  d[d'Y      dd\              ZH eEj                  d]d'Y      d'd'd d d d d^	 	 	 	 	 	 	 	 	 	 	 	 	 dd_       ZI eEj                  d`d'Y      d'd'd d d d eJeJda	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 ddb       ZKe eEj                  dcd'Y      ddd              ZLe eEj                  ded'Y      d'dfd'd dg	 	 	 	 	 	 	 	 	 	 	 	 	 ddh              ZMe eEj                  did'Y      d'dfd'd dg	 	 	 	 	 	 	 	 	 	 	 	 	 ddj              ZNe eEj                  dkd'Y      ddl              ZOe eEj                  dmd'Y      dddn              ZP eEj                  dod'Y      d'd'd'd dp	 	 	 	 	 	 	 	 	 	 	 ddq       ZQe eEj                  drd'Y      d/e$f	 	 	 	 	 dds              ZRe eEj                  dtd'Y      d/e$du	 	 	 	 	 	 	 ddv              ZSe eEj                  dwd'Y      ddx              ZTe eEj                  dyd'Y      ddz              ZU eEj                  d{d'Y      dd|       ZV eEj                  d}d'Y      dd~       ZWe eEj                  dd'Y      dd              ZX eEj                  dd'Y      dd       ZY xZZS )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.
    zClassVar[ConfigDict]model_configzClassVar[dict[str, FieldInfo]]model_fieldsz&ClassVar[dict[str, ComputedFieldInfo]]model_computed_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____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__set[str]__pydantic_fields_set____pydantic_private__NzXPydantic models should inherit from BaseModel, BaseModel cannot be instantiated directly	validatorzbase-model-instantiated)
val_or_sercode
serializer)__dict__rQ   rO   rR   c               B    d}| j                   j                  ||        y)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)self_instanceNrL   validate_python)selfdata__tracebackhide__s      M/var/www/highfloat_scraper/venv/lib/python3.12/site-packages/pydantic/main.py__init__zBaseModel.__init__   s#     !##33D3M    Tc                    | j                   S )zGet extra fields set during validation.

        Returns:
            A dictionary of extra fields, or `None` if `config.extra` is not set to `"allow"`.
        )rO   r\   s    r_   model_extrazBaseModel.model_extra   s     &&&ra   c                    | 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.
        )rQ   rc   s    r_   model_fields_setzBaseModel.model_fields_set   s     +++ra   c                z   | j                  |       }i }t               }| j                  j                         D ]x  \  }}|j                  =|j                  |v r/|j                  |j                        ||<   |j                  |       ||vr|j                  t        |j                  t              r|j                  j                  n|j                  g}|D ]  }	t        |	t              r+|	|v r'|j                  |	      ||<   |j                  |        nDt        |	t              sO|	j                  |      }
|
t        usi|
||<   |j                  |        n ||vs'||v r'|j                  |      ||<   |j                  |       R|j                         rd|j!                  d      ||<   { ||}| j"                  j%                  d      dk(  r$|j                         D ci c]  \  }}||
 c}}nd}t'        |d|       t'        |d|       | j(                  st'        |d|       | j*                  ra|j-                  d       t/        |d	      rB|j0                  6|j                         D ]#  \  }}||j2                  v s||j0                  |<   % |S | j(                  st'        |d	d       |S c c}}w )
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)call_default_factoryextraallowrW   rQ   rO   rR   )__new__setr>   itemsaliaspopaddvalidation_alias
isinstancer   choicesstrr   search_dict_for_pathr   is_requiredget_defaultr=   get_object_setattrrJ   rI   model_post_inithasattrrR   rA   )cls_fields_setvaluesmfields_values
fields_setnamefieldvalidation_aliasesrn   valuekv_extras                 r_   model_constructzBaseModel.model_construct   s   * KK(*U
++113 	WKD%{{&5;;&+@&,jj&=d#t$J&U-C-C-O "%"8"8,G **22001 # 0 
"E!%-%6/.4jj.?d+"t,#E95 % : :6 B (9927M$/&NN40!
" :%6>*0**T*:M$'NN4(**,*/*;*;QU*;*VM$';	W< $K 251A1A1E1Eg1NRY1Yflln-daQT-_c 	 	:}54kB**A3V<%%d#q01a6L6L6X"LLN 6DAqA44445..q16  ,, A5t<) .s   )J7)updatedeepc                  |r| j                         n| j                         }|r| j                  j                  d      dk(  rY|j	                         D ]E  \  }}|| j
                  v r||j                  |<   $|j                  i |_        ||j                  |<   G n|j                  j                  |       |j                  j                  |j                                |S )a  Usage 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.
        ri   rj   )__deepcopy____copy__r=   rx   rm   r>   rW   rO   r   rQ   keys)r\   r   r   copiedr   r   s         r_   
model_copyzBaseModel.model_copy  s     )-""$$--/  $$W-8"LLN 9DAqD----.*!44<8:F57811!49 &&v.**11&++-@ra   python)modeincludeexcludecontextby_aliasexclude_unsetexclude_defaultsexclude_none
round_tripwarningsserialize_as_anyc               P    | j                   j                  | |||||||||	|
|      S )a  Usage 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.
        )r   r   r   r   r   r   r   r   r   r   r   )rK   	to_python)r\   r   r   r   r   r   r   r   r   r   r   r   s               r_   
model_dumpzBaseModel.model_dump5  sG    L ++55'-%!- 6 
 	
ra   indentr   r   r   r   r   r   r   r   r   r   c               l    | j                   j                  | |||||||||	|
|      j                         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   )rK   to_jsondecode)r\   r   r   r   r   r   r   r   r   r   r   r   s               r_   model_dump_jsonzBaseModel.model_dump_jsonj  sP    H ++33'-%!- 4 
 &(	ra   
validationc                "    t        | ||||      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   ref_templateschema_generatorr   )r(   )r|   r   r   r   r   s        r_   r(   zBaseModel.model_json_schema  s    ( !(P`gk
 	
ra   c                   t        | t        j                        st        d      |D cg c])  }t	        |t
              r|nt        j                  |      + }}dj                  |      }| j                   d| dS c c}w )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., [])

issubclasstypingGeneric	TypeErrorrr   rt   r   display_as_typejoin__name__)r|   paramsparamparam_namesparams_components        r_   model_parametrized_namez!BaseModel.model_parametrized_name  s~    " #v~~.YZZ
 gmm]b
5# 6uE<Q<QRW<XXmm99[1,,q!1 2!44 ns   .A=c                     y)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.
        N )r\   _BaseModel__contexts     r_   rz   zBaseModel.model_post_init  s     	ra      )forceraise_errors_parent_namespace_depth_types_namespacec               @   |s| j                   ryd| j                  v rt        | d       ||j                         }n|dkD  r^t	        j
                  |      xs i }t        j                  | j                        xs i }i ||}t        j                  |      | _        nt        j                  | j                        }t	        j                  | |      }i | j                  ddi}t        j                  | | j                  t        j                  |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`.
        NrD   r   )parent_depthdefer_buildF)check)r   types_namespace)rC   rW   delattrr   r   parent_frame_namespacer   unpack_lenient_weakvaluedictrH   build_lenient_weakvaluedictget_cls_types_namespacer=   complete_model_classr   r   ConfigWrapper)	r|   r   r   r   r   r   frame_parent_nscls_parent_nsconfigs	            r_   model_rebuildzBaseModel.model_rebuild  s   0 22)S\\978+9I9N9N9P*Q.&3&J&JXo&p&vtvO+HHIjIjkqoq " 'K&J/&JO8K8g8ghw8xC5&9&V&V99'O #0"G"G_"] @((?-?F&;;%%fE:) / ra   strictfrom_attributesr   c               D    d}| j                   j                  ||||      S )a  Validate 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.
        Tr   rZ   )r|   objr   r   r   r^   s         r_   model_validatezBaseModel.model_validate  s1    0 !))99 : 
 	
ra   r   r   c               B    d}| j                   j                  |||      S )a  Usage 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   )rL   validate_json)r|   	json_datar   r   r^   s        r_   model_validate_jsonzBaseModel.model_validate_json+  s)    0 !))77	&Za7bbra   c               B    d}| j                   j                  |||      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   )rL   validate_strings)r|   r   r   r   r^   s        r_   model_validate_stringsz BaseModel.model_validate_stringsF  s)    & !))::3vW^:__ra   c               d    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`.
        rD   origin)rW   rG   rD   )r|   sourcehandlers      r_   __get_pydantic_core_schema__z&BaseModel.__get_pydantic_core_schema__\  s6     &5 44X>333vra   c                    ||      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.
        r   )r|   core_schemar   s      r_   __get_pydantic_json_schema__z&BaseModel.__get_pydantic_json_schema__t  s    0 {##ra   c                     y)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.
        Nr   r|   kwargss     r_   __pydantic_init_subclass__z$BaseModel.__pydantic_init_subclass__  s    " 	ra   c                   t        j                  | |      }||S | t        u rt        d      t	        | d      st        |  d      | j
                  d   s*t        j                  | j                  vrt        |  d      t        |t              s|f}t        j                  | |       t        t        | j
                  d   |            t        j                  j!                         j#                               rr| }t        j$                  | ||       |S | j
                  d   }|s|}nt        fd|D              }| j
                  d   xs | }|j'                  |      }t        t        j(                  j#                               D ci c]  }|d  c}      }	t        j*                  ||      5 }
|
|
cd d d        S t        j,                  | |||      }||cd d d        S 	 |j/                  d	
       t        j2                  ||||	      }t        j$                  | ||||       d d d        |S c c}w # t0        $ r Y Kw xY w# 1 sw Y   S xY w)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  J   K   | ]  }t        j                  |        y wN)r   replace_types).0argtypevars_maps     r_   	<genexpr>z.BaseModel.__class_getitem__.<locals>.<genexpr>  s     _CY44S,G_s    #r      )r   )r   get_cached_generic_type_earlyr+   r   r{   rG   r   r   	__bases__rr   tuplecheck_parameters_countdictzipr   all_identicalr   r~   set_cached_generic_typer   iter_contained_typevarsgeneric_recursion_self_typeget_cached_generic_type_later   r"   create_generic_submodel)r|   typevar_valuescachedsubmodelparent_argsr   r   
model_namer   r   maybe_self_typer   s              @r_   __class_getitem__zBaseModel.__class_getitem__  ss    88nMM)_``s,-se#jkll00>6>>Y\YfYfCfse#:;<<.%0,.N((n= DH11,?PD
  1 1 3\5H5H5JKP\H--c>8LJ G ;;FCK%_S^__66x@GCF77=J*3*K*KLL_L_La*bccF 66vtD _".*_ _ #??^U[]ab%!_ _(((C %<<ZQUW]^ 11#~xQWY]^+_. 5 d 3  	_. s<   
H:9II-H??1I?	II
IIIc           
        t        |       }|j                  |      }t        |dt        | j                               t        |dt        | j
                               t        |dt        | j                               t        | d      r| j                  t        |dd       |S t        |d| j                  j                         D ci c]  \  }}|t        us|| c}}       |S c c}}w )z$Returns a shallow copy of the model.rW   rO   rQ   rR   N)typerk   ry   r   rW   rO   rQ   r{   rR   rm   r   )r\   r|   r   r   r   s        r_   r   zBaseModel.__copy__  s    4jKK:tDMM':;/d6M6M1NO4d4;W;W6XYt348Q8Q8YA5t<  &"&";";"A"A"Cb$!QqPaGaAb  cs   C(C(c                   t        |       }|j                  |      }t        |dt        | j                  |             t        |dt        | j
                  |             t        |dt        | j                               t        | d      r| j                  t        |dd       |S t        |dt        | j                  j                         D ci c]  \  }}|t        us|| c}}|             |S c c}}w )z!Returns a deep copy of the model.rW   )memorO   rQ   rR   N)r  rk   ry   r   rW   rO   r   rQ   r{   rR   rm   r   )r\   r  r|   r   r   r   s         r_   r   zBaseModel.__deepcopy__  s    4jKK:xD'IJ/$:Q:QX\1]^ 	4d4;W;W6XYt348Q8Q8YA5t<  &4+D+D+J+J+Lk41aPQYjPj!Q$krvw  ls   C7"C7c                t   t         j                  | d      }||v r<||   }t        |d      r|j                  | t	        |             S 	 | j
                  |   S 	 t         j                  | d      }|r	 ||   S t        | j                  |      rt        |   |      S t        t	        |       j                  d|      # t        $ r)}t        t	        |       j                  d|      |d }~ww xY w# t        $ r d }Y w xY w# t        $ r)}t        t	        |       j                  d|      |d }~ww xY w)NrA   __get__ object has no attribute rO   )object__getattribute__r{   r  r  rR   KeyErrorAttributeErrorr   	__class__super)r\   itemprivate_attributes	attributeexcpydantic_extrar  s         r_   __getattr__zBaseModel.__getattr__  s`   !'!8!8?W!X)).t4	9i0$,,T4:>>o44T::*%+%<%<TCW%XN "s-d33 t~~t4$w7== -T
0C0C/FF_`d_g-hii)   o(DJ,?,?+BB[\`[c)deknno & *%)N* $ s,T
0C0C/FF_`d_g-hiorrssB   	B? C4 2D ?	C1$C,,C14DD	D7$D22D7c           
        || j                   v r?t        |d| j                  j                   d| j                  j                   d| d      t	        j
                  |      sf| j                  || j                  vrt        | ||       y | j                  |   }t        |d      r|j                  | |       y || j                  |<   y | j                  ||       t        | j                  |d       }t        |t              r|j                  | |       y | j                  j!                  dd       r| j"                  j%                  | ||       y | j                  j!                  d      dk7  r4|| j&                  vr&t)        d	| j                  j                   d
| d	      | j                  j!                  d      dk(  rS|| j&                  vrE| j*                  r|| j*                  v r|| j,                  |<   y 	 t        | |       t        | ||       y || j.                  |<   | j0                  j3                  |       y # t        $ r || j,                  |<   Y y w xY w)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_assignmentri   rj   "z" object has no field ")r@   r  r  r   r   is_valid_field_namerR   rA   ry   r{   r!  _check_frozengetattrrr   propertyr=   rx   rL   r"  r>   
ValueErrorrd   rO   rW   rQ   rp   )r\   r   r   r  attrs        r_   __setattr__zBaseModel.__setattr__-  sB   t***$h1$..2I2I1J KEEI^^E\E\D]]^_c^ddnp  006,,4DD_D_8_#D$6  !% ; ;D AIy)4!))$6  ;@11$7tU+4>>46D$)T5)""&&'<dC++??dER""&&w/7:t4K\K\?\ 1T^^%<%<$==TUYTZZ[!\]]""&&w/7:t4K\K\?\##0@0@(@49D++D1;d+ (dE:&+d#,,006 * >8=//5>s   8H= =IIc                N   || j                   v r<| j                   |   }t        |d      r|j                  |        y 	 | j                  |= y | j                  |d        || j                  v rt        j                  | |       y | j                  || j                  v r| j                  |= y 	 t        j                  | |       y # t        $ r)}t        t        |       j                  d|      |d }~ww xY w# t
        $ r$ t        t        |       j                  d|      w xY w)N
__delete__r  )rA   r{   r,  rR   r  r  r  r   r%  r>   r  __delattr__rO   )r\   r  r  r  s       r_   r-  zBaseModel.__delattr__X  s0   t222 77=	9l3((.o11$7 tT*t(((""4.((4AXAX9X++D1f&&tT2   o(DJ,?,?+BB[\`[c)deknno & f(DJ,?,?+BB[\`[c)deefs#   C +C7 	C4$C//C47-D$c                   | j                   j                  dd       rd}n*t        | j                  j                  |      dd      rd}ny ||f|d}t        j
                  j                  | j                  j                  |g      )Nfrozenfrozen_instanceFfrozen_fieldr  locinput)	r=   rx   r&  r>   pydantic_coreValidationErrorfrom_exception_datar  r   )r\   r   r   typerrors        r_   r%  zBaseModel._check_frozenr  s}      40#CT&&**40(EB C71

 ++??@W@WZ_Y`aara   c                    | j                   }|r,|j                         D ci c]  \  }}|t        us|| }}}| j                  | j                  | j
                  |dS c c}}w )N)rW   rO   rQ   rR   )rR   rm   r   rW   rO   rQ   )r\   privater   r   s       r_   __getstate__zBaseModel.__getstate__  se    ++(/V11DU;Uq!tVGV"&"9"9'+'C'C$+	
 	
 Ws
   A A c                    t        | d|d          t        | d|d          t        | d|d          t        | d|d          y )NrQ   rO   rR   rW   )ry   )r\   states     r_   __setstate__zBaseModel.__setstate__  sL    7?X9YZ2E:N4OP4e<R6STj%
*;<ra   c                >   t        |t              r)| j                  d   xs | j                  }|j                  d   xs |j                  }||k(  r4t	        | dd       t	        |dd       k(  r| j
                  |j
                  k(  sy| j                  |j                  k(  ryt        |       j                  j                         }| j                  j                         |k  r|j                  j                         |k  ry|rt        j                  | nd }	  || j                         ||j                        k(  S t        S # t        $ rR t        j                  | j                        }t        j                  |j                        } ||       ||      k(  cY S w xY w)Nr   rR   FTc                "    t         j                  S r   )r   	_SENTINEL)_s    r_   <lambda>z"BaseModel.__eq__.<locals>.<lambda>  s    [a[k[k ra   )rr   r+   rG   r  r&  rO   rW   r  r>   r   operator
itemgetterr  r   SafeGetItemProxyNotImplemented)r\   other	self_type
other_typer>   getterself_fields_proxyother_fields_proxys           r_   __eq__zBaseModel.__eq__  st   %+ !>>xHZDNN	"@@J]eoo
 +&<dCwuVlnrGss//53K3KK  ==ENN2  $Dz66;;===%%'<7ENN<O<O<QUa<a  @L,,l;Qk
S!$--0F5>>4JJJ &%   S )/(?(?(N%)/)@)@)P&!"34?Q8RRRSs   $E AFFc                     y)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.
            Nr   r   s     r_   __init_subclass__zBaseModel.__init_subclass__  s    ra   c              #     K   | j                   j                         D cg c]  \  }}|j                  d      r||f c}}E d{    | j                  }|r|j                         E d{    yyc c}}w 7 27 w)zSo `dict(model)` works.rC  N)rW   rm   
startswithrO   )r\   r   r   ri   s       r_   __iter__zBaseModel.__iter__  sl     )-)<)<)>Xv1allSVFWQFXXX''{{}$$  YX %s3   A>A4A4 A>A:%A>-A<.A><A>c                L    | j                          d| j                  d       dS )N(r   ))__repr_name____repr_str__rc   s    r_   __repr__zBaseModel.__repr__  s+    $$&'q):):4)@(ACCra   c              #     K    j                   j                         D ]6  \  }} j                  j                  |      }|s$|j                  s1||f 8 	 t
        j                   d      }|d |j                         D        E d {     fd j                  j                         D        E d {    y # t        $ r d }Y Zw xY w7 A7 w)NrO   c              3  *   K   | ]  \  }}||f  y wr   r   )r   r   r   s      r_   r   z*BaseModel.__repr_args__.<locals>.<genexpr>   s     B41aABs   c              3  Z   K   | ]"  \  }}|j                   s|t        |      f $ y wr   )reprr&  )r   r   r   r\   s      r_   r   z*BaseModel.__repr_args__.<locals>.<genexpr>  s*     cda\]\b\bQa()cs   ++)	rW   rm   r>   rx   r^  r  r  r  r?   )r\   r   r   r   r  s   `    r_   __repr_args__zBaseModel.__repr_args__  s     MM'') 	DAq%%))!,Ed
		"#44T;OPN %B>+?+?+ABBBcd6P6P6V6V6Xccc  	"!N	" CcsS   >CCCB; .C
C*C5C6C;C	CC		CCc                $    | j                  d      S )N )rY  rc   s    r_   __str__zBaseModel.__str__	  s      %%ra   EThe `__fields__` attribute is deprecated, use `model_fields` instead.categoryc                P    t        j                  dt               | j                  S )Nrc  rd  )r   warnr)   r>   rc   s    r_   
__fields__zBaseModel.__fields__  s$    
 	S^w	
    ra   MThe `__fields_set__` attribute is deprecated, use `model_fields_set` instead.c                P    t        j                  dt               | j                  S )Nri  rd  )r   rg  r)   rQ   rc   s    r_   __fields_set__zBaseModel.__fields_set__  s$     	[.	
 +++ra   :The `dict` method is deprecated; use `model_dump` instead.r   r   r   r   r   r   c               f    t        j                  dt               | j                  ||||||      S )Nrl  rd  rm  )r   rg  r)   r   )r\   r   r   r   r   r   r   s          r_   r   zBaseModel.dict#  s<     	R]vw'-%  
 	
ra   ?The `json` method is deprecated; use `model_dump_json` instead.)r   r   r   r   r   r   encodermodels_as_dictc                   t        j                  dt               |t        urt	        d      |t        urt	        d      |	rt	        d      | j                  ||||||      S )Nro  rd  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.rm  )r   rg  r)   r   r   r   )
r\   r   r   r   r   r   r   rp  rq  dumps_kwargss
             r_   jsonzBaseModel.json8  s{     	MXq	
 ++kll!22sttWXX##'-% $ 
 	
ra   CThe `parse_obj` method is deprecated; use `model_validate` instead.c                Z    t        j                  dt               | j                  |      S )Nru  rd  r   rg  r)   r   r|   r   s     r_   	parse_objzBaseModel.parse_objX  s)     	Q\u	
 !!#&&ra   The `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_picklec                  t        j                  dt               ddlm} 	 |j                  |||||      }| j%                  |      S # t        t        f$ r}dd l}	t        |t              rd}
n.t        ||	j                        rd}
nt        |t              rd	}
nd
}
t        j                  |
t        |            d|d}t        j                  j!                  | j"                  |g      d }~ww xY w)Nrz  rd  r   parser~  r|  r}  r  r   zvalue_error.unicodedecodezvalue_error.jsondecodevalue_error
type_error)__root__r2  )r   rg  r)   
deprecatedr  load_str_bytesr(  r   rt  rr   UnicodeDecodeErrorJSONDecodeErrorr5  PydanticCustomErrorrt   r6  r7  r   r   )r|   br|  r}  r~  r  r  r   r  rt  type_strr9  s               r_   	parse_rawzBaseModel.parse_raw`  s     	I.	

 	&	[&&)!) ' C8 !!#&&+ I& 	[ #126C!5!563C,('
 &99(CHM$	5E  //CCCLLSXRYZZ)	[s   A
 
C1BC,,C1The `parse_file` method is deprecated; load the data from file, then if your data is JSON use `model_validate_json`, otherwise `model_validate` instead.c                   t        j                  dt               ddlm} |j                  |||||      }| j                  |      S )Nr  rd  r   r  r  )r   rg  r)   r  r  	load_filery  )r|   pathr|  r}  r~  r  r  r   s           r_   
parse_filezBaseModel.parse_file  sQ     	M.	

 	&oo%%  
 }}S!!ra   qThe `from_orm` method is deprecated; set `model_config['from_attributes']=True` and use `model_validate` instead.c                    t        j                  dt               | j                  j	                  dd       st        dd       | j                  |      S )Nr  rd  r   zHYou must set the config attribute `from_attributes=True` to use from_ormrU   )r   rg  r)   r=   rx   r#   r   rx  s     r_   from_ormzBaseModel.from_orm  sX     	W.	

 ##$5t<#Zae  !!#&&ra   DThe `construct` method is deprecated; use `model_construct` instead.c                `    t        j                  dt                | j                  dd|i|S )Nr  rd  r}   r   )r   rg  r)   r   )r|   r}   r~   s      r_   	constructzBaseModel.construct  s3     	R]v	
 #s""E{EfEEra   The `copy` method is deprecated; use `model_copy` instead. See the docstring of `BaseModel.copy` for details about how to handle `include` and `exclude`.)r   r   r   r   c          
        t        j                  dt               ddlm} t        |j                  | dd||d      fi |xs i }| j                  d}n6| j                  j                         D 	ci c]  \  }}	|	t        us||	 }}}	| j                  d}
n}| j                  j                         }
t        | j                        D ]  }||vs|
j                  |        t        |      D ]%  }|| j                  v s|j                  |      |
|<   ' |r| j                  |j                         z  }nt!        | j                        }|r|t!        |      z  }|j#                  | |||
||      S c c}	}w )	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.
        r  rd  r   copy_internalsF)to_dictr   r   r   r   N)r   )r   rg  r)   r  r  r   _iterrR   rm   r   rO   r   listro   rQ   r   rl   _copy_and_set_values)r\   r   r   r   r   r  r~   r;  r   r   ri   r   s               r_   r   zBaseModel.copy  s   F 	m.	

 	/  eeWgej ! 
 |	
 $$,G(,(A(A(G(G(Ih1QVgMgq!thGh""*+/E++002E$112 !F?IIaL! &\ -///%zz!}E!H-
 55EJT99:J #g,&J224UT[bf2gg/ is   3E4E4CThe `schema` method is deprecated; use `model_json_schema` instead.c                ^    t        j                  dt               | j                  ||      S )Nr  rd  r   r   )r   rg  r)   r(   )r|   r   r   s      r_   schemazBaseModel.schema  s.    
 	Q\u	
 $$h\$RRra   WThe `schema_json` method is deprecated; use `model_json_schema` and json.dumps instead.r  c                   t        j                  dt               dd l}ddlm}  |j                  | j                  ||      fd|i|S )Nr  rd  r   r   )pydantic_encoderr  default)r   rg  r)   rt  deprecated.jsonr  dumpsr(   )r|   r   r   rs  rt  r  s         r_   schema_jsonzBaseModel.schema_json$  sV     	e.	
 	5tzz!!8,!O
$
 
 	
ra   BThe `validate` method is deprecated; use `model_validate` instead.c                Z    t        j                  dt               | j                  |      S )Nr  rd  rw  )r|   r   s     r_   validatezBaseModel.validate:  s)     	P[t	
 !!%((ra   LThe `update_forward_refs` method is deprecated; use `model_rebuild` instead.c                x    t        j                  dt               |rt        d      | j	                  d       y )Nr  rd  z,`localns` arguments are not longer accepted.T)r   )r   rg  r)   r   r   )r|   localnss     r_   update_forward_refszBaseModel.update_forward_refsB  s8     	Z.	
 JKK%ra   HThe private method `_iter` will be removed and should no longer be used.c                p    t        j                  dt               ddlm}  |j
                  | g|i |S )Nr  rd  r   r  )r   rg  r)   r  r  r  r\   r   r   r  s       r_   r  zBaseModel._iterP  s8     	V.	
 	/#~##D:4:6::ra   WThe private method `_copy_and_set_values` will be removed and should no longer be used.c                p    t        j                  dt               ddlm}  |j
                  | g|i |S )Nr  rd  r   r  )r   rg  r)   r  r  r  r  s       r_   r  zBaseModel._copy_and_set_values\  s8    
 	e.	
 	/2~224I$I&IIra   MThe private method `_get_value` will be removed and should no longer be used.c                p    t        j                  dt               ddlm}  |j
                  | g|i |S )Nr  rd  r   r  )r   rg  r)   r  r  
_get_value)r|   r   r   r  s       r_   r  zBaseModel._get_valuei  s8     	[.	
 	/(~((>t>v>>ra   RThe private method `_calculate_keys` will be removed and should no longer be used.c                p    t        j                  dt               ddlm}  |j
                  | g|i |S )Nr  rd  r   r  )r   rg  r)   r  r  _calculate_keysr  s       r_   r  zBaseModel._calculate_keysw  s8    
 	`.	
 	/-~--dDTDVDDra   )r]   r   returnNone)r  rN   )r  rP   r   )r|   type[Model]r}   zset[str] | Noner~   r   r  r*   )r\   r*   r   rN   r   boolr  r*   )r   zLiteral['json', 'python'] | strr   r-   r   r-   r   rN   r   r  r   r  r   r  r   r  r   r  r   'bool | Literal['none', 'warn', 'error']r   r  r  dict[str, Any])r   z
int | Noner   r-   r   r-   r   rN   r   r  r   r  r   r  r   r  r   r  r   r  r   r  r  rt   )
r   r  r   rt   r   ztype[GenerateJsonSchema]r   r&   r  r  )r   ztuple[type[Any], ...]r  rt   )r   r   r  r  )
r   r  r   r  r   intr   rN   r  bool | None)r|   r  r   r   r   r  r   r  r   rN   r  r*   )
r|   r  r   zstr | bytes | bytearrayr   r  r   rN   r  r*   )
r|   r  r   r   r   r  r   rN   r  r*   )r   type[BaseModel]r   r   r  r0   )r   r0   r   r    r  r'   )r   r   r  r  )r  z!type[Any] | tuple[type[Any], ...]r  z3type[BaseModel] | _forward_ref.PydanticRecursiveRef)r\   r*   r  r*   )r\   r*   r  zdict[int, Any] | Noner  r*   )r  rt   r  r   )r   rt   r   r   r  r  )r  dict[Any, Any])r>  r  r  r  )rI  r   r  r  )r   zUnpack[ConfigDict])r  TupleGenerator)r  rt   )r  z_repr.ReprArgs)r  zdict[str, FieldInfo])r   r-   r   r-   r   r  r   r  r   r  r   r  r  typing.Dict[str, Any])r   r-   r   r-   r   r  r   r  r   r  r   r  rp  z"typing.Callable[[Any], Any] | Nonerq  r  rs  r   r  rt   )r|   r  r   r   r  r*   )r|   r  r  zstr | bytesr|  
str | Noner}  rt   r~  DeprecatedParseProtocol | Noner  r  r  r*   )r|   r  r  z
str | Pathr|  r  r}  rt   r~  r  r  r  r  r*   )r\   r*   r   +AbstractSetIntStr | MappingIntStrAny | Noner   r  r   ztyping.Dict[str, Any] | Noner   r  r  r*   )r   r  r   rt   r  r  )r   r  r   rt   rs  r   r  rt   )r|   r  r   r   r  r*   )r  r   r  r  )r   r   r   r   r  r   )[r   
__module____qualname____doc__r   TYPE_CHECKING__annotations___FieldrO   rQ   rR   r>   r?   r   DecoratorInfosrF   rH   r   
MockValSerrL   rK   	__slots__r!   r=   rC   rJ   r`   __pydantic_base_init__r'  rd   rf   classmethodr   r   r   r   r$   r%   r(   r   rz   r   r   r   r   r   r   r   r  r   r   r  r*  r-  r%  r<  r?  rO  rQ  rT  rZ  r_  r   RepresentationrX  rY  
__pretty____rich_repr__rb  typing_extensionsr  rh  rk  r   r   rt  ry  r  r  r  r  r   r  r  r  r  r  r  r  r  __classcell__)r  s   @r_   r+   r+   B   s	   8  +*	 54	  FEg** EE**--"66"00!EE'RR'FF KK!//!;; 99
 5;4F1F,2,>>6<%6H3H
  ""<+"<"<">(,%!9!9!9f"*"

 #;-":":f#*#
 dI<L!#
N '+H#' ' , , N N` DHV[ > 19)-#!&" <@!&3
 .3
 	3

 3
 '3
 3
 3
 3
 3
 3
 :3
 3
 
3
p ")-#!&" <@!&1 1 	1
 1 '1 1 1 1 1 1 :1 1 
1f  05G+

 
 3	

 
 

 
. 5 54  !'(265 5 	5
 "%5 05 
5 5n 
 #'+)-


 	

 %
 '
 

 
8 
 #)-cc*c 	c
 'c 
c c4 
 #)-``` 	`
 '` 
` `*  . $$ &$
 
$ $2  $>>>	<>@&* 	j@)	7V	f4b	
= 5	&n 
	.%Dd( ((66M''44L%%00J((66M& !!!OZ^! ! !!!W,	 
, "!!"^imn #!&"
 
 	

 
 
 
 
 

 o
( "!!"cnrs #!&"6G0
 
 	

 
 
 
 
 4
 
 
 

 t
> !!!"grvw' x ' !!!	E $(04"-'-'-' !	-'
 -' .-' -' 
-' -'^ !!!	I $(04"""" !	"
 " ." " 
" "2 !!!	S

' 
' !!!"hswxF y F "!!	i @D?C/3EhEh =Eh =	Eh
 -Eh Eh 
Eh
EhN !!!"grvw"8LSS25S	S x S !!!a
 "&;O

58
ad
	
	 

" !!!"fquv) w ) !!!V&	 
& "!!R]a;; "!!aJ	J !!!W?	 
? "!!\E	Era   )	metaclass)
__config__r  __base__r  __validators____cls_kwargs__c                    y r   r   __model_namer  r  r  r  r  r  field_definitionss           r_   r;   r;          ra   )r  r  r  r  r  c                    y r   r   r  s           r_   r;   r;     r  ra   )r  r  r  r  r  r  r  c                  |t        j                  dt               |#|t        dd      t	        |t
              s0|f}n,t        j                  t        j                  d   t              f}|xs i }i }	i }
|j                         D ]  \  }}t        j                  |      st        j                  d| dt               t	        |t
              rt        j                  d	|      }	 |\  }}nPt        j                  |      r7t!        j"                  |      ^}}}ddlm} t	        ||      st        dd      d|}}|r||
|<   ||	|<    |$t)        j*                  d      }|j,                  d   }|
|d}|r|j/                  d|i       |r|j/                  |       |j/                  |	       |r"t1        j2                  |      j4                  |d<   t7        j8                  |      }t7        j:                  | ||      \  }}}||ur||d<   |j/                  |        || ||fd|d|S # t        $ r}t        d
d      |d}~ww xY w)a2  Usage 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:
            `<name>=(<type>, <default value>)`, `<name>=(<type>, <FieldInfo>)`, or `typing.Annotated[<type>, <FieldInfo>]`.
            Any additional metadata in `typing.Annotated[<type>, <FieldInfo>, ...]` 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 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   )r8   z<Field definitions should be a Annotated[<type>, <FieldInfo>]r   )r  r  r  r=   )kwds__orig_bases__F)#__pydantic_reset_parent_namespace___create_model_module)r   rg  RuntimeWarningr#   rr   r   r   castTyper+   rm   r   r$  r(  r   is_annotatedr  get_argsfieldsr8   sys	_getframe	f_globalsr   r   r   config_dicttypesresolve_basesprepare_class)r  r  r  r  r  r  r  r  r  r  r   f_namef_deff_annotationf_valueerC  r8   f	namespaceresolved_basesmetansr  s                           r_   r;   r;     s}   J FW!#X/  (E* {HKKG 4i@B#)rNFK*002 !**62MMOPVxWXY[ijeU#KK 159E(-%g ''.*;*D*D+'\7Q *gy1'R9  %)%'L".K v=!@ MM![[,
4?z ZI)W-.(V$+$9$9*$E$Q$Q	.!((2N((~N[ND"dX%'R -2'  W  'J9 s   (H--	I	6II	)r  rt   r  ConfigDict | Noner  r  r  r  r  rt   r  dict[str, classmethod] | Noner  rN   r  r   r  r  )r  rt   r  r  r  r  r  z%type[Model] | tuple[type[Model], ...]r  rt   r  r  r  rN   r  r   r  r  )r  rt   r  r  r  r  r  z,type[Model] | tuple[type[Model], ...] | Noner  r  r  r  r  rN   r  ztuple[str, ...] | Noner  r   r  r  )\r  
__future__r   _annotationsrE  r  r  r   r   r   r   r   r   r   r	   r
   r   r   r   r   r5  r  r   r   	_internalr   r   r   r   r   r   r   r   r   r   
_migrationr   aliasesr   r   annotated_handlersr   r    r   r!   errorsr"   r#   json_schemar$   r%   r&   r'   r(   r)   r*   rt   r  r  r-   r  r  inspectr.   pathlibr/   r0   r1   r2   r3   _internal._utilsr4   r5   deprecated.parser6   DeprecatedParseProtocolr  r7   r8   r9   r:   r  DeprecationWarning__all__object_setattrry   ModelMetaclassr+   overloadr   r;   r  r   ra   r_   <module>r     s     2  
     V V V   + '   * , J  B u u / 	{+5c?D$67S3s8T#s(^T#s(^TQRy R 
!KK(EEFF' 3
%%44@E-<< @EF*  %)48,0 " 	
   2 *     %)48,0 " 	
 4  2 *   " %)=A!48,0(,rr "r 	r
 ;r r 2r *r &r r rj  )ra   