
    `id                   ^   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 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jX                  ryddl-m.Z. ddl/m0Z0 ddlm1Z1m2Z2m3Z3 ddlm4Z4m5Z5 ddl6m7Z7m8Z8 ddl9m:Z; ddl<m=Z=m>Z>m?Z? ddl<m@ZA ej                  ej                  eDef   ddf   ZE ej                  dd      ZGdZHdeId<   ne+ZJdZKej                  ZM G d dej                        ZOej                  dddeQddd 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 d&d!       ZRej                  ddeQddd"	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 d'd#       ZRdddddddd$	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 d(d%ZR eeQ      ZSy))z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            
      
    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/d6		 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 dd7Z"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Z8ddR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.6/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__rH   rF   rI   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rC   validate_python)selfdata__tracebackhide__s      R/var/www/html/ts-aiml.yecor.com/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"`.
        )rF   rS   s    rV   model_extrazBaseModel.model_extra   s     &&&rX   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.
        )rH   rZ   s    rV   model_fields_setzBaseModel.model_fields_set   s     +++rX   c                   | j                  |       }i }t               }| j                  j                         D ]  \  }}|j                  r>|j                  |v r0|j                  |j                        ||<   |j                  |       P||v r&|j                  |      ||<   |j                  |       z|j                         r|j                  d      ||<    ||}d}| j                  j                  d      dk(  r i }|j                         D ]
  \  }	}
|
||	<    n|j                  |       t        |d|       t        |d|       | j                  st        |d|       | j                  ra|j                  d       t!        |d	      rB|j"                  6|j                         D ]#  \  }	}
|	|j$                  v s|
|j"                  |	<   % |S | 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)call_default_factoryNextraallowrN   rH   rF   rI   )__new__setr5   itemsaliaspopaddis_requiredget_defaultr4   getupdate_object_setattrrA   r@   model_post_inithasattrrI   r8   )cls_fields_setvaluesmfields_values
fields_setnamefield_extrakvs              rV   model_constructzBaseModel.model_construct   s    KK(*U
++113 	SKD%{{u{{f4&,jj&=d#t$&,jj&6d#t$&&(&+&7&7T&7&Rd#	S $K(,(G3F 1q	   (:}54kB**A3V<%%d#q01a6L6L6X"LLN 6DAqA44445..q16  ,, A5t<rX   )rk   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.6/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.
        r`   ra   )__deepcopy____copy__r4   rj   rd   r5   rN   rF   rk   rH   keys)rS   rk   r{   copiedrx   ry   s         rV   
model_copyzBaseModel.model_copy   s     )-""$$--/  $$W-8"LLN 9DAqD----.*!44<8:F57811!49 &&v.**11&++-@rX   python)	modeincludeexcludeby_aliasexclude_unsetexclude_defaultsexclude_none
round_tripwarningsc       	        L    | j                   j                  | |||||||||	
      S )a  Usage docs: https://docs.pydantic.dev/2.6/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 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.
            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: 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   )rB   	to_python)
rS   r   r   r   r   r   r   r   r   r   s
             rV   
model_dumpzBaseModel.model_dump  sA    B ++55'-%! 6 
 	
rX   	indentr   r   r   r   r   r   r   r   c       	        h    | j                   j                  | |||||||||	
      j                         S )a  Usage docs: https://docs.pydantic.dev/2.6/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.
            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: Whether to log warnings when invalid fields are encountered.

        Returns:
            A JSON string representation of the model.
        r   )rB   to_jsondecode)
rS   r   r   r   r   r   r   r   r   r   s
             rV   model_dump_jsonzBaseModel.model_dump_jsonG  sI    > ++33'-%! 4 
 &(	rX   
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   )ro   r   r   r   r   s        rV   r   zBaseModel.model_json_schemas  s    ( !(P`gk
 	
rX   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	TypeError
isinstancestrr   display_as_typejoin__name__)ro   paramsparamparam_namesparams_components        rV   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 )rS   _BaseModel__contexts     rV   rm   zBaseModel.model_post_init  s     	rX      )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`.
        Nr;   r   )parent_depthdefer_buildF)check)r   types_namespace)r:   rN   delattrr   r   parent_frame_namespacer   unpack_lenient_weakvaluedictr?   build_lenient_weakvaluedictget_cls_types_namespacer4   complete_model_classr   r
   ConfigWrapper)	ro   r   r   r   r   r   frame_parent_nscls_parent_nsconfigs	            rV   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:) / rX   strictfrom_attributescontextc               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   rQ   )ro   objr   r   r   rU   s         rV   model_validatezBaseModel.model_validate  s1    0 !))99 : 
 	
rX   r   r   c               B    d}| j                   j                  |||      S )a  Usage docs: https://docs.pydantic.dev/2.6/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   )rC   validate_json)ro   	json_datar   r   rU   s        rV   model_validate_jsonzBaseModel.model_validate_json  s)    0 !))77	&Za7bbrX   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   )rC   validate_strings)ro   r   r   r   rU   s        rV   model_validate_stringsz BaseModel.model_validate_strings  s)    & !))::3vW^:__rX   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`.
        r;   origin)rN   r>   r;   )ro   _BaseModel__source_BaseModel__handlers      rV   __get_pydantic_core_schema__z&BaseModel.__get_pydantic_core_schema__2  s7     &5 44X>333""rX   c                     ||      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.
        r   )ro   _BaseModel__core_schemar   s      rV   __get_pydantic_json_schema__z&BaseModel.__get_pydantic_json_schema__J  s    . ''rX   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   ro   kwargss     rV   __pydantic_init_subclass__z$BaseModel.__pydantic_init_subclass__c  s    " 	rX   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     rV   	<genexpr>z.BaseModel.__class_getitem__.<locals>.<genexpr>  s     _CY44S,G_s    #r      )r   )r   get_cached_generic_type_earlyr/   r   rn   r>   r   r   	__bases__r   tuplecheck_parameters_countdictzipr   all_identicalr   rq   set_cached_generic_typer   iter_contained_typevarsgeneric_recursion_self_typeget_cached_generic_type_later   r   create_generic_submodel)ro   typevar_valuescachedsubmodelparent_argsr   r   
