
    df4                    L   U d Z ddlm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& ddl'm(Z(m)Z)m*Z*m+Z+m,Z, ddlm-Z- ej\                  rwddl/m0Z0 ddl1m2Z2 ddlm3Z3m4Z4m5Z5 ddlm6Z6m7Z7 ddl8m9Z9m:Z: ddl;m<Z= ddl#m>Z? e@e	e	e	f   ZAe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eQddd 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 d&d!       ZRej                  deQddd"	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 d'd#       ZRddeQd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)ComputedFieldInfo	FieldInfoModelPrivateAttr)DEFAULT_REF_TEMPLATEGenerateJsonSchemaJsonSchemaModeJsonSchemaValuemodel_json_schema)PydanticDeprecatedSince20)	Signature)Path)
CoreSchemaSchemaSerializerSchemaValidator)LiteralUnpack)AbstractSetIntStrMappingIntStrAny)Protocol)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
                  rxd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$<   n=i Z ej                         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dd-       Zedd.       Zedd/       Zeddd1       Zd0dd2dd3Z d4d0d0dddddd,d5		 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 dd6Z!d0d0d0dddddd,d7		 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 dd8Z"ed,e#e$d9f	 	 	 	 	 	 	 	 	 dd:       Z%edd;       Z&dd<Z'edd,d=d0d>	 	 	 	 	 	 	 	 	 dd?       Z(ed0d0d0d@	 	 	 	 	 	 	 	 	 	 	 ddA       Z)ed0d0dB	 	 	 	 	 	 	 	 	 ddC       Z*ed0d0dB	 	 	 	 	 	 	 	 	 ddD       Z+eddE       Z,e	 	 	 	 	 	 ddF       Z-eddG       Z.	 	 	 	 ddHZ/ddIZ0dddJZ1ej
                  sd fdKZ2ddLZ3ddMZ4ddNZ5ddOZ6ddPZ7ej
                  rddQZ8ddRZ9ddSZ:ddTZ;e<jz                  j|                  Z>e<jz                  j~                  Z?e<jz                  j                  Z@e<jz                  j                  ZAddUZBe eCj                  dVeEW      ddX              ZFe eCj                  dYeEW      ddZ              ZG eCj                  d[eEW      d0d0ddddd\	 	 	 	 	 	 	 	 	 	 	 	 	 dd]       ZH eCj                  d^eEW      d0d0ddddeIeId_	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 dd`       ZJe eCj                  daeEW      ddb              ZKe eCj                  dceEW      d0ddd0dde	 	 	 	 	 	 	 	 	 	 	 	 	 ddf              ZLe eCj                  dgeEW      d0ddd0dde	 	 	 	 	 	 	 	 	 	 	 	 	 ddh              ZMe eCj                  dieEW      ddj              ZNe eCj                  dkeEW      dddl              ZO eCj                  dmeEW      d0d0d0ddn	 	 	 	 	 	 	 	 	 	 	 ddo       ZPe eCj                  dpeEW      d,e#f	 	 	 	 	 ddq              ZQe eCj                  dreEW      d,e#ds	 	 	 	 	 	 	 ddt              ZRe eCj                  dueEW      ddv              ZSe eCj                  dweEW      ddx              ZT eCj                  dyeEW      ddz       ZU eCj                  d{eEW      dd|       ZVe eCj                  d}eEW      dd~              ZW eCj                  deEW      dd       ZX xZYS )r/   a  Usage docs: https://docs.pydantic.dev/2.4/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 specified during validation.
        __pydantic_private__: Instance attribute with the values of private attributes set on the model instance.
    zClassVar[ConfigDict]model_configzClassVar[dict[str, FieldInfo]]model_fieldszClassVar[set[str]]__class_vars__z%ClassVar[dict[str, ModelPrivateAttr]]__private_attributes__zClassVar[Signature]__signature__zClassVar[bool]__pydantic_complete__zClassVar[CoreSchema]__pydantic_core_schema____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__zXPydantic models should inherit from BaseModel, BaseModel cannot be instantiated directly	validatorzbase-model-instantiated)
val_or_sercode
serializer)__dict__rG   rE   rH   c                B    d}| j                   j                  ||        y)aj  Create a new model by parsing and validating input data from keyword arguments.

        Raises [`ValidationError`][pydantic_core.ValidationError] if the input data cannot be
        validated to form a valid model.

        `__init__` uses `__pydantic_self__` instead of the more common `self` for the first arg to
        allow `self` as a field name.
        T)self_instanceNrB   validate_python)__pydantic_self__data__tracebackhide__s      F/home/api-vastappli/venv/lib/python3.12/site-packages/pydantic/main.py__init__zBaseModel.__init__   s$     !00@@Uf@g    Tc                    | j                   j                  j                         D ci c]  \  }}||j                   c}}S c c}}w )zGet the computed fields of this model instance.

        Returns:
            A dictionary of computed field names and their corresponding `ComputedFieldInfo` objects.
        )r<   computed_fieldsitemsinfo)selfkvs      rU   model_computed_fieldszBaseModel.model_computed_fields   s9     '+&B&B&R&R&X&X&Z[da166	[[[s   Ac                    | j                   S )zGet extra fields set during validation.

        Returns:
            A dictionary of extra fields, or `None` if `config.extra` is not set to `"allow"`.
        )rE   r\   s    rU   model_extrazBaseModel.model_extra   s     &&&rW   c                    | j                   S )zReturns the set of fields that have been set on this model instance.

        Returns:
            A set of strings representing the fields that have been set,
                i.e. that were not filled from defaults.
        )rG   ra   s    rU   model_fields_setzBaseModel.model_fields_set   s     +++rW   Nc                4   | j                  |       }i }i }| j                  j                         D ]}  \  }}|j                  r-|j                  |v r|j	                  |j                        ||<   ?||v r|j	                  |      ||<   X|j                         ri|j                  d      ||<    |t        |j                               }|j                  |       d}| j                  j                  d      dk(  r i }|j                         D ]
  \  }	}
|
||	<    n|j                  |       t        |d|       t        |d|       | j                  st        |d|       | j                  r|j                  d       |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allowrM   rG   rE   rH   )__new__r5   rZ   aliaspopis_requiredget_defaultsetkeysupdater4   get_object_setattrr@   r?   model_post_init)cls_fields_setvaluesmfields_valuesdefaultsnamefield_extrar]   r^   s              rU   model_constructzBaseModel.model_construct   s    KK(*#%++113 	NKD%{{u{{f4&,jj&=d#&,jj&6d#&&(!&!2!2!2!M	N m0023KX&(,(G3F 1q	   (:}54kB**A3V<%%d#  ,, A5t<rW   )rp   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.4/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.
        rg   rh   )__deepcopy____copy__r4   rq   rZ   r5   rM   rE   rp   rG   ro   )r\   rp   r~   copiedr]   r^   s         rU   
model_copyzBaseModel.model_copy   s     )-""$$--/  $$W-8"LLN 9DAqD----.*!44<8:F57811!49 &&v.**11&++-@rW   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.4/concepts/serialization/#modelmodel_dump

        Generate a dictionary representation of the model, optionally specifying which fields to include or exclude.

        Args:
            mode: The mode in which `to_python` should run.
                If mode is 'json', the dictionary will only contain JSON serializable types.
                If mode is 'python', the dictionary may contain any Python objects.
            include: A list of fields to include in the output.
            exclude: A list of fields to exclude from the output.
            by_alias: Whether to use the field's alias in the dictionary key if defined.
            exclude_unset: Whether to exclude fields that are unset or None from the output.
            exclude_defaults: Whether to exclude fields that are set to their default value from the output.
            exclude_none: Whether to exclude fields that have a value of `None` from the output.
            round_trip: Whether to enable serialization and deserialization round-trip support.
            warnings: Whether to log warnings when invalid fields are encountered.

        Returns:
            A dictionary representation of the model.
        )	r   r   r   r   r   r   r   r   r   )rA   	to_python)
r\   r   r   r   r   r   r   r   r   r   s
             rU   
model_dumpzBaseModel.model_dump  sA    B ++55'-%! 6 
 	
rW   	indentr   r   r   r   r   r   r   r   c       	        h    | j                   j                  | |||||||||	
      j                         S )aI  Usage docs: https://docs.pydantic.dev/2.4/concepts/serialization/#modelmodel_dump_json

        Generates a JSON representation of the model using Pydantic's `to_json` method.

        Args:
            indent: Indentation to use in the JSON output. If None is passed, the output will be compact.
            include: Field(s) to include in the JSON output. Can take either a string or set of strings.
            exclude: Field(s) to exclude from the JSON output. Can take either a string or set of strings.
            by_alias: Whether to serialize using field aliases.
            exclude_unset: Whether to exclude fields that have not been explicitly set.
            exclude_defaults: Whether to exclude fields that have the default value.
            exclude_none: Whether to exclude fields that have a value of `None`.
            round_trip: Whether to use serialization/deserialization between JSON and class instance.
            warnings: Whether to show any warnings that occurred during serialization.

        Returns:
            A JSON string representation of the model.
        r   )rA   to_jsondecode)
r\   r   r   r   r   r   r   r   r   r   s
             rU   model_dump_jsonzBaseModel.model_dump_jsonA  sI    > ++33'-%! 4 
 &(	rW   
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!   )rt   r   r   r   r   s        rU   r!   zBaseModel.model_json_schemam  s    ( !(P`gk
 	
