AlkantarClanX12

Your IP : 3.145.89.89


Current Path : /opt/cloudlinux/venv/lib64/python3.11/site-packages/pydantic/__pycache__/
Upload File :
Current File : //opt/cloudlinux/venv/lib64/python3.11/site-packages/pydantic/__pycache__/main.cpython-311.pyc

�

X��e4�����UdZddlmZddlZddlZddlZddlmZmZddlm	Z	m
Z
ddlZddlZddlm
Z
ddlmZmZmZmZmZmZmZmZmZmZdd	lmZdd
lmZmZddlmZddl m!Z!m"Z"dd
l#m$Z$m%Z%m&Z&ddl'm(Z(m)Z)m*Z*m+Z+m,Z,ddlm-Z-ej.rtddl/m0Z0ddl1m2Z2ddlm3Z3m4Z4m5Z5ddlm6Z6m7Z7ddl8m9Z9m:Z:ddl;m<Z=ddl#m>Z?e@e	e	e	fZAejBejCeDe	fddfZEejFdd���ZGdZHdeId<ne-ZJdZKejLZMGd�dejN���ZOejPddeQddd �d:d0���ZRejPdeQddd1�d;d4���ZRddeQdddd5�d<d9�ZReeQ��ZSdS)=zLogic 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] | Noneztyping_extensions.TypeAlias�IncEx)r0�create_modelc
�	��eZdZUdZejr�ded<	ded<	ded<ded	<d
ed<ded
<ded<ded<ded<ded<ded<ded<ded<ded<ded<ed���Zd ed!<ed���Z	d"ed#<ed���Z
d ed$<n7iZej
��Zejd%d&d'�(��Zejd%d)d'�(��Zd*Ze��ZdZdZd�d/�Zd0e_ed�d2���Zed�d3���Zed�d4���Zed�d�d<���Zd5dd=�d�dB�Z dCd5d5dddddd0dD�	d�dQ�Z!d5d5d5dddddd0dR�	d�dV�Z"ed0e#e$dWfd�d\���Z%ed�d_���Z&d�da�Z'edd0dbd5dc�d�dj���Z(ed5d5d5dk�d�dp���Z)ed5d5dq�d�dt���Z*ed5d5dq�d�du���Z+ed�d{���Z,ed�d���Z-ed�d����Z.d�d��Z/d�d��Z0d�d�d��Z1ejsd�fd��Z2d�d��Z3d�d��Z4d�d��Z5d�d��Z6d�d��Z7ejrd�d��Z8d�d��Z9d�d��Z:d�d��Z;e<j=j>Z>e<j=j?Z?e<j=j@Z@e<j=jAZAd�d��ZBeeCjDd�eE����d�d������ZFeeCjDd�eE����d�d������ZGeCjDd�eE����d5d5ddddd��d�d����ZHeCjDd�eE����d5d5ddddeIeId��d�d����ZJeeCjDd�eE����d�d������ZKeeCjDd�eE����d5d�d5dd���dd������ZLeeCjDd�eE����d5d�d5dd���dd������ZMeeCjDd�eE����d�d„����ZNeeCjDd�eE����d�d�dĄ����ZOeCjDd�eE����d5d5d5ddƜ�ddɄ��ZPeeCjDd�eE����d0e#f�dd˄����ZQeeCjDd�eE����d0e#d͜�dd΄����ZReeCjDd�eE�����ddЄ����ZSeeCjDd�eE�����ddӄ����ZTeCjDd�eE�����ddք��ZUeCjDd�eE�����dd؄��ZVeeCjDd�eE�����ddڄ����ZWeCjDd�eE�����dd܄��ZX�xZYS(r0a�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.
    zClassVar[ConfigDict]�model_configzClassVar[dict[str, FieldInfo]]�model_fieldszClassVar[set[str]]�__class_vars__z%ClassVar[dict[str, ModelPrivateAttr]]�__private_attributes__zClassVar[Signature]�
__signature__zClassVar[bool]�__pydantic_complete__zClassVar[CoreSchema]�__pydantic_core_schema__�__pydantic_custom_init__z$ClassVar[_decorators.DecoratorInfos]�__pydantic_decorators__z+ClassVar[_generics.PydanticGenericMetadata]�__pydantic_generic_metadata__zClassVar[dict[str, Any] | None]�__pydantic_parent_namespace__z+ClassVar[None | Literal['model_post_init']]�__pydantic_post_init__�__pydantic_root_model__zClassVar[SchemaSerializer]�__pydantic_serializer__zClassVar[SchemaValidator]�__pydantic_validator__F)�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�	validatorzbase-model-instantiated)�
val_or_ser�code�
serializer)�__dict__rHrFrI�datar�return�Nonec�B�d}|j�||���dS)ajCreate 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�rC�validate_python)�__pydantic_self__rO�__tracebackhide__s   �B/opt/cloudlinux/venv/lib/python3.11/site-packages/pydantic/main.py�__init__zBaseModel.__init__�s-��!���0�@�@��Uf�@�g�g�g�g�g�T�dict[str, ComputedFieldInfo]c�R�d�|jj���D��S)z�Get the computed fields of this model instance.

        Returns:
            A dictionary of computed field names and their corresponding `ComputedFieldInfo` objects.
        c�$�i|]