model_namer   r   maybe_self_typer   s              @rV   __class_getitem__zBaseModel.__class_getitem__v  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                               | 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.rN   rF   rH   NrI   )
typerb   rl   r   rN   rF   rH   rI   rd   r   )rS   ro   rr   rx   ry   s        rV   r~   zBaseModel.__copy__  s    4jKK:tDMM':;/d6M6M1NO4d4;W;W6XY$$,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                               | 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.rN   )memorF   rH   NrI   )r   rb   rl   r   rN   rF   r   rH   rI   rd   r   )rS   r   ro   rr   rx   ry   s         rV   r}   zBaseModel.__deepcopy__  s    4jKK:xD'IJ/$:Q:QX\1]^ 	4d4;W;W6XY$$,A5t<  &4+D+D+J+J+Lk41aPQYjPj!Q$krvw  ls   C+C+c                t   t         j                  | d      }||v r<||   }t        |d      r|j                  | t	        |             S 	 | j
                  |   S 	 t         j                  | d      }|	 ||   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)Nr8   __get__ object has no attribute rF   )object__getattribute__rn   r  r   rI   KeyErrorAttributeErrorr   	__class__super)rS   itemprivate_attributes	attributeexcpydantic_extrar  s         rV   __getattr__zBaseModel.__getattr__  sc   !'!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_assignmentr`   ra   "z" object has no field ")r7   r  r  r   r   is_valid_field_namerI   r8   rl   rn   r  _check_frozengetattrr   propertyr4   rj   rC   r  r5   