rW   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__)rt   paramsparamparam_namesparams_components        rU   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     rU   rs   zBaseModel.model_post_init  s     	rW      )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)r9   rM   delattrr   r   parent_frame_namespacer   unpack_lenient_weakvaluedictr>   build_lenient_weakvaluedictget_cls_types_namespacer4   complete_model_classr   r
   ConfigWrapper)	rt   r   r   r   r   r   frame_parent_nscls_parent_nsconfigs	            rU   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:) / rW   strictfrom_attributescontextc               D    d}| j                   j                  ||||      S )a  Validate a pydantic model instance.

        Args:
            obj: The object to validate.
            strict: Whether to raise an exception on invalid fields.
            from_attributes: Whether to extract data from object attributes.
            context: Additional context to pass to the validator.

        Raises:
            ValidationError: If the object could not be validated.

        Returns:
            The validated model instance.
        Tr   rP   )rt   objr   r   r   rT   s         rU   model_validatezBaseModel.model_validate  s1    0 !))99 : 
 	
rW   r   r   c               B    d}| j                   j                  |||      S )a  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   )rB   validate_json)rt   	json_datar   r   rT   s        rU   model_validate_jsonzBaseModel.model_validate_json  s)    , !))77	&Za7bbrW   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   )rB   validate_strings)rt   r   r   r   rT   s        rU   model_validate_stringsz BaseModel.model_validate_strings  s)    & !))::3vW^:__rW   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)rM   r=   r:   )rt   _BaseModel__source_BaseModel__handlers      rU   __get_pydantic_core_schema__z&BaseModel.__get_pydantic_core_schema__*  s7     &5 44X>333""rW   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   )rt   _BaseModel__core_schemar   s      rU   __get_pydantic_json_schema__z&BaseModel.__get_pydantic_json_schema__B  s    . ''rW   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   rt   kwargss     rU   __pydantic_init_subclass__z$BaseModel.__pydantic_init_subclass__[  s    " 	rW   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     rU   	<genexpr>z.BaseModel.__class_getitem__.<locals>.<genexpr>  s     _CY44S,G_s    #r      )r   )r   get_cached_generic_type_earlyr/   r   hasattrr=   r   r   	__bases__r   tuplecheck_parameters_countdictzipr   all_identicalro   rv   set_cached_generic_typer   iter_contained_typevarsgeneric_recursion_self_typeget_cached_generic_type_later   r   create_generic_submodel)rt   typevar_valuescachedsubmodelparent_argsr   r   
model_namer   r   maybe_self_typer   s              @rU   __class_getitem__zBaseModel.__class_getitem__n  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.rM   rE   rG   NrH   )
typeri   rr   r   rM   rE   rG   rH   rZ   r   )r\   rt   rw   r]   r^   s        rU   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.rM   )memorE   rG   NrH   )r  ri   rr   r   rM   rE   r   rG   rH   rZ   r   )r\   r  rt   rw   r]   r^   s         rU   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)Nr7   __get__ object has no attribute rE   )object__getattribute__r   r  r  rH   KeyErrorAttributeErrorr   	__class__super)r\   itemprivate_attributes	attributeexcpydantic_extrar  s         rU   __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                  j                  dd       r<d|f|d}t        j                  j                  | j                  j                  |g      t!        | j"                  j                  |      dd	      r<d
|f|d}t        j                  j                  | j                  j                  |g      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(  r|| j"                  vr|| j.                  |<   y || j0                  |<   | j2                  j5                  |       y )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__frozenfrozen_instancer  locinputFfrozen_fieldvalidate_assignmentrg   rh   "z" object has no field ")r6   r
  r  r   r   is_valid_field_namerH   r7   rr   r   r  r4   rq   pydantic_coreValidationErrorfrom_exception_datagetattrr5   r   propertyrB   r  
