Viewing File: /opt/hc_python/lib/python3.12/site-packages/pydantic/v1/__pycache__/typing.cpython-312.pyc

�

e��g�K�
��UddlZddlZddlmZddlmZddlmZmZmZmZ	m
Z
mZmZm
Z
mZmZmZmZmZmZmZmZmZmZmZmZmZmZddlmZmZmZm Z!m"Z#	ddlm$Z%	ddlm(Z)	dd
l*m+Z,ejZdkr
ded
ededefd�Z.nded
ededefd�Z.ejZdkreZ/n
dTded
ededefd�Z/ed�Z0e	defZ1e	gefZ2e	de0fZ3ddhZ4ehZ5eee6d<e7ed�re5jqej>�ejZdkrdeedeeefd�Z9nddlm9Z:deedeeefd�Z9ejZdkrdd lm;Z;deedeedffd!�Z<n&dd"lm<Z=deedeedffd#�Z>deedeedffd$�Z<ejZdkrdeedeefd%�Z?ndd&lm@Z@dd'lmAZAdeedeefd(�Z?ejZd)krdeeedeBfd*�ZCe)fZDn9ddl*Z*ddlZdeeedeBfd+�ZCejve*jPe*jVfZDeeEefZFerldd,lGmHZHe
eeEefddfZIeeEefZJeeefZKeeEZLeeEZMeeNeEfZOeeOZPeeOefZQeeOefZRe
e1ddfZSeeeeEefZTd-ZUeUreVeZWneVeeefZWd.ZXdj�ZZdeZedfZ[eeeefe6d/<ejZdkr	dedeBfd0�Z\n#ejZdd1dk(r	dedeBfd2�Z\ndedeBfd3�Z\d4eedeEfd5�Z]d6eeEeefd7eeEdeeEeeffd8�Z^deedeBfd9�Z_deedeBfd:�Z`deedeedffd;�Zadeedeedffd<�ZbdeedeBfd=�ZcdeedeBfd>�ZddedeBfd?�ZededeBfd@�ZfedAeE�ZgdeedeBfdB�ZhdeedeefdC�Zid4eeedeBfdD�Zjd4eeedeBfdE�ZkdFeedeBfdG�ZldFeedeBfdH�ZmdIdJd
ededdfdK�Zn	dUdLeedMedJdNeeeeeEefe1fddOdPeeeodfddfdQ�ZpdeededeBeeffdR�ZqdedeefdS�Zry#e&$r
ddlm'Z%Y���wxYw#e&$rd	Z)Y���wxYw#e&$rd	Z,Y���wxYw)V�N)�Callable)�PathLike)�
TYPE_CHECKING�AbstractSet�Anyr�ClassVar�Dict�
ForwardRef�	Generator�Iterable�List�Mapping�NewType�Optional�Sequence�Set�Tuple�Type�TypeVar�Union�
_eval_type�cast�get_type_hints)�	Annotated�Final�Literal�NotRequired�Required)�_TypingBase)�_Final)�GenericAlias�)�	UnionType���	�type_�globalns�localns�returnc�&�|j||�S�N)�	_evaluate�r'r(r)s   �A/opt/hc_python/lib/python3.12/site-packages/pydantic/v1/typing.py�evaluate_forwardrefr0:s�����x��1�1�c�V�tt|�j||t���S)N)�recursive_guard)rrr-�setr.s   r/r0r0?s%��
�C���)�)�(�G�S�U�)�S�Sr1�objc� �t|||d��S)NT)�include_extras)r)r5r(r)s   r/�get_all_type_hintsr8Os���c�8�W�T�J�Jr1�_T.�
AnnotatedMeta�_AnnotatedAlias�
LITERAL_TYPESr�r%��tc��t|�jtvrttt
t�St|dd�S)N�
__origin__)�type�__name__�AnnotatedTypeNamesrrrr�getattr)r?s r/�
get_originrFhs5����7���1�1���S�	�9�-�-��q�,��-�-r1)rF�tpc��t|�jtvrttt
t�St|�xs
t|dd�S)a4
        We can't directly use `typing.get_origin` since we need a fallback to support
        custom generic classes like `ConstrainedList`
        It should be useless once https://github.com/cython/cython/issues/3537 is
        solved and https://github.com/pydantic/pydantic/pull/1753 is merged.
        rAN)	rBrCrDrrrr�_typing_get_originrE�rGs r/rFrFqsA����8��� 2�2���S�	�9�-�-�!�"�%�H���\�4�)H�Hr1)�
_GenericAliasc�$�t|�jtvr|j|jzSt|t�r@|j}|jtur |r|dturt|dd�|df}|St|dd�S)z�Compatibility version of get_args for python 3.7.

        Mostly compatible with the python 3.8 `typing` module version
        and able to handle almost all use cases.
        rN����__args__r")rBrCrDrN�__metadata__�
isinstancerKrAr�Ellipsis�listrE)r?�ress  r/�get_argsrT�s�����7���1�1��:�:����.�.��a��'��*�*�C��|�|�x�'�C�C��F�(�4J��C���H�~�s�2�w�/���J��q�*�b�)�)r1�rTc��t|d�rtf|jzS	|tdk(stj
dk\r
|tdk(ryy#t$rYywxYw)aI
        In python 3.9, `typing.Dict`, `typing.List`, ...
        do have an empty `__args__` by default (instead of the generic ~T for example).
        In order to still support `Dict` for example and consider it as `Dict[Any, Any]`,
        we retrieve the `_nparams` value that tells us how many parameters it needs.
        �_nparamsr"r$�r")�hasattrrrWr�sys�version_info�tuple�	TypeErrorrJs r/�_generic_get_argsr^�se���2�z�"��6�B�K�K�'�'�	��U�2�Y��#�"2�"2�f�"<��u�R�y������	���	�s�+A�	A�Ac��t|�jtvr|j|jzSt|�xst
|dd�xst|�S)a�Get type arguments with all substitutions performed.

        For unions, basic simplifications used by Union constructor are performed.
        Examples::
            get_args(Dict[str, int]) == (str, int)
            get_args(int) == ()
            get_args(Union[int, Union[T, int], str][int]) == (int, str)
            get_args(Union[int, Tuple[T, int]][str]) == (int, Tuple[str, int])
            get_args(Callable[[], T][int]) == ([], int)
        rNr")rBrCrDrNrO�_typing_get_argsrEr^rJs r/rTrT�sO����8��� 2�2��;�;����0�0���#�[�w�r�:�r�'B�[�FW�XZ�F[�[r1c��|S)z�Python 3.9 and older only supports generics from `typing` module.
        They convert strings to ForwardRef automatically.

        Examples::
            typing.List['Hero'] == typing.List[ForwardRef('Hero')]
        r"rJs r/�convert_genericsrb�s	���	r1)�_UnionGenericAlias)r;c�|��t��}|rt�d�s�St��}|turt	t|d�|dd�St
�fd�|D��}||k(r�St�t�rt||�St�t�rt||�S	t�d|��S#t$rY�SwxYw)a�
        Recursively searches for `str` type hints and replaces them with ForwardRef.

        Examples::
            convert_generics(list['Hero']) == list[ForwardRef('Hero')]
            convert_generics(dict['Hero', 'Team']) == dict[ForwardRef('Hero'), ForwardRef('Team')]
            convert_generics(typing.Dict['Hero', 'Team']) == typing.Dict[ForwardRef('Hero'), ForwardRef('Team')]
            convert_generics(list[str | 'Hero'] | int) == list[str | ForwardRef('Hero')] | int
        rNr�Nc3��K�|]:}t|t�rt�t�rt|�n