ValueErrorr[   rF   rN   rH   rg   )rS   ru   valuer  attrs        rV   __setattr__zBaseModel.__setattr__  sA   4&&& (-dnn.E.E-F GAAEAXAX@YYZ[_Z``jl  ,,T2((0D@[@[4[dE2  !77=	9i0%%dE2  7<D--d34't~~tT2dH%LLu%""#8$?'';;D$N""7+w64tGXGX;Xq!8!8 99PQUPVVWXYY""7+w64tGXGX;XDD,<,<$<05''-7D$' $D$6"'DMM$((,,T2 & :49D++D1: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  )r8   rn   r  rI   r  r  r   r   r  r5   r  __delattr__rF   )rS   r
  r  r  s       rV   r  zBaseModel.__delattr__,  s0   4...33D9Iy,/$$T*k--d3 	4&4$$$tT*$$0TT=T=T5T''-b""4.  k$T
(;(;'>>WX\W_%`agjjk " b$T
(;(;'>>WX\W_%`aab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)	r4   rj   r  r5   pydantic_coreValidationErrorfrom_exception_datar  r   )rS   ru   r  typerrors        rV   r  zBaseModel._check_frozenF  s}      40#CT&&**40(EB C71

 ++??@W@WZ_Y`aarX   c                    | j                   }|r,|j                         D ci c]  \  }}|t        us|| }}}| j                  | j                  | j
                  |dS c c}}w )N)rN   rF   rH   rI   )rI   rd   r   rN   rF   rH   )rS   privaterx   ry   s       rV   __getstate__zBaseModel.__getstate__T  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 )NrH   rF   rI   rN   )rl   )rS   states     rV   __setstate__zBaseModel.__setstate___  sL    7?X9YZ2E:N4OP4e<R6STj%
*;<rX   c                :   t        |t              r'| j                  d   xs | j                  }|j                  d   xs |j                  }||k(  r2| j                  |j                  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   FTc                "    t         j                  S r   )r   	_SENTINEL)_s    rV   <lambda>z"BaseModel.__eq__.<locals>.<lambda>  s    W]WgWg rX   )r   r/   r>   r  rI   rF   rN   r   r5   r   operator
itemgetterr  r   SafeGetItemProxyNotImplemented)rS   other	self_type
other_typer5   getterself_fields_proxyother_fields_proxys           rV   __eq__zBaseModel.__eq__e  sj   eY' ::8DVI<<XFY%//J Z'--1K1KK++u/G/GG }}.  :22779L}}!!#|38K8K8MQ]8] <HX((,7MgF
Odmm,u~~0FFF "!  O %+$;$;DMM$J!%+%<%<U^^%L"/0F;M4NNNOs   $D? ?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     rV   __init_subclass__zBaseModel.__init_subclass__  s    rX   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.r5  N)rN   rd   
startswithrF   )rS   rx   ry   r`   s       rV   __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__rZ   s    rV   __repr__zBaseModel.__repr__  s+    $$&'q):):4)@(ACCrX   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)NrF   c              3  *   K   | ]  \  }}||f  y wr   r   )r   rx   ry   s      rV   r   z*BaseModel.__repr_args__.<locals>.<genexpr>  s     B41aABs   c              3  Z   K   | ]"  \  }}|j                   s|t        |      f $ y wr   )reprr  )r   rx   ry   rS   s      rV   r   z*BaseModel.__repr_args__.<locals>.<genexpr>  s*     cda\]\b\bQa()cs   ++)	rN   rd   r5   rj   rP  r  r  r  r6   )rS   rx   ry   rv   r  s   `    rV   __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 )rK  rZ   s    rV   __str__zBaseModel.__str__  s      %%rX   EThe `__fields__` attribute is deprecated, use `model_fields` instead.categoryc                P    t        j                  dt               | j                  S )NrU  rV  )r   warnr   r5   rZ   s    rV   
__fields__zBaseModel.__fields__  s$    
 	S^w	
    rX   MThe `__fields_set__` attribute is deprecated, use `model_fields_set` instead.c                P    t        j                  dt               | j                  S )Nr[  rV  )r   rY  r   rH   rZ   s    rV   __fields_set__zBaseModel.__fields_set__  s$     	[.	
 +++rX   :The `dict` method is deprecated; use `model_dump` instead.r   r   r   r   r   r   c               f    t        j                  dt               | j                  ||||||      S )Nr^  rV  r_  )r   rY  r   r   )rS   r   r   r   r   r   r   s          rV   r   zBaseModel.dict  s<     	R]vw'-%  
 	
rX   ?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 )Nra  rV  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   rY  r   r   r   r   )
rS   r   r   r   r   r   r   rb  rc  dumps_kwargss
             rV   jsonzBaseModel.json
  s{     	MXq	
 ++kll!22sttWXX##'-% $ 
 	
rX   CThe `parse_obj` method is deprecated; use `model_validate` instead.c                Z    t        j                  dt               | j                  |      S )Nrg  rV  r   rY  r   r   ro   r   s     rV   	parse_objzBaseModel.parse_obj*  s)     	Q\u	
 !!#&&rX   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)Nrl  rV  r	   parserp  rn  ro  rq  r   zvalue_error.unicodedecodezvalue_error.jsondecodevalue_error
type_error)__root__r$  )r   rY  r   
deprecatedrt  load_str_bytesr  r   rf  r   UnicodeDecodeErrorJSONDecodeErrorr'  PydanticCustomErrorr   r(  r)  r   r   )ro   brn  ro  rp  rq  rt  r   r  rf  type_strr+  s               rV   	parse_rawzBaseModel.parse_raw2  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  rV  r	   rs  ru  )r   rY  r   ry  rt  	load_filerk  )ro   pathrn  ro  rp  rq  rt  r   s           rV   
parse_filezBaseModel.parse_fileg  sQ     	M.	

 	&oo%%  
 }}S!!rX   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  rV  r   zHYou must set the config attribute `from_attributes=True` to use from_ormrL   )r   rY  r   r4   rj   r   r   rj  s     rV   from_ormzBaseModel.from_orm  sX     	W.	

 ##$5t<#Zae  !!#&&rX   DThe `construct` method is deprecated; use `model_construct` instead.c                `    t        j                  dt                | j                  dd|i|S )Nr  rV  rp   r   )r   rY  r   rz   )ro   rp   rq   s      rV   	constructzBaseModel.construct  s3     	R]v	
 #s""E{EfEErX   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   rk   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  rV  r	   copy_internalsF)to_dictr   r   r   r   N)r{   )r   rY  r   ry  r  r   _iterrI   rd   r   rF   r   listrf   rH   r   rc   _copy_and_set_values)rS   r   r   rk   r{   r  rq   r-  rx   ry   r`   rt   s               rV   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  rV  r   r   )r   rY  r   r   )ro   r   r   s      rV   schemazBaseModel.schema  s.    
 	Q\u	
 $$h\$RRrX   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  rV  r   r	   )pydantic_encoderr  default)r   rY  r   rf  deprecated.jsonr  dumpsr   )ro   r   r   re  rf  r  s         rV   schema_jsonzBaseModel.schema_json  sV     	e.	
 	5tzz!!8,!O