ValueErrorrE   rM   rG   add)r\   rz   valuer  errorattrs         rU   __setattr__zBaseModel.__setattr__  s   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""8T2)w5E
  //CCDNND[D[^c]deeT&&**40(EB&w5E
  //CCDNND[D[^c]deet~~tT2dH%LLu%""#8$?'';;D$N""7+w64tGXGX;Xq!8!8 99PQUPVVWXYY""7+w64tGXGX;X,1D##D)"'DMM$((,,T2rW   c                *   || j                   v r<| j                   |   }t        |d      r|j                  |        y 	 | j                  |= y || 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  )r7   r   r+  rH   r	  r
  r  r   r5   r  __delattr__rE   )r\   r  r  r  s       rU   r,  zBaseModel.__delattr__'  s   4...33D9Iy,/$$T*k--d3 T&&&tT*$$0TT=T=T5T''-b""4.  k$T
(;(;'>>WX\W_%`agjjk " b$T
(;(;'>>WX\W_%`aabs#   B0 C% 0	C"9$CC"%-Dc                    | j                   }|r,|j                         D ci c]  \  }}|t        us|| }}}| j                  | j                  | j
                  |dS c c}}w )N)rM   rE   rG   rH   )rH   rZ   r   rM   rE   rG   )r\   privater]   r^   s       rU   __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 )NrG   rE   rH   rM   )rr   )r\   states     rU   __setstate__zBaseModel.__setstate__H  sL    7?X9YZ2E:N4OP4e<R6STj%