t	|����<y�wr,)rP�str�TypingGenericAliasr
rb)�.0�argrGs  �r/�	<genexpr>z#convert_generics.<locals>.<genexpr>�s<�����
��� *�#�s�3�
�2�GY�8Z�J�s�O�`p�qt�`u�u��s�AA)
rFrYrTrr;rbr\rPrh�TypesUnionTyperc�setattr�AttributeError)rG�origin�args�	converteds`   r/rbrb�s�����B����W�R��4��I���|���Y��"�#3�D��G�#<�d�1�2�h�G�G��
��
�
�	�
����I�
��.�
/�%�f�i�8�8�
��N�
+�%�f�i�8�8�
���J�	�2��I��"�
���I�
�s�
B.�.	B;�:B;�r%�
c��|tuSr,)rrJs r/�is_unionru�s���U�{�r1c�:�|tuxs|tjuSr,)r�typesr#rJs r/ruru�s���U�{�3�b�E�O�O�3�3r1)�
ModelFieldF)'�AnyCallable�NoArgAnyCallable�NoneType�is_none_type�display_as_type�resolve_annotations�is_callable_type�is_literal_type�all_literal_values�
is_namedtuple�is_typeddict�is_typeddict_special�is_new_type�new_type_supertype�is_classvar�is_finalvar�update_field_forward_refs�update_model_forward_refs�TupleGenerator�
DictStrAny�DictAny�SetStr�ListStr�IntStr�AbstractSetIntStr�
DictIntStrAny�CallableGenerator�ReprArgs�AnyClassMethodr��
WithArgsTypesrTrF�
get_sub_types�typing_baser8ru�StrPath�MappingIntStrAny�
NONE_TYPESc��|tvSr,�r��r's r/r|r|R�
���
�"�"r1�c�X�tD]}||us�yt|�rt|�dk(Sy)NTr,F)r�r�r�)r'�	none_types  r/r|r|Ws4��#�I��	�!��$��5�!�%�e�,��7�7�r1c��|tvSr,r�r�s r/r|r|dr�r1�vc	��t|t�s,t|t�st|t�s|j}tt
|��r,ddjttt|����d�St|t�rt|�jdd�S	|jS#t$rt|�jdd�cYSwxYw)NzUnion[z, �]ztyping.�)rPr�r�rB�	__class__rurF�join�mapr}rTrg�replacerCrn�r�s r/r}r}hs����a��%�j��M�.J�S]�^_�ae�Sf�
�K�K���
�1�
����	�	�#�o�x��{�"C�D�E�Q�G�G��!�]�#��1�v�~�~�i��,�,�-��z�z����-��1�v�~�~�i��,�,�-�s�)B5�5$C�C�raw_annotations�module_namec���d}|r 	tj|}|j}i}|j	�D]�\}}t|t�rJdtjcxkDrdk\sntjdk\rt|dd��}n
t|d��}	tjd	k\rt||dd
��}n
t||d�}|||<��|S#t$rY��wxYw#t$rY�#wxYw)z�
    Partially taken from typing.get_type_hints.

    Resolve string or ForwardRef annotations into type objects if possible.
    Nrr)r%r&r>)r%rsreFT)�is_argument�is_class)r�)r%�
r")�type_params)rZ�modules�__dict__�KeyError�itemsrPrgr[r
r�	NameError)r�r��base_globals�module�annotations�name�values       r/r~r~zs���.2�L��	+��[�[��-�F�
"�?�?�L��K�&�,�,�.���e��e�S�!���)�)�6�Y�6�#�:J�:J�j�:X�"�5�e�d�K��"�5�e�<��	����7�*�"�5�,��"�M��"�5�,��=��"��D��/����-�	��	��$�	��	�s#�C�0C �	C�C� 	C,�+C,c�8�|tuxst|�tuSr,)rrFr�s r/rr�s���H��=�
�5� 1�X� =�=r1c�8�tduxrt|�tvSr,)rrFr<r�s r/r�r��s���$��E�:�e�#4�
�#E�Er1c��t|�Sr,rUr�s r/�literal_valuesr��s���E�?�r1c�X�t|�s|fSt|�}td�|D��S)z�
    This method is used to retrieve all Literal values as
    Literal can be used recursively (see https://www.python.org/dev/peps/pep-0586)
    e.g. `Literal[Literal[Literal[1, 2, 3], "foo"], 5, None]`
    c3�@K�|]}t|�D]}|����y�wr,)r�)rir��xs   r/rkz%all_literal_values.<locals>.<genexpr>�s ����J��u�0B�5�0I�1��0I���s�)r�r�r\)r'�valuess  r/r�r��s.���5�!��x��
�E�
"�F��J��J�J�Jr1c�D�ddlm}||t�xrt|d�S)zy
    Check if a given class is a named tuple.
    It can be either a `typing.NamedTuple` or `collections.namedtuple`
    r��lenient_issubclass�_fields)�pydantic.v1.utilsr�r\rY�r'r�s  r/r�r��s ��
5��e�U�+�I���y�0I�Ir1c�D�ddlm}||t�xrt|d�S)z�
    Check if a given class is a typed dict (from `typing` or `typing_extensions`)
    In 3.10, there will be a public method (https://docs.python.org/3.10/library/typing.html#typing.is_typeddict)
    rr��	__total__)r�r��dictrYr�s  r/r�r��s ��
5��e�T�*�J�w�u�k�/J�Jr1c�&�|tuxs|tuSr,)�TypedDictRequired�TypedDictNotRequiredr�s r/�_check_typeddict_specialr��s���%�%�F��2F�)F�Fr1c�D�t|�xstt|��S)zN
    Check if type is a TypedDict special form (Required or NotRequired).
    )r�rFr�s r/r�r��s ��$�E�*�Y�.F�z�RW�GX�.Y�Yr1�	test_typec�R�t|tj�xrt|d�S)z>
    Check whether type_ was created using typing.NewType
    �
__supertype__)rPr�r�rYr�s r/r�r��s#���e�Y�0�0�1�U�g�e�_�6U�Ur1c�P�t|d�r|j}t|d�r�|S)Nr�)rYr�r�s r/r�r��s(��
�%��
)��#�#���%��
)��Lr1c�f�|�y|jtjk(xrt|dd�dk(S)NF�_namer)r�rrEr�s r/�_check_classvarr��s2���y���;�;�(�,�,�,�X���G�T�1J�j�1X�Xr1c��|�y|jtjk(xr%tjdkxst	|dd�dk(S)z9
    Check if a given type is a `typing.Final` type.
    NFr=r�r)r�rrZr[rEr�s r/�_check_finalvarr��sF��	�y���;�;�%�/�/�)�q�s�/?�/?�&�/H�/p�G�TU�W^�`d�Le�ip�Lp�qr1�ann_typec��t|�stt|��ry|jtk(r|jjd�ryy)NTz	ClassVar[F)r�rFr�r