$
 
 	
rX   BThe `validate` method is deprecated; use `model_validate` instead.c                Z    t        j                  dt               | j                  |      S )Nr  rV  ri  )ro   r  s     rV   validatezBaseModel.validate  s)     	P[t	
 !!%((rX   LThe `update_forward_refs` method is deprecated; use `model_rebuild` instead.c                x    t        j                  dt               |rt        d      | j	                  d       y )Nr  rV  z,`localns` arguments are not longer accepted.T)r   )r   rY  r   r   r   )ro   localnss     rV   update_forward_refszBaseModel.update_forward_refs  s8     	Z.	
 JKK%rX   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  rV  r	   r  )r   rY  r   ry  r  r  rS   r   r   r  s       rV   r  zBaseModel._iter"  s8     	V.	
 	/#~##D:4:6::rX   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  rV  r	   r  )r   rY  r   ry  r  r  r  s       rV   r  zBaseModel._copy_and_set_values.  s8    
 	e.	
 	/2~224I$I&IIrX   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  rV  r	   r  )r   rY  r   ry  r  
_get_value)ro   r   r   r  s       rV   r  zBaseModel._get_value;  s8     	[.	
 	/(~((>t>v>>rX   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  rV  r	   r  )r   rY  r   ry  r  _calculate_keysr  s       rV   r  zBaseModel._calculate_keysI  s8    
 	`.	
 	/-~--dDTDVDDrX   )rT   r   returnNone)r  rE   )r  rG   r   )ro   type[Model]rp   zset[str] | Nonerq   r   r  r.   )rS   r.   rk   rE   r{   boolr  r.   )r   zLiteral['json', 'python'] | strr   r1   r   r1   r   r  r   r  r   r  r   r  r   r  r   r  r  dict[str, Any])r   z
int | Noner   r1   r   r1   r   r  r   r  r   r  r   r  r   r  r   r  r  r   )
r   r  r   r   r   ztype[GenerateJsonSchema]r   r   r  r  )r   ztuple[type[Any], ...]r  r   )r   r   r  r  )
r   r  r   r  r   intr   rE   r  bool | None)ro   r  r   r   r   r  r   r  r   rE   r  r.   )
ro   r  r   zstr | bytes | bytearrayr   r  r   rE   r  r.   )
ro   r  r   r   r   r  r   rE   r  r.   )r   type[BaseModel]r   r   r  r"   )r   r"   r   r   r  r   )r   r   r  r  )r   z!type[Any] | tuple[type[Any], ...]r  z3type[BaseModel] | _forward_ref.PydanticRecursiveRef)rS   r.   r  r.   )rS   r.   r   zdict[int, Any] | Noner  r.   )r
  r   r  r   )ru   r   r  r   r  r  )r  dict[Any, Any])r0  r  r  r  )r;  r   r  r  )r   zUnpack[ConfigDict])r  TupleGenerator)r  r   )r  z_repr.ReprArgs)r  zdict[str, FieldInfo])r   r1   r   r1   r   r  r   r  r   r  r   r  r  typing.Dict[str, Any])r   r1   r   r1   r   r  r   r  r   r  r   r  rb  z"typing.Callable[[Any], Any] | Nonerc  r  re  r   r  r   )ro   r  r   r   r  r.   )ro   r  r~  zstr | bytesrn  
str | Nonero  r   rp  DeprecatedParseProtocol | Nonerq  r  r  r.   )ro   r  r  z
str | Pathrn  r  ro  r   rp  r  rq  r  r  r.   )rS   r.   r   +AbstractSetIntStr | MappingIntStrAny | Noner   r  rk   ztyping.Dict[str, Any] | Noner{   r  r  r.   )r   r  r   r   r  r  )r   r  r   r   re  r   r  r   )ro   r  r  r   r  r.   )r  r   r  r  )r   r   r   r   r  r   )[r   
__module____qualname____doc__r   TYPE_CHECKING__annotations___FieldrF   rH   rI   r5   r6   r   DecoratorInfosr=   r?   r   
MockValSerrC   rB   	__slots__r   r4   r:   rA   rW   __pydantic_base_init__r  r[   r]   classmethodrz   r   r   r   r   r   r   r   rm   r   r   r   r   r   r   r   r   r~   r}   r  r  r  r  r.  r1  rA  rC  rF  rL  rQ  r   RepresentationrJ  rK  
__pretty____rich_repr__rT  typing_extensionsry  rZ  r]  r   r   rf  rk  r  r  r  r  r   r  r  r  r  r  r  r  r  __classcell__)r  s   @rV   r/   r/   =   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#' ' , , 7 7r DHV[ > 19#!&" ,
 .,
 	,

 ,
 ,
 ,
 ,
 ,
 ,
 ,
 
,
b "#!&" * * 	*
 * * * * * * * 
*X  05G+

 
 3	

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

 %
 '
 

 
8 
 #)-cc*c 	c
 'c 
c c4 
 #)-``` 	`
 '` 
` `* # #. (!( (( 
	( (0  $>>>	<>@&* 	j@)3Vb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rX   )	metaclass)
__config__r  __base__r  __validators____cls_kwargs__c                    y r   r   __model_namer  r  r  r  r  r  field_definitionss           rV   r2   r2   W       rX   )r  r  r  r  r  c                    y r   r   r  s           rV   r2   r2   f  r  rX   )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 ]u  \  }}t        j                  |      st        j                  d| dt               t	        |t
              rt        j                  d	|      }	 |\  }}nd|}}|r||