*;<rW   c                N   t        |t              r| j                  d   xs | j                  }|j                  d   xs |j                  }||k(  xrO | j                  |j                  k(  xr4 | j
                  |j
                  k(  xr | j                  |j                  k(  S t        S )Nr   )r   r/   r=   r  rM   rH   rE   NotImplemented)r\   other	self_type
other_types       rU   __eq__zBaseModel.__eq__N  s    eY' ::8DVI<<XFY%//J Z' HMMU^^3H--1K1KKH ++u/G/GG	 "!rW   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     rU   __init_subclass__zBaseModel.__init_subclass__d  s    rW   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._N)rM   rZ   
startswithrE   )r\   r]   r^   rg   s       rU   __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__ra   s    rU   __repr__zBaseModel.__repr__  s+    $$&'q):):4)@(ACCrW   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)NrE   c              3  *   K   | ]  \  }}||f  y wr   r   )r   r]   r^   s      rU   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      rU   r   z*BaseModel.__repr_args__.<locals>.<genexpr>  s*     cda\]\b\bQa()cs   ++)	rM   rZ   r5   rq   rH  r  r  r
  r_   )r\   r]   r^   r{   r  s   `    rU   __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 )rC  ra   s    rU   __str__zBaseModel.__str__  s      %%rW   EThe `__fields__` attribute is deprecated, use `model_fields` instead.)categoryc                N    t        j                  dt               | j                  S )NrM  )r   warnDeprecationWarningr5   ra   s    rU   
__fields__zBaseModel.__fields__  s     
 	]_qr   rW   MThe `__fields_set__` attribute is deprecated, use `model_fields_set` instead.c                N    t        j                  dt               | j                  S )NrS  )r   rP  rQ  rG   ra   s    rU   __fields_set__zBaseModel.__fields_set__  s$     	[]o	
 +++rW   :The `dict` method is deprecated; use `model_dump` instead.r   r   r   r   r   r   c               d    t        j                  dt               | j                  ||||||      S )NrV  rW  )r   rP  rQ  r   )r\   r   r   r   r   r   r   s          rU   r   zBaseModel.dict  s<     	RTfg'-%  
 	
rW   ?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 )NrY  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.rW  )r   rP  rQ  r   r   r   )
r\   r   r   r   r   r   r   rZ  r[  dumps_kwargss
             rU   jsonzBaseModel.json  sw      	WYkl++kll!22sttWXX##'-% $ 
 	
rW   CThe `parse_obj` method is deprecated; use `model_validate` instead.c                X    t        j                  dt               | j                  |      S )Nr_  r   rP  rQ  r   rt   r   s     rU   	parse_objzBaseModel.parse_obj  s%    
 	[]op!!#&&rW   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)Nrd  r	   parserh  rf  rg  ri  r   zvalue_error.unicodedecodezvalue_error.jsondecodevalue_error
type_error)__root__r  )r   rP  rQ  
deprecatedrl  load_str_bytesr$  r   r^  r   UnicodeDecodeErrorJSONDecodeErrorr  PydanticCustomErrorr   r   r!  r   r   )rt   brf  rg  rh  ri  rl  r   r  r^  type_strr'  s               rU   	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	 	C0BC++C0zThe `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 )NzThe `parse_file` method is deprecated; load the data from file, then if your data is JSON use `model_validate_json` otherwise `model_validate` instead.r	   rk  rm  )r   rP  rQ  rq  rl  	load_filerc  )rt   pathrf  rg  rh  ri  rl  r   s           rU   
parse_filezBaseModel.parse_file)  sQ     	L	

 	&oo%%  
 }}S!!rW   zqThe `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 )NzqThe `from_orm` method is deprecated; set `model_config["from_attributes"]=True` and use `model_validate` instead.r   zHYou must set the config attribute `from_attributes=True` to use from_ormrK   )r   rP  rQ  r4   rq   r   r   rb  s     rU   from_ormzBaseModel.from_ormH  sW     	0	

 ##$5t<#Zae  !!#&&rW   DThe `construct` method is deprecated; use `model_construct` instead.c                ^    t        j                  dt                | j                  dd|i|S )Nr  ru   r   )r   rP  rQ  r}   )rt   ru   rv   s      rU   	constructzBaseModel.constructZ  s/    
 	\^pq"s""E{EfEErW   z8The copy method is deprecated; use `model_copy` instead.)r   r   rp   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.
        zThe `copy` method is deprecated; use `model_copy` instead. See the docstring of `BaseModel.copy` for details about how to handle `include` and `exclude`.r	   copy_internalsF)to_dictr   r   r   r   N)r~   )r   rP  rQ  rq  r  r   _iterrH   rZ   r   rE   r   listrk   rG   ro   rn   _copy_and_set_values)r\   r   r   rp   r~   r  rv   r.  r]   r^   rg   
fields_sets               rU   r   zBaseModel.copyb  s   H 	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   2E3E3CThe `schema` method is deprecated; use `model_json_schema` instead.c                \    t        j                  dt               | j                  ||      S )Nr  r   r   )r   rP  rQ  r!   )rt   r   r   s      rU   schemazBaseModel.schema  s*     	[]op$$h\$RRrW   WThe `schema_json` method is deprecated; use `model_json_schema` and json.dumps instead.r  c                   dd l }t        j                  dt               ddlm}  |j                  | j                  ||      fd|i|S )Nr   r  r	   )pydantic_encoderr  default)r^  r   rP  rQ  deprecated.jsonr  dumpsr!   )rt   r   r   r]  r^  r  s         rU   schema_jsonzBaseModel.schema_json  sV     	e	
 	6tzz!!8,!O
$
 
 	
rW   BThe `validate` method is deprecated; use `model_validate` instead.c                X    t        j                  dt               | j                  |      S )Nr  ra  )rt   r&  s     rU   validatezBaseModel.validate  s%    
 	Z\no!!%((rW   LThe `update_forward_refs` method is deprecated; use `model_rebuild` instead.c                v    t        j                  dt               |rt        d      | j	                  d       y )Nr  z,`localns` arguments are not longer accepted.T)r   )r   rP  rQ  r   r   )rt   localnss     rU   update_forward_refszBaseModel.update_forward_refs  s8     	Z\n	
 JKK%rW   HThe private method `_iter` will be removed and should no longer be used.c                n    t        j                  dt               ddlm}  |j
                  | g|i |S )Nr  r	   r  )r   rP  rQ  rq  r  r  r\   r   r   r  s       rU   r  zBaseModel._iter  s4     	`btu.#~##D:4:6::rW   zWThe private method `_copy_and_set_values` will be removed and should no longer be used.c                n    t        j                  dt               ddlm}  |j
                  | g|i |S )NzXThe private method  `_copy_and_set_values` will be removed and should no longer be used.r	   r  )r   rP  rQ  rq  r  r  r  s       rU   r  zBaseModel._copy_and_set_values  s8    
 	f	
 	/2~224I$I&IIrW   zMThe private method `_get_value` will be removed and should no longer be used.c                n    t        j                  dt               ddlm}  |j
                  | g|i |S )NzNThe private method  `_get_value` will be removed and should no longer be used.r	   r  )r   rP  rQ  rq  r  