�__forward_arg__�
startswith�r�s r/r�r��sC���x� �O�J�x�4H�$I�����Z�'�H�,D�,D�,O�,O�P[�,\��r1c�D�t|�xstt|��Sr,)r�rFr�s r/r�r�s���8�$�M��
�8�8L�(M�Mr1�fieldrxc��d}|jjtk(r"d}t|j||xsd�|_|jjtk(r"d}t|j||xsd�|_|r|j�|jr|jD]}t|||���|j�|j�yy)z]
    Try to update ForwardRefs on fields based on this ModelField, globalns and localns.
    FTN�r(r))
r'r�r
r0�outer_type_�prepare�
sub_fieldsr��discriminator_key�&prepare_discriminated_union_sub_fields)r�r(r)r��sub_fs     r/r�r�s����G��{�{���
�*���)�%�+�+�x���D�Q������"�"�j�0���/��0A�0A�8�W�_�X\�]����
�
�
������%�%�E�%�e�h��P�&�
���*�
�4�4�6�+r1�model�fields�
json_encodersr��exc_to_suppressc�$�|jtjvr6tj|jjj	�}ni}|j|j|�|D]}	t|||���t|j��D]X}t|t�rt|�}nt|t�r|}n�3	t|||xsd�}	|j|�||	<�Zy#|$rY��wxYw#|$rY�nwxYw)zL
    Try to update model fields ForwardRefs based on model and localns.
    r�N)�
__module__rZr�r��copy�
setdefaultrCr�r4�keysrPrgr
r0�pop)
r�r�r�r)r�r(�f�key�fr�new_keys
          r/r�r�s��
���3�;�;�&��;�;�u�/�/�0�9�9�>�>�@�����������.�
��	�%�a�(�G�L���=�%�%�'�(���c�3��'��_�B�
��Z�
(��B��	�)�"�h���4�H�G�"/�!2�!2�3�!7�
�g��)���	��	���	��	�s$�7C<�D�<D�D�D�Dc�x�|turyt|��yt|�}|rt|dt�sy|dS)z�
    Tries to get the class of a Type[T] annotation. Returns True if Type is used
    without brackets. Otherwise returns None.
    TNr)rBrFrTrP)r'rps  r/�	get_classr�CsA��

��}���%�� ���E�?�D��z�$�q�'�4�0���A�w�r1c���t|�}|turtt|�d�St	|�r+t|�D��cgc]}t|�D]}|���c}}S|gScc}}w)z~
    Return all the types that are allowed by type `tp`
    `tp` can be a `Union` of allowed types or an `Annotated` type
    r)rFrr�rTru)rGror?r�s    r/r�r�Usd��
��^�F�
����X�b�\�!�_�-�-�	�&�	�#�B�<�B�<�a��q�1A�A��1A��<�B�B��t���Cs�A$)NNrX)srZ�typing�collections.abcr�osrrrr�TypingCallablerr	r
rrr
rrrrrrrrrrrr�typing_extensionsrrrrr�rr�rr��ImportErrorr r!rhrwr#rlr[r0r8r9ryrz�AnyArgTCallablerDr<�__annotations__rY�addrFrIrKrTr`r^rbrcr;�boolrur�rgr��pydantic.v1.fieldsrxr�r�r�r�r��intr�r�r�r�r�r��MYPY�classmethodr��__all__r�r{r�r|r}r~rr�r�r�r�r�r�r�r�r�r�r�r�r�r�r��
BaseExceptionr�r�r�r"r1r/�<module>r
sZ��
�
�$��������2��-�1��9�
�1����f��2�:�2��2�s�2�s�2�
T�:�T��T�s�T�s�T����f��(��K��K�s�K�C�K�SV�K�
�T�]���S�#�X�&��!�"�c�'�*��!��b��)��
&�'8�9��#�)�
�s�3�x�#�
�6�9�����f�n�n�%����f��.�d�3�i�.�H�T�#�Y�$7�.�8�	I�t�C�y�	I�X�d�3�i�%8�	I����f��$�
*�D��I�
*�%��S��/�
*� 4��d�3�i��E�#�s�(�O��(\�T�#�Y�\�5��c��?�\�"���f���T�#�Y��4��9��*�1�&�T�#�Y�&�4��9�&�R���g���X�d�3�i�(��T��(�)�M���4�X�d�3�i�(�4�T�4��)�)�5�+=�+=�u���O�M���X�
�
���-��u�S�#�X���d�:�;�N��c�3�h��J��3��8�n�G�
��X�F��3�i�G�
�3��8�_�F�#�F�+������%�M��v�s�{�+��!�+�t�T�"9�:����h�s�m�S�0�1�2�H��D��$�S�)��%�S�#�s�]�3��(��V�>�>��%)�(�G�D�M�#B�
�E�#�s�C�-� �B����f��#�C�#�D�#�	���b�q��V�#�	�C�	�D�	�#�C�#�D�#�-�t�C�y�-�S�-�$ ��c�4��9�n�)=� �H�UX�M� �^b�cf�hl�mp�hq�cq�^r� �F>�D��I�>�$�>�F�4��9�F��F��$�s�)���c�3�h���
K�d�3�i�
K�E�#�s�(�O�
K�J��c��J�t�J�K��S�	�K�d�K�G�C�G�D�G�Z��Z��Z�
�K��%�	�V�t�C�y�V�T�V��d�3�i��D��I��Y�x��S�	�*�Y�t�Y�r�x��S�	�*�r�t�r�	�$�s�)�	��	�N�$�s�)�N��N�7�\�7�S�7�3�7�SW�7�68:�$8���9�$8��\�"�$8���d�3�i��j�8�9�;�F�G�$8��	$8�
�4�
�.��3�4�$8�
�
$8�N�T�#�Y��5��t�T�#�Y�)>�#?��$�c��d�3�i���[�-�,�,�-��
���������N��s6�P�P+�#P9�P(�'P(�+P6�5P6�9Q�Q
Back to Directory File Manager