\}}||j��S�)�info��.0�k�vs   rX�
<dictcomp>z3BaseModel.model_computed_fields.<locals>.<dictcomp>�s ��[�[�[�d�a���1�6�[�[�[rZ)r=�computed_fields�items��selfs rX�model_computed_fieldszBaseModel.model_computed_fields�s+��\�[�d�&B�&R�&X�&X�&Z�&Z�[�[�[�[rZc��|jS)z�Get extra fields set during validation.

        Returns:
            A dictionary of extra fields, or `None` if `config.extra` is not set to `"allow"`.
        )rFrgs rX�model_extrazBaseModel.model_extra�s
���&�&rZc��|jS)z�Returns 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.
        )rHrgs rX�model_fields_setzBaseModel.model_fields_set�s
���+�+rZN�cls�type[Model]�_fields_set�set[str] | None�valuesr/c�b�|�|��}i}i}|j���D]}\}}|jr'|j|vr|�|j��||<�3||vr|�|��||<�P|���s|�d���||<�~|�!t|�����}|�	|��d}|j
�d��dkr"i}|���D]
\}	}
|
||	<�n|�	|��t|d|��t|d|��|j
st|d|��|jr|�d��n|j
st|d	d��|S)
aSCreates 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�allowrNrHrFrI)�__new__r6rf�alias�pop�is_required�get_default�set�keys�updater5�get�_object_setattrrAr@�model_post_init)rnrprr�m�
fields_values�defaults�name�field�_extrarbrcs           rX�model_constructzBaseModel.model_construct�s���
�K�K�����(*�
�#%���+�1�1�3�3�	N�	N�K�D�%��{�
N�u�{�f�4�4�&,�j�j���&=�&=�
�d�#�#�����&,�j�j��&6�&6�
�d�#�#��&�&�(�(�
N�!&�!2�!2��!2�!M�!M��������m�0�0�2�2�3�3�K����X�&�&�&�(,�������(�(�G�3�3��F������
�
���1���q�	�	�
�
� � ��(�(�(���:�}�5�5�5���4�k�B�B�B��*�	=��A�3�V�<�<�<��%�	=�
���d�#�#�#�#��,�	=�
�A�5�t�<�<�<��rZ)r~�deeprhr~r��boolc��|r|���n|���}|r�|j�d��dkrG|���D]1\}}||jvr||j|<�|j�i|_||j|<�2n|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.
        rurv)�__deepcopy__�__copy__r5rrfr6rNrFr~rHr})rhr~r��copiedrbrcs      rX�
model_copyzBaseModel.model_copy�s���)-�A��"�"�$�$�$�$�-�-�/�/���	A�� �$�$�W�-�-��8�8�"�L�L�N�N�9�9�D�A�q��D�-�-�-�-.����*�*�!�4�<�8:�F�5�78��1�!�4�4�
9���&�&�v�.�.�.��*�1�1�&�+�+�-�-�@�@�@��
rZ�python)	�mode�include�exclude�by_alias�
exclude_unset�exclude_defaults�exclude_none�
round_trip�warningsr��Literal['json', 'python'] | strr�r2r�r�r�r�r�r�r��dict[str, Any]c	�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�)rB�	to_python)
rhr�r�r�r�r�r�r�r�r�s
          rX�
model_dumpzBaseModel.model_dumpsC��B�+�5�5������'�-�%�!��6�
�
�	
rZ�	�indentr�r�r�r�r�r�r�r�r��
int | None�strc	�n�|j�||||||||||	��
�
���S)aIUsage 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�)rB�to_json�decode)
rhr�r�r�r�r�r�r�r�r�s
          rX�model_dump_jsonzBaseModel.model_dump_jsonAsM��>�+�3�3������'�-�%�!��4�
�
��&�(�(�	rZ�
validation�ref_template�schema_generator�type[GenerateJsonSchema]r c�*�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�r�r�r�)r")rnr�r�r�r�s     rXr"zBaseModel.model_json_schemams(��(!��(��P`�gk�
�
�
�	
rZ�params�tuple[type[Any], ...]c��t|tj��std���d�|D��}d�|��}|j�d|�d�S)a}Compute the class name for parametrizations of generic classes.

        This method can be overridden to achieve a custom naming scheme for generic BaseModels.

        Args:
            params: Tuple of types of the class. Given a generic class
                `Model` with 2 type variables and a concrete model `Model[str, int]`,
                the value `(str, int)` would be passed to `params`.

        Returns:
            String representing the new class where `params` are passed to `cls` as type variables.

        Raises:
            TypeError: Raised when trying to generate concrete names for non-generic models.
        z;Concrete names should only be generated for generic models.c�d�g|]-}t|t��r|ntj|����.Sr^)�
isinstancer�r�display_as_type�ra�params  rX�
<listcomp>z5BaseModel.model_parametrized_name.<locals>.<listcomp>�s8��m�m�m�]b�
�5�#� 6� 6�X�u�u�E�<Q�RW�<X�<X�m�m�mrZ�, �[�])�
issubclass�typing�Generic�	TypeError�join�__name__)rnr��param_names�params_components    rX�model_parametrized_namez!BaseModel.model_parametrized_name�sk��"�#�v�~�.�.�	[��Y�Z�Z�Z�
n�m�fl�m�m�m���9�9�[�1�1���,�4�4�!1�4�4�4�4rZ�_BaseModel__contextc��dS)z�Override 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.
        Nr^)rhr�s  rXr�zBaseModel.model_post_init�s	��	
�rZ�)�force�raise_errors�_parent_namespace_depth�_types_namespacer�r�r��intr��bool | Nonec��|s	|jrdSd|jvrt|d��|�|���}n�|dkrRt	j|���pi}t
j|j��pi}i|�|�}t
j	|��|_nt
j|j��}t	j
||��}i|j�ddi�}t
j||j
tj|d���||���S)	a1Try to rebuild the pydantic-core schema for the model.

        This may be necessary when one of the annotations is a ForwardRef which could not be resolved during
        the initial attempt to build the schema, and automatic rebuilding fails.

        Args:
            force: Whether to force the rebuilding of the model schema, defaults to `False`.
            raise_errors: Whether to raise errors, defaults to `True`.
            _parent_namespace_depth: The depth level of the parent namespace, defaults to 2.
            _types_namespace: The types namespace, defaults to `None`.

        Returns:
            Returns `None` if the schema is already "complete" and rebuilding was not required.
            If rebuilding _was_ required, returns `True` if rebuilding was successful, otherwise `False`.
        Nr;r)�parent_depth�defer_buildF)�check)r��types_namespace)r:rN�delattrrr�parent_frame_namespacer�unpack_lenient_weakvaluedictr?�build_lenient_weakvaluedict�get_cls_types_namespacer5�complete_model_classr�r�
ConfigWrapper)	rnr�r�r�r�r��frame_parent_ns�
cls_parent_ns�configs	         rX�
model_rebuildzBaseModel.model_rebuild�s=��0�	��2�	��4�)�S�\�9�9���7�8�8�8��+�9I�9N�9N�9P�9P���*�Q�.�.�&3�&J�Xo�&p�&p�&p�&v�tv�O�+�H��Ij�k�k�q�oq�"�'K��&J�/�&J�O�8K�8g�hw�8x�8x�C�5�5�&9�&V��9�'�'�O�#0�"G��_�"]�"]��@��(�?�-��?�?�F�&�;�����%�f�E�:�:�:�)� /����
rZ��strict�from_attributes�context�objr�r�r�c�B�d}|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�rT)rnr�r�r�r�rWs      rX�model_validatezBaseModel.model_validate�s3��0!���)�9�9�����:�
�
�	
rZ�r�r��	json_data�str | bytes | bytearrayc�@�d}|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�)rC�
validate_json)rnr�r�r�rWs     rX�model_validate_jsonzBaseModel.model_validate_json�s)��,!���)�7�7�	�&�Za�7�b�b�brZc�@�d}|j�|||���S)aRValidate the given object contains string data against the Pydantic model.

        Args:
            obj: The object contains string data to validate.
            strict: Whether to enforce types strictly.
            context: Extra variables to pass to the validator.

        Returns:
            The validated Pydantic model.
        Tr�)rC�validate_strings)rnr�r�r�rWs     rX�model_validate_stringsz BaseModel.model_validate_stringss)��&!���)�:�:�3�v�W^�:�_�_�_rZ�_BaseModel__source�type[BaseModel]�_BaseModel__handlerrr&c�R�d|jvr|jds|jS||��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)rNr>r;)rnr�r�s   rX�__get_pydantic_core_schema__z&BaseModel.__get_pydantic_core_schema__*s<��&���5�5��4�X�>�
4��3�3��y��"�"�"rZ�_BaseModel__core_schemarr!c��||��S)acHook 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^)rnr�r�s   rX�__get_pydantic_json_schema__z&BaseModel.__get_pydantic_json_schema__Bs��.�y��'�'�'rZ�kwargsc��dS)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^�rnr�s  rX�__pydantic_init_subclass__z$BaseModel.__pydantic_init_subclass__[s	��"	
�rZ�typevar_values�!type[Any] | tuple[type[Any], ...]�3type[BaseModel] | _forward_ref.PydanticRecursiveRefc��
�tj||��}|�|S|turtd���t	|d��st|�d����|jds%tj|jvrt|�d����t|t��s|f}tj||��tt|jd|�����
tj�
����
�����r�
r|}tj|||���nI|jd}|s|}nt�
fd�|D����}|jdp|}|�|��}td	�tj�
�����D����}tj||��5}	|	�|	cddd��Stj||||��}|�|cddd��S	|�d
���n#t0$rYnwxYwtj||||��}tj|||||��ddd��n#1swxYwY|S)NzAType parameters should be placed on typing.Generic, not BaseModel�__parameters__zG cannot be parametrized because it does not inherit from typing.Generic�
parametersz is not a generic class�argsc3�B�K�|]}tj|���V��dS�N)r�
replace_types)ra�arg�typevars_maps  �rX�	<genexpr>z.BaseModel.__class_getitem__.<locals>.<genexpr>�s0�����_�_�C�Y�4�S�,�G�G�_�_�_�_�_�_rZr�c��i|]}|d��Sr�r^r�s  rXrdz/BaseModel.__class_getitem__.<locals>.<dictcomp>�s��c�c�c����c�c�crZ�)r�)r�get_cached_generic_type_earlyr0r��hasattrr>r�r��	__bases__r��tuple�check_parameters_count�dict�zipr�
all_identicalr}rr�set_cached_generic_typer��iter_contained_typevars�generic_recursion_self_type�get_cached_generic_type_later�r�create_generic_submodel)rnr��cached�submodel�parent_argsr�r��
model_namer��maybe_self_typers          @rX�__class_getitem__zBaseModel.__class_getitem__nsi����8��n�M�M�����M��)����_�`�`�`��s�,�-�-�	m��s�k�k�k�l�l�l��0��>�	=�6�>�Y\�Yf�Cf�Cf��s�;�;�;�<�<�<��.�%�0�0�	/�,�.�N��(��n�=�=�=�DH���1�,�?��P�P�D
�D
����� 1� 1� 3� 3�\�5H�5H�5J�5J�K�K�%	_�P\�%	_��H��-�c�>�8�L�L�L�L��;�F�C�K��
`�%����_�_�_�_�S^�_�_�_�_�_���6�x�@�G�C�F��7�7��=�=�J��c�c�)�*K�L�L_�L_�La�La�*b�*b�c�c�c���F��6�v�t�D�D�
_��"�.�*�
_�
_�
_�
_�
_�
_�
_�
_�#�?��^�U[�]a�b�b���%�!�

_�
_�
_�
_�
_�
_�
_�
_���(�(��(�C�C�C�C��2�����D�	����%�<�Z��QU�W]�^�^���1�#�~�x�QW�Y]�^�^�^�+
_�
_�
_�
_�
_�
_�
_�
_�
_�
_�
_����
_�
_�
_�
_�.�s<�I/�%I/�
H$�#I/�$
H1�.I/�0H1�12I/�/I3�6I3c��t|��}|�|��}t|dt|j����t|dt|j����t|dt|j����|j�t|dd��n2t|dd�|j���D����|S)z$Returns a shallow copy of the model.rNrFrHNrIc�,�i|]\}}|tu�||��Sr^rr`s   rXrdz&BaseModel.__copy__.<locals>.<dictcomp>�s)��b�b�b�$�!�Q�q�Pa�Ga�Ga��A�Ga�Ga�GarZ)	�typerwr�rrNrFrHrIrf)rhrnr�s   rXr�zBaseModel.__copy__�s����4�j�j���K�K�������:�t�D�M�':�':�;�;�;���/��d�6M�1N�1N�O�O�O���4�d�4�;W�6X�6X�Y�Y�Y��$�,��A�5�t�<�<�<�<���&�b�b�$�";�"A�"A�"C�"C�b�b�b�
�
�
��rZ�memo�dict[int, Any] | Nonec	���t|��}|�|��}t|dt|j|�����t|dt|j|�����t|dt
|j����|j�t|dd��nAt|dtd�|j�	��D��|�����|S)z!Returns a deep copy of the model.rN)rrFrHNrIc�,�i|]\}}|tu�||��Sr^rr`s   rXrdz*BaseModel.__deepcopy__.<locals>.<dictcomp>�s*��k�k�k�4�1�a�PQ�Yj�Pj�Pj�!�Q�Pj�Pj�PjrZ)
rrwr�rrNrFrrHrIrf)rhrrnr�s    rXr�zBaseModel.__deepcopy__�s����4�j�j���K�K�������:�x��
�D�'I�'I�'I�J�J�J���/��$�:Q�X\�1]�1]�1]�^�^�^�	��4�d�4�;W�6X�6X�Y�Y�Y��$�,��A�5�t�<�<�<�<���&��k�k�4�+D�+J�+J�+L�+L�k�k�k�rv�w�w�w�
�
�
��rZ�itemc����t�|d��}||vr�||}t|d��r#|�|t	|����S	|j|S#t$r,}tt	|��j�d|����|�d}~wwxYw	t�|d��}n#t$rd}YnwxYw|�B	||S#t$r,}tt	|��j�d|����|�d}~wwxYwt|j	|��r!t���|��Stt	|��j�d|�����)Nr8�__get__� object has no attribute rF)�object�__getattribute__rr"rrI�KeyError�AttributeErrorr��	__class__�super)rhr �private_attributes�	attribute�exc�pydantic_extrar(s      �rX�__getattr__zBaseModel.__getattr__�s����!'�!8�!8��?W�!X�!X���)�)�)�.�t�4�	��9�i�0�0�?�$�,�,�T�4��:�:�>�>�>�o��4�T�:�:���o�o�o�(�D��J�J�,?�)d�)d�\`�)d�)d�e�e�kn�n�����o����
*�%+�%<�%<�T�CW�%X�%X�N�N��%�*�*�*�%)�N�N�N�*����"�-�s�-�d�3�3��#�s�s�s�,��T�
�
�0C�-h�-h�`d�-h�-h�i�i�or�r�����s�����t�~�t�4�4�j�$�w�w�7�7��=�=�=�-��T�
�
�0C�-h�-h�`d�-h�-h�i�i�isB�A*�*
B �4'B�B �$C�C�C�C�
D�''D�Dr��valuec
���||jvr/t|�d|jj�d|jj�d|�d����t	j|��sb|j�	||jvrt|||��n>|j|}t|d��r|�
||��n
||j|<dS|j�dd��r2d|f|d�}tj�|jj|g���t!|j�|��dd	��r2d
|f|d�}tj�|jj|g���t!|j|d��}t%|t&��r|�
||��dS|j�dd��r|j�|||��dS|j�d��d
kr)||jvr t-d|jj�d|�d����|j�d��d
kr||jvr||j|<dS||j|<|j�|��dS)Nz is a ClassVar of `zR` and cannot be set on an instance. If you want to set a value on the class, use `�.z
 = value`.�__set__�frozen�frozen_instance�r�loc�inputF�frozen_field�validate_assignmentrurv�"z" object has no field ")r7r'r(r�r
�is_valid_field_namerIr8r�rr2r5r�
pydantic_core�ValidationError�from_exception_data�getattrr6r��propertyrCr9�
ValueErrorrFrNrH�add)rhr�r/r+�error�attrs      rX�__setattr__zBaseModel.__setattr__�s����4�&�&�&� ��l�l�d�n�.E�l�l�AE��AX�l�l�[_�l�l�l���
��,�T�2�2�	f��(�0�D��@[�4[�4[���d�E�2�2�2�2� �7��=�	��9�i�0�0�<��%�%�d�E�2�2�2�2�6;�D�-�d�3��F�
�
�
"�
"�8�T�
2�
2�
	f�)��w��5�5�E�
 �/�C�C�D�N�D[�^c�]d�e�e�e�
�T�&�*�*�4�0�0�(�E�
B�
B�	f�&��w��5�5�E�
 �/�C�C�D�N�D[�^c�]d�e�e�e��t�~�t�T�2�2���d�H�%�%�	3��L�L��u�%�%�%�%�%�
�
�
"�
"�#8�$�
?�
?�
	3��'�;�;�D�$��N�N�N�N�N�
�
�
"�
"�7�
+�
+�w�
6�
6�4�t�GX�;X�;X��X���!8�X�X�QU�X�X�X�Y�Y�Y�
�
�
"�
"�7�
+�
+�w�
6�
6�4�t�GX�;X�;X�,1�D�#�D�)�)�)�"'�D�M�$���(�,�,�T�2�2�2�2�2rZc�(�||jvrx|j|}t|d��r|�|��dS	|j|=dS#t$r,}tt
|��j�d|����|�d}~wwxYw||jvrt�
||��dS|j�||jvr
|j|=dS	t�
||��dS#t
$r'tt
|��j�d|�����wxYw)N�
__delete__r#)r8rrGrIr&r'rr�r6r$�__delattr__rF)rhr r+r,s    rXrHzBaseModel.__delattr__'sc���4�.�.�.��3�D�9�I��y�,�/�/�
��$�$�T�*�*�*���
k��-�d�3�3�3���
k�
k�
k�$��T�
�
�(;�%`�%`�X\�%`�%`�a�a�gj�j�����
k����
�T�&�
&�
&����t�T�*�*�*�*�*�
�
$�
0�T�T�=T�5T�5T��'��-�-�-�
b��"�"�4��.�.�.�.�.��!�
b�
b�
b�$��T�
�
�(;�%`�%`�X\�%`�%`�a�a�a�
b���s#�A	�	
A?�'A:�:A?�C � 1D�dict[Any, Any]c�|�|j}|rd�|���D��}|j|j|j|d�S)Nc�,�i|]\}}|tu�||��Sr^rr`s   rXrdz*BaseModel.__getstate__.<locals>.<dictcomp>@s)��V�V�V���1�1�DU�;U�;U�q�!�;U�;U�;UrZ)rNrFrHrI)rIrfrNrFrH)rh�privates  rX�__getstate__zBaseModel.__getstate__=sQ���+���	W�V�V��
�
���V�V�V�G��
�"&�"9�'+�'C�$+�	
�
�	
rZ�statec��t|d|d��t|d|d��t|d|d��t|d|d��dS)NrHrFrIrN)r�)rhrNs  rX�__setstate__zBaseModel.__setstate__Hsj����7��?X�9Y�Z�Z�Z���2�E�:N�4O�P�P�P���4�e�<R�6S�T�T�T���j�%�
�*;�<�<�<�<�<rZ�otherc��t|t��r^|jdp|j}|jdp|j}||ko/|j|jko|j|jko|j|jkStS)Nr�)r�r0r>r(rNrIrF�NotImplemented)rhrQ�	self_type�
other_types    rX�__eq__zBaseModel.__eq__Ns����e�Y�'�'�	"��:�8�D�V���I��<�X�F�Y�%�/�J��Z�'�H��M�U�^�3�H��-��1K�K�H��+�u�/G�G�	
�"�!rZ�Unpack[ConfigDict]c��dS)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  rX�__init_subclass__zBaseModel.__init_subclass__ds���rZ�TupleGeneratorc#�K�d�|j���D��Ed{V��|j}|r|���Ed{V��dSdS)zSo `dict(model)` works.c�F�g|]\}}|�d���||f��S)�_)�
startswithr`s   rXr�z&BaseModel.__iter__.<locals>.<listcomp>}s2��X�X�X�v��1�a�l�l�SV�FW�FW�X�Q��F�X�X�XrZN)rNrfrF)rhrus  rX�__iter__zBaseModel.__iter__{sz����X�X���)<�)<�)>�)>�X�X�X�X�X�X�X�X�X�X��'���	%��{�{�}�}�$�$�$�$�$�$�$�$�$�	%�	%rZc�\�|����d|�d���d�S)N�(r��))�
__repr_name__�__repr_str__rgs rX�__repr__zBaseModel.__repr__�s3���$�$�&�&�C�C��):�):�4�)@�)@�C�C�C�CrZ�_repr.ReprArgsc#��K��j���D].\}}�j�|��}|r
|jr||fV��/	t
��d��}n#t$rd}YnwxYw|�$d�|���D��Ed{V���fd��j���D��Ed{V��dS)NrFc3�$K�|]\}}||fV��dSr�r^r`s   rXrz*BaseModel.__repr_args__.<locals>.<genexpr>�s*����B�B�4�1�a��A��B�B�B�B�B�BrZc3�P�K�|] \}}|j�|t�|��fV��!dSr�)�reprr?)rarbrcrhs   �rXrz*BaseModel.__repr_args__.<locals>.<genexpr>�s?�����c�c�d�a��\]�\b�c�Q���a�(�(�)�c�c�c�c�c�crZ)	rNrfr6rrjr$r%r'ri)rhrbrcr�r-s`    rX�
__repr_args__zBaseModel.__repr_args__�s������M�'�'�)�)�	�	�D�A�q��%�)�)�!�,�,�E��
���
���d�
�
�
��	"�#�4�4�T�;O�P�P�N�N���	"�	"�	"�!�N�N�N�	"�����%�B�B�>�+?�+?�+A�+A�B�B�B�B�B�B�B�B�B�B�c�c�c�c�d�6P�6V�6V�6X�6X�c�c�c�c�c�c�c�c�c�c�c�cs�
A)�)A8�7A8c�,�|�d��S)N� )rdrgs rX�__str__zBaseModel.__str__�s��� � ��%�%�%rZ�EThe `__fields__` attribute is deprecated, use `model_fields` instead.)�category�dict[str, FieldInfo]c�D�tjdt��|jS)Nro)r��warn�DeprecationWarningr6rgs rX�
__fields__zBaseModel.__fields__�s!��
	�
�]�_q�r�r�r�� � rZ�MThe `__fields_set__` attribute is deprecated, use `model_fields_set` instead.c�D�tjdt��|jS)Nrv)r�rsrtrHrgs rX�__fields_set__zBaseModel.__fields_set__�s)��	�
�[�]o�	
�	
�	
��+�+rZ�:The `dict` method is deprecated; use `model_dump` instead.�r�r�r�r�r�r��typing.Dict[str, Any]c�l�tjdt��|�||||||���S)Nryrz)r�rsrtr�)rhr�r�r�r�r�r�s       rXrzBaseModel.dict�sE��	�
�R�Tf�g�g�g�������'�-�%�
�
�
�	
rZ�?The `json` method is deprecated; use `model_dump_json` instead.)r�r�r�r�r�r��encoder�models_as_dictr~�"typing.Callable[[Any], Any] | Noner�dumps_kwargsc���tjdt��|turt	d���|turt	d���|	rt	d���|�||||||���S)Nr}zMThe `encoder` argument is no longer supported; use field serializers instead.zUThe `models_as_dict` argument is no longer supported; use a model serializer instead.z9`dumps_kwargs` keyword arguments are no longer supported.rz)r�rsrtr	r�r�)
rhr�r�r�r�r�r�r~rr�s
          rX�jsonzBaseModel.json�s��� 	�
�W�Yk�l�l�l��+�+�+��k�l�l�l��!2�2�2��s�t�t�t��	Y��W�X�X�X��#�#����'�-�%�
$�
�
�	
rZ�CThe `parse_obj` method is deprecated; use `model_validate` instead.c�`�tjdt��|�|��S)Nr��r�rsrtr��rnr�s  rX�	parse_objzBaseModel.parse_obj�s,��
	�
�[�]o�p�p�p��!�!�#�&�&�&rZ��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_pickle�b�str | bytesr��
str | Noner�r��DeprecatedParseProtocol | Noner�c�
�tjdt��ddlm}	|�|||||���}n�#ttf$r�}ddl}	t|t��rd}
n2t||	j��rd}
nt|t��rd}
nd	}
tj
|
t|����d
|d�}tj�|j|g���d}~wwxYw|�|��S)Nr�r
��parse�r�r�r�r�rzvalue_error.unicodedecodezvalue_error.jsondecode�value_error�
type_error)�__root__r5)r�rsrt�
deprecatedr��load_str_bytesrAr�r�r��UnicodeDecodeError�JSONDecodeErrorr<�PydanticCustomErrorr�r=r>r�r�)rnr�r�r�r�r�r�r�r,r��type_strrCs            rX�	parse_rawzBaseModel.parse_raw�sP��	�
�
I��	
�	
�	
�
	&�%�%�%�%�%�	[��&�&���)�!�)�'���C�C���I�&�	[�	[�	[��K�K�K��#�1�2�2�
(�6����C��!5�6�6�
(�3����C��,�,�
(�(���'��
&�9�(�C��H�H�M�M�$��	5�5�E� �/�C�C�C�L�SX�RY�Z�Z�Z�����)	[����*�!�!�#�&�&�&s�=�C-�BC(�(C-z�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.�path�
str | Pathc��tjdt��ddlm}|�|||||���}|�|��S)Nz�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.r
r�r�)r�rsrtr�r��	load_filer�)rnr�r�r�r�r�r�r�s        rX�
parse_filezBaseModel.parse_file)sp��	�
�
L��	
�	
�	
�
	&�%�%�%�%�%��o�o���%��%��
�
���}�}�S�!�!�!rZzqThe `from_orm` method is deprecated; set `model_config['from_attributes']=True` and use `model_validate` instead.c��tjdt��|j�dd��stdd����|�|��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�rL)r�rsrtr5rrr�r�s  rX�from_ormzBaseModel.from_ormHsq��	�
�
0��	
�	
�	
�
��#�#�$5�t�<�<�	�#�Z�ae����
��!�!�#�&�&�&rZ�DThe `construct` method is deprecated; use `model_construct` instead.c�T�tjdt��|jdd|i|��S)Nr�rpr^)r�rsrtr�)rnrprrs   rX�	constructzBaseModel.constructZs6��
	�
�\�^p�q�q�q�"�s�"�E�E�{�E�f�E�E�ErZz8The copy method is deprecated; use `model_copy` instead.)r�r�r~r��+AbstractSetIntStr | MappingIntStrAny | None�typing.Dict[str, Any] | Nonec
��tjdt��ddlm}t|�|dd||d���fi|pi��}|j�d}n#d�|j���D��}|j	�d}n||j	�
��}t|j	��D]}	|	|vr|�|	���t|��D]#}	|	|j	vr|�|	��||	<�$|r|j
|���z}
nt|j
��}
|r|
t|��z}
|�|||
|||���S)	a�Returns a copy of the model.

        !!! warning "Deprecated"
            This method is now deprecated; use `model_copy` instead.

        If you need `include` or `exclude`, use:

        ```py
        data = self.model_dump(include=include, exclude=exclude, round_trip=True)
        data = {**data, **(update or {})}
        copied = self.model_validate(data)
        ```

        Args:
            include: Optional set or mapping
                specifying which fields to include in the copied model.
            exclude: Optional set or mapping
                specifying which fields to exclude in the copied model.
            update: Optional dictionary of field-value pairs to override field values
                in the copied model.
            deep: If True, the values of fields that are Pydantic models will be deep copied.

        Returns:
            A copy of the model with included, excluded and updated fields as specified.
        z�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
��copy_internalsF)�to_dictr�r�r�r�Nc�,�i|]\}}|tu�||��Sr^rr`s   rXrdz"BaseModel.copy.<locals>.<dictcomp>�s)��h�h�h���1�Q�Vg�Mg�Mg�q�!�Mg�Mg�MgrZ)r�)r�rsrtr�r�r�_iterrIrfrFr�listryrHr}r|�_copy_and_set_values)rhr�r�r~r�r�rrrLrurb�
fields_sets           rXrzBaseModel.copybs���H	�
�
m��	
�	
�	
�
	/�.�.�.�.�.��� � ��e�e�W�g�ej�
!�
�
�
�
��|��	
�
���$�,��G�G�h�h��(A�(G�(G�(I�(I�h�h�h�G��"�*�+/�E�E��+�0�0�2�2�E��$�1�2�2�
!�
!���F�?�?��I�I�a�L�L�L���&�\�\�
-�
-����/�/�/�%�z�z�!�}�}�E�!�H���	;��5����
�
�E�J�J��T�9�:�:�J��	'��#�g�,�,�&�J��2�2�4���U�T[�bf�2�g�g�grZ�CThe `schema` method is deprecated; use `model_json_schema` instead.c�d�tjdt��|�||���S)Nr��r�r�)r�rsrtr")rnr�r�s   rX�schemazBaseModel.schema�s1��	�
�[�]o�p�p�p��$�$�h�\�$�R�R�RrZ�WThe `schema_json` method is deprecated; use `model_json_schema` and json.dumps instead.r�c��ddl}tjdt��ddlm}|j|�||���fd|i|��S)Nrr�r
)�pydantic_encoderr��default)r�r�rsrt�deprecated.jsonr��dumpsr")rnr�r�r�r�r�s      rX�schema_jsonzBaseModel.schema_json�s~��	�����
�e��	
�	
�	
�	6�5�5�5�5�5��t�z��!�!�8�,�!�O�O�
�
�$�
��
�
�	
rZ�BThe `validate` method is deprecated; use `model_validate` instead.c�`�tjdt��|�|��S)Nr�r�)rnr/s  rX�validatezBaseModel.validate�s,��
	�
�Z�\n�o�o�o��!�!�%�(�(�(rZ�LThe `update_forward_refs` method is deprecated; use `model_rebuild` instead.�localnsc��tjdt��|rtd���|�d���dS)Nr�z,`localns` arguments are not longer accepted.T)r�)r�rsrtr�r�)rnr�s  rX�update_forward_refszBaseModel.update_forward_refs�sU��	�
�Z�\n�	
�	
�	
��	L��J�K�K�K������%�%�%�%�%rZ�HThe private method `_iter` will be removed and should no longer be used.r�c�d�tjdt��ddlm}|j|g|�Ri|��S)Nr�r
r�)r�rsrtr�r�r��rhr�r�r�s    rXr�zBaseModel._iter�sM��	�
�`�bt�u�u�u�.�.�.�.�.�.�#�~�#�D�:�4�:�:�:�6�:�:�:rZzWThe private method `_copy_and_set_values` will be removed and should no longer be used.c�d�tjdt��ddlm}|j|g|�Ri|��S)NzXThe private method  `_copy_and_set_values` will be removed and should no longer be used.r
r�)r�rsrtr�r�r�r�s    rXr�zBaseModel._copy_and_set_values�sU��
	�
�f��	
�	
�	
�	/�.�.�.�.�.�2�~�2�4�I�$�I�I�I�&�I�I�IrZzMThe private method `_get_value` will be removed and should no longer be used.c�d�tjdt��ddlm}|j|g|�Ri|��S)NzNThe private method  `_get_value` will be removed and should no longer be used.r
r�)r�rsrtr�r��
_get_value)rnr�r�r�s    rXr�zBaseModel._get_value�sU��	�
�\�^p�	
�	
�	
�	/�.�.�.�.�.�(�~�(��>�t�>�>�>�v�>�>�>rZ�RThe private method `_calculate_keys` will be removed and should no longer be used.c�d�tjdt��ddlm}|j|g|�Ri|��S)Nr�r
r�)r�rsrtr�r��_calculate_keysr�s    rXr�zBaseModel._calculate_keys	sU��
	�
�`�bt�	
�	
�	
�	/�.�.�.�.�.�-�~�-�d�D�T�D�D�D�V�D�D�DrZ)rOrrPrQ)rPr[)rPrE)rPrGr�)rnrorprqrrrrPr/)rhr/r~rEr�r�rPr/)r�r�r�r2r�r2r�r�r�r�r�r�r�r�r�r�r�r�rPr�)r�r�r�r2r�r2r�r�r�r�r�r�r�r�r�r�r�r�rPr�)
r�r�r�r�r�r�r�r rPr�)r�r�rPr�)r�rrPrQ)
r�r�r�r�r�r�r�rErPr�)rnror�rr�r�r�r�r�rErPr/)
rnror�r�r�r�r�rErPr/)
rnror�rr�r�r�rErPr/)r�r�r�rrPr&)r�r&r�rrPr!)r�rrPrQ)r�r�rPr�)rhr/rPr/)rhr/rrrPr/)r r�rPr)r�r�r/rrPrQ)rPrI)rNrIrPrQ)rQrrPr�)r�rW)rPrZ)rPr�)rPrf)rPrq)r�r2r�r2r�r�r�r�r�r�r�r�rPr{)r�r2r�r2r�r�r�r�r�r�r�r�r~r�rr�r�rrPr�)rnror�rrPr/)rnror�r�r�r�r�r�r�r�r�r�rPr/)rnror�r�r�r�r�r�r�r�r�r�rPr/)rhr/r�r�r�r�r~r�r�r�rPr/)r�r�r�r�rPr{)r�r�r�r�r�rrPr�)rnror/rrPr/)r�rrPrQ)r�rr�rrPr)Zr��
__module__�__qualname__�__doc__r��
TYPE_CHECKING�__annotations__�_FieldrFrHrIr6r�DecoratorInfosr=r�
MockValSerrCrB�	__slots__rr5r:rArY�__pydantic_base_init__r@rirkrm�classmethodr�r�r�r�rrr"r�r�r�r�r�r�r�r�r�rr�r�r.rErHrMrPrVrYr_rerkr�Representationrcrd�
__pretty__�
__rich_repr__rn�typing_extensionsr�r#rurxrr	r�r�r�r�r�r�rr�r�r�r�r�r�r�r��
__classcell__)r(s@rXr0r0<s����������8��8
�	+�*�*�*�	�	5�4�4�4�	�	+�*�*�*�E�E�E�E�*�*�*�*�-�-�-�-�6�6�6�6�0�0�0�0�E�E�E�E�R�R�R�R�F�F�F�F�K�K�K�K�/�/�/�/�;�;�;�;�9�9�9�9�
5;�F��4F�4F�4F��F�F�F�F�,2�F��,>�,>�,>��>�>�>�>�6<�f�%�6H�6H�6H��H�H�H�H�H���"<�+�"<�">�">��!9��!9�f�"�*�"
�"
�"
��
#;�-�":�f�#�*�#
�#
�#
��d�I��:�<�<�L�!��#��h�h�h�h�'+�H�#�
�\�\�\��X�\��'�'�'��X�'��,�,�,��X�,��/�/�/�/��[�/�bDH�V[�������>19����#�!&�"� ��,
�,
�,
�,
�,
�,
�b"����#�!&�"� ��*�*�*�*�*�*�X��0�5G�+�
�
�
�
��[�
�.�5�5�5��[�5�4
�
�
�
���!�'(�26�
5�5�5�5�5��[�5�n�
#�'+�)-�

�
�
�
�
��[�
�8�
#�)-�c�c�c�c�c��[�c�0�
#�)-�`�`�`�`�`��[�`�*�#�#�#��[�#�.�(�(�(��[�(�0�
�
�
��[�
�$>�>�>�>�@����&�����*��!j�	j�	j�	j�	j�	j�	j�@,3�,3�,3�,3�\b�b�b�b�,	
�	
�	
�	
�=�=�=�=�"�"�"�"�"���
	�	�	�	�.%�%�%�%�D�D�D�D�d�d�d�d�(�(�6�M��'�4�L��%�0�J��(�6�M�&�&�&�&��!��!�O�Zs����!�!�!����X�!��!��!�W�*����,�,�,�	���X�
,�"��!�D�Oh�������#�!&�"�
�
�
�
�
���
�("��!�I�Tm�������#�!&�"�6G�0�
�
�
�
�
���
�:�!��!�M�Xq����'�'�'����[�'��!��!�	E�*����$(��04�"�-'�-'�-'�-'�-'����[�-'�^�!��!�	I�*����$(��04�"�"�"�"�"�"����[�"�2�!��!�	S�*����

'�
'�
'����[�
'��!��!�N�Yr����F�F�F�F����[�F�"��!�B�Mf����@D�?C�/3��
Hh�Hh�Hh�Hh�Hh���Hh�T�!��!�M�Xq����#�8L�S�S�S�S����[�S��!��!�a�*����
"&�;O�
�
�
�
�
�	���[�

�"�!��!�L�Wp����)�)�)����[�)��!��!�V�*����&�&�&�	���[�
&�"��!�R�]v����;�;�;���;�"��!�a�*����J�J�J�	��J��!��!�W�*����?�?�?�	���[�
?�"��!�\�*����E�E�E�	��E�E�E�E�ErZ)�	metaclass)�
__config__�__base__r��__validators__�__cls_kwargs__�__model_namer�r��ConfigDict | Noner�rQr�r�� dict[str, AnyClassMethod] | Noner�rE�field_definitionsrrPr�c��dSr�r^�r�r�r�r�r�r�r�s       rXr3r3�	���CrZ)r�r�r�r��%type[Model] | tuple[type[Model], ...]roc��dSr�r^r�s       rXr3r3%r�rZ)r�r�r�r�r�r��,type[Model] | tuple[type[Model], ...] | Noner��tuple[str, ...] | Nonec��|�tjdt��|�,|�tdd����t	|t
��s|f}n+t
jtjdt��f}|pi}i}i}	|�
��D]�\}
}tj|
��stjd|
�d�t��t	|t
��r@t
jd	|��}	|\}}
n(#t$r}td
d���|�d}~wwxYwd|}
}|r||	|
<|
||
<��|	|d�}|r|�|��|�|��|rtj|��j|d
<t%j|��}t%j|||���\}}}||ur||d<|�|��||||fddi|��S)a�Dynamically creates and returns a new Pydantic model, in other words, `create_model` dynamically creates a
    subclass of [`BaseModel`][pydantic.BaseModel].

    Args:
        __model_name: The name of the newly created model.
        __config__: The configuration of the new model.
        __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 togetherzcreate-model-config-baser�r/z3fields may not start with an underscore, ignoring "r:ztuple[str, Any]z4Field definitions should be a `(<type>, <default>)`.zcreate-model-field-definitions)r�r�r5)�kwds�__orig_bases__�#__pydantic_reset_parent_namespace__F)r�rs�RuntimeWarningrr�r	r��cast�Typer0rfr
r;rAr~rr��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                    rXr3r33s[��@���
�F��W�W�W����!�#�X�/����
��(�E�*�*�	#� �{�H���K���G� 4�i�@�@�B��#�)�r�N�
�F��K�*�0�0�2�2�!�!�
����*�6�2�2�	k��M�Y�PV�Y�Y�Y�[i�j�j�j��e�U�#�#�
	0��K� 1�5�9�9�E�
�(-�%��g�g���
�
�
�'�J�9����������
����%)�%�'�L��	/�".�K��� ��v���4?�z� Z� Z�I��)�����(�(�(�
���V�����R�$+�$9�*�$E�$E�$Q�	�.�!��(��2�2�N��(��~�N�[�[�[�N�D�"�d��X�%�%�'����
���R�����4��n�i�k�k�]b�k�fj�k�k�ks�4C:�:
D�D�D)r�r�r�r�r�rQr�r�r�r�r�rEr�rrPr�)r�r�r�r�r�r�r�r�r�r�r�rEr�rrPro)r�r�r�r�r�r�r�r�r�r�r�rEr�r�r�rrPro)Tr��
__future__r�_annotationsr�r�r�rrrrr<r�r	�	_internalrrr
rrrrrrr�
_migrationr�annotated_handlersrrr�r�errorsrrr�rrr�json_schemarrr r!r"r#r��inspectr$�pathlibr%r&r'r(r)r*�_internal._utilsr+r,�deprecated.parser-�DeprecatedParseProtocolr.r�r��AnyClassMethod�	Generator�Tupler�rZ�TypeVarr/r2r�rt�__all__�object_setattrr��ModelMetaclassr0�overloadr�r3r.r^rZrX�<module>rs��� � � �2�2�2�2�2�2�����
�
�
�
������������� � � � � � � � ���������+�+�+�+�+�+�������������������������*�)�)�)�)�)�J�J�J�J�J�J�J�J�������B�B�B�B�B�B�B�B�B�B�B�B�B�B�B�B�B�B�u�u�u�u�u�u�u�u�u�u�u�u�u�u�/�/�/�/�/�/�	��3�!�!�!�!�!�!�������K�K�K�K�K�K�K�K�K�K�1�1�1�1�1�1�1�1�E�E�E�E�E�E�E�E�E�E�E�E�E�E�'�'�'�'�'�'� ��c�3��/�N��%�f�l�3��8�&<�d�D�&H�I�N��F�N�7�+�6�6�6�E�)g�E�g�g�g�g�g�3��
%��%�4��XE�XE�XE�XE�XE�-�<�XE�XE�XE�XE�v&��%)���7;�,0�
�
�
�
�
���
���%)��7;�,0�
�
�
�
�
���
� %)�=A��7;�,0�(,�Rl�Rl�Rl�Rl�Rl�Rl�j ���)�)���rZ