_get_value)rt   r   r   r  s       rU   r  zBaseModel._get_value  s8     	\^p	
 	/(~((>t>v>>rW   RThe private method `_calculate_keys` will be removed and should no longer be used.c                n    t        j                  dt               ddlm}  |j
                  | g|i |S )Nr  r	   r  )r   rP  rQ  rq  r  _calculate_keysr  s       rU   r  zBaseModel._calculate_keys	  s8    
 	`bt	
 	/-~--dDTDVDDrW   )rS   r   returnNone)r  zdict[str, ComputedFieldInfo])r  rD   )r  rF   r   )rt   type[Model]ru   zset[str] | Nonerv   r   r  r.   )r\   r.   rp   rD   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   rD   r  bool | None)rt   r  r   r   r   r  r   r  r   rD   r  r.   )
rt   r  r   zstr | bytes | bytearrayr   r  r   rD   r  r.   )
rt   r  r   r   r   r  r   rD   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)r\   r.   r  r.   )r\   r.   r  zdict[int, Any] | Noner  r.   )r  r   r  r   )rz   r   r&  r   r  r  )r  dict[Any, Any])r1  r  r  r  )r5  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  rZ  z"typing.Callable[[Any], Any] | Noner[  r  r]  r   r  r   )rt   r  r   r   r  r.   )rt   r  rv  zstr | bytesrf  
str | Nonerg  r   rh  DeprecatedParseProtocol | Noneri  r  r  r.   )rt   r  r{  z
str | Pathrf  r  rg  r   rh  r  ri  r  r  r.   )r\   r.   r   +AbstractSetIntStr | MappingIntStrAny | Noner   r  rp   ztyping.Dict[str, Any] | Noner~   r  r  r.   )r   r  r   r   r  r  )r   r  r   r   r]  r   r  r   )rt   r  r&  r   r  r.   )r  r   r  r  )r   r   r   r   r  r   )Zr   
__module____qualname____doc__r   TYPE_CHECKING__annotations___FieldrE   rG   rH   r5   r   DecoratorInfosr<   r   
MockValSerrB   rA   	__slots__r   r4   r9   r@   rV   __pydantic_base_init__r#  r_   rb   rd   classmethodr}   r   r   r   r   r   r!   r   rs   r   r   r   r   r   r   r   r   r   r   r  r)  r,  r/  r2  r8  r:  r>  rD  rI  r   RepresentationrB  rC  
__pretty____rich_repr__rL  typing_extensionsrq  r"   rR  rU  r   r   r^  rc  rx  r|  r  r  r   r  r  r  r  r  r  r  r  __classcell__)r  s   @rU   r/   r/   <   s
   8  +*	 54	 +* 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!#h '+H#\ \ ' ' , , / /b 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0 
 #)-``` 	`
 '` 