|<   ||	|<   w |$t        j                  d      }|j                   d   }|
|d}|r|j#                  d|i       |r|j#                  |       |j#                  |	       |r"t%        j&                  |      j(                  |d<   t+        j,                  |      }t+        j.                  | ||      \  }}}||ur||d<   |j#                  |        || ||fd|d|S # t        $ r}t        d
d      |d}~ww xY w)a  Usage docs: https://docs.pydantic.dev/2.6/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>)` 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   )r  r  r  r4   )kwds__orig_bases__F)#__pydantic_reset_parent_namespace___create_model_module)r   rY  RuntimeWarningr   r   r   r   castTyper/   rd   r   r  r  sys	_getframe	f_globalsrk   r
   r   config_dicttypesresolve_basesprepare_class)r  r  r  r  r  r  r  r  r  fieldsr   f_namef_deff_annotationf_valueef	namespaceresolved_basesmetansr  s                         rV   r2   r2   u  s/   H 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 %)%'L".K v#!& MM![[,
4?z ZI)W-.(V$+$9$9*$E$Q$Q	.!((2N((~N[ND"dX%'R -2'  =  'J9 s   (G!!	G=*G88G=)r  r   r  ConfigDict | Noner  r  r  r  r  r   r  dict[str, classmethod] | Noner  rE   r  r   r  r  )r  r   r  r  r  r  r  z%type[Model] | tuple[type[Model], ...]r  r   r  r  r  rE   r  r   r  r  )r  r   r  r  r  r  r  z,type[Model] | tuple[type[Model], ...] | Noner  r  r  r  r  rE   r  ztuple[str, ...] | Noner  r   r  r  )Tr  
__future__r   _annotationsr7  r  r  r   r   r   r   r   r   r'  r  r   	_internalr
   r   r   r   r   r   r   r   r   r   
_migrationr   annotated_handlersr   r   r   r   errorsr   r   json_schemar   r   r   r   r   r   r  inspectr    pathlibr!   r"   r#   r$   r%   r&   _internal._utilsr'   r(   deprecated.parser)   DeprecatedParseProtocolr  r*   r+   r,   r-   r  	GeneratorTupler   r  TypeVarr.   r1   r  DeprecationWarning__all__object_setattrrl   ModelMetaclassr/   overloadr   r2   r  r   rX   rV   <module>r     s     2  
         +   * J  B u u /	!KK1EEFF'%%fll38&<dD&HINFNN7+6E)gE&g 3
%%44WE-<< WEt(  %)48,0 " 	
   2 *     %)48,0 " 	
 4  2 *   " %)=A!48,0(,dd "d 	d
 ;d d 2d *d &d d dN  )rX   