` `* # #. (!( (( 
	( (0  $>>>	<>@&* 	j@,3\b,	
="" 
	.%Dd( ((66M''44L%%00J((66M& !!!OZs! ! !!!W*,	 
, "!!DOh #!&"
 
 	

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

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

' 
' !!!NYrF F "!!BMf @D?C/3HhHh =Hh =	Hh
 -Hh Hh 
HhHhT !!!MXq #8LSS25S	S S !!!a*
 "&;O

58
ad
	
	 

" !!!LWp) ) !!!V*&	 
& "!!R]v;; "!!a*J	J !!!W*?	 
? "!!\*E	ErW   )	metaclass)
__config____base__r  __validators____cls_kwargs__c                    y r   r   __model_namer  r  r  r  r  field_definitionss          rU   r2   r2          rW   )r  r  r  r  c                    y r   r   r  s          rU   r2   r2   %  r  rW   )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 |	|d}|r|j                  |       |j                  |       |r"t        j                   |      j"                  |d<   t%        j&                  |      }t%        j(                  | ||      \  }}}||ur||d<   |j                  |        || ||fddi|S # t        $ r}t        d
d      |d}~ww xY w)a  Dynamically creates and returns a new Pydantic model, in other words, `create_model` dynamically creates a
    subclass of [`BaseModel`][pydantic.BaseModel].

    Args:
        __model_name: The name of the newly created model.
        __config__: The configuration of the new model.
        __base__: The base class for the new model.
        __module__: The name of the module that the model belongs to.
        __validators__: A dictionary of methods that validate
            fields.
        __cls_kwargs__: A dictionary of keyword arguments for class creation.
        __slots__: Deprecated. Should not be passed to `create_model`.
        **field_definitions: Attributes of the new model. They should be passed in the format:
            `<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-definitions)r  r  r4   )kwds__orig_bases__#__pydantic_reset_parent_namespace__F)r   rP  RuntimeWarningr   r   r   r   castTyper/   rZ   r   r  r$  rp   r
   r   config_dicttypesresolve_basesprepare_class)r  r  r  r  r  r  r  r  fieldsr   f_namef_deff_annotationf_valuee	namespaceresolved_basesmetansr  s                       rU   r2   r2   3  s   @ 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#!& 5@z ZI(V$+$9$9*$E$Q$Q	.!((2N((~N[ND"dX%'Rnik]bkfjkk/  'J9 s   (F%%	G.F<<G)r  r   r  ConfigDict | Noner  r  r  r   r   dict[str, AnyClassMethod] | Noner  rD   r  r   r  r  )r  r   r  r  r  z%type[Model] | tuple[type[Model], ...]r  r   r  r  r  rD   r  r   r  r  )r  r   r  r  r  z,type[Model] | tuple[type[Model], ...] | Noner  r   r  r  r  rD   r  ztuple[str, ...] | Noner  r   r  r  )Tr  
__future__r   _annotationsr  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   r  r   r   r   json_schemar   r   r   r    r!   r"   r  inspectr#   pathlibr$   r%   r&   r'   r(   r)   _internal._utilsr*   r+   deprecated.parser,   DeprecatedParseProtocolr-   r  r  AnyClassMethod	GeneratorTupler   r  TypeVarr.   r1   r  rQ  __all__object_setattrrr   ModelMetaclassr/   overloadr   r2   r  r   rW   rU   <module>r     sn     2         +   * J  B B B u u /	!KK1EE' c3/N%%fll38&<dD&HINFNN7+6E)gE&g 3
%%44XE-<< XEv&  %)7;,0

 "
 	

 
 5
 *
 
 
 
  %)7;,0

 "
 4	

 
 5
 *
 
 
 
  %)=A7;,0(,RlRl "Rl ;	Rl
 Rl 5Rl *Rl &Rl Rl Rlj  )rW   