PK APOCALYPSE V1

APOCALYPSE V1

Current Path : /opt/hc_python/lib/python3.12/site-packages/pydantic/__pycache__/
Upload File :
Current File : //opt/hc_python/lib/python3.12/site-packages/pydantic/__pycache__/mypy.cpython-312.pyc

�

���g������dZddlmZddlZddlmZddlmZmZm	Z	ddl
mZddlm
Z
mZddlmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZm Z m!Z!m"Z"m#Z#m$Z$m%Z%m&Z&m'Z'm(Z(m)Z)m*Z*m+Z+m,Z,m-Z-m.Z.m/Z/dd	l0m1Z1dd
l2m3Z3m4Z4m5Z5m6Z6m7Z7m8Z8m9Z9ddl:m;Z;ddl<m=Z=dd
l>m?Z?ddl@mAZAddlBmCZCddlDmEZEddlFmGZGmHZHmIZImJZJmKZKmLZLmMZMmNZNmOZOmPZPmQZQddlRmSZSddlTmUZUddlVmWZXddlYmZZZddl[m\Z\	ddlFm]Z]dZ_dZ`dZadZbdZcdZddZed Zfd!Zghd"�Zhe\eX�Zieid#k\rd$nd%Zjd&ZWdKd'�ZkGd(�d)e7�ZlGd*�d+�ZmdLd,�ZnGd-�d.�ZoGd/�d0�ZpGd1�d2�ZqGd3�d4�Zred5d6d7�Zsed8d9d7�Zted:d;d7�Zued<d=d7�Zved>d?d7�Zwed>d@d7�Zxed>dAd7�ZydMdB�ZzdNdC�Z{dOdD�Z|								dPdE�Z}dOdF�Z~dQdG�ZdQdH�Z�			dR																	dSdI�Z�dTdJ�Z�y#e^$r
ddlFmOZ]Y��wxYw)Uz^This module includes classes and functions designed specifically for use with the mypy plugin.�)�annotationsN)�ConfigParser)�Any�Callable�Iterator)�	ErrorCode)�expand_type�expand_type_by_instance) �	ARG_NAMED�
ARG_NAMED_OPT�ARG_OPT�ARG_POS�	ARG_STAR2�	INVARIANT�MDEF�Argument�AssignmentStmt�Block�CallExpr�ClassDef�Context�	Decorator�DictExpr�EllipsisExpr�
Expression�FuncDef�IfStmt�JsonDict�
MemberExpr�NameExpr�PassStmt�PlaceholderNode�RefExpr�	Statement�StrExpr�SymbolTableNode�TempNode�	TypeAlias�TypeInfo�Var)�Options)�CheckerPluginInterface�ClassDefContext�FunctionContext�
MethodContext�Plugin�ReportConfigContext�SemanticAnalyzerPluginInterface)�dataclasses)�deserialize_and_fixup_type)�set_callable_name)�make_wildcard_trigger)�state)�map_type_from_supertype)�AnyType�CallableType�Instance�NoneType�
Overloaded�Type�	TypeOfAny�TypeType�TypeVarType�	UnionType�get_proper_type)�
fill_typevars)�get_unique_redefinition_name)�__version__)�_fields)�parse_mypy_version)�
TypeVarDef)rA�
pydantic-mypyzpydantic-mypy-metadatazpydantic.main.BaseModelz#pydantic_settings.main.BaseSettingszpydantic.root_model.RootModelz5pydantic._internal._model_construction.ModelMetaclasszpydantic.fields.Fieldzpydantic.dataclasses.dataclass�.pydantic.functional_validators.model_validator>�*pydantic.functional_serializers.serializer�.pydantic.deprecated.class_validators.validator�.pydantic.functional_validators.field_validator�0pydantic.functional_serializers.model_serializer�3pydantic.deprecated.class_validators.root_validatorrK)ri��builtins�__builtins__�c��tS)a!`version` is the mypy version string.

    We might want to use this to print a warning if the mypy version being used is
    newer, or especially older, than we expect (or need).

    Args:
        version: The mypy version string.

    Return:
        The Pydantic mypy plugin type.
    )�PydanticPlugin)�versions �</opt/hc_python/lib/python3.12/site-packages/pydantic/mypy.py�pluginrXss
����c�l��eZdZdZd�fd�Zd
d�Zdd�Zdd�Zdd�Zdd�Z	dd�Z
dd	�Zdd
�Zdd�Z
�xZS)rUzThe Pydantic mypy plugin.c���t|�|_|jj�|_t�|�|�y�N)�PydanticPluginConfig�
plugin_config�to_data�_plugin_data�super�__init__)�self�options�	__class__s  �rWrbzPydanticPlugin.__init__�s4���1�'�:��� �.�.�6�6�8���
����!rYc���|j|�}|rLt|jt�r2t	d�|jj
D��r|jSy)zUpdate Pydantic model class.c3�BK�|]}|jtk(���y�wr\)�fullname�BASEMODEL_FULLNAME��.0�bases  rW�	<genexpr>z5PydanticPlugin.get_base_class_hook.<locals>.<genexpr>�s����P�<�4�4�=�=�$6�6�<���N)�lookup_fully_qualified�
isinstance�noder)�any�mro�$_pydantic_model_class_maker_callback�rcrh�syms   rW�get_base_class_hookz"PydanticPlugin.get_base_class_hook�sG���)�)�(�3���:�c�h�h��1��P�3�8�8�<�<�P�P��@�@�@�rYc�.�|tk(r|jSy)z,Update Pydantic `ModelMetaclass` definition.N)�MODEL_METACLASS_FULLNAME�)_pydantic_model_metaclass_marker_callback�rcrhs  rW�get_metaclass_hookz!PydanticPlugin.get_metaclass_hook�s���/�/��A�A�A�rYc�h�|j|�}|r|jtk(r|jSy)z/Adjust the return type of the `Field` function.N)rorh�FIELD_FULLNAME�_pydantic_field_callbackrus   rW�get_function_hookz PydanticPlugin.get_function_hook�s/���)�)�(�3���3�<�<�>�1��0�0�0�rYc�2�|jd�rtSy)z-Adjust return type of `from_orm` method call.z	.from_ormN)�endswith�from_attributes_callbackr{s  rW�get_method_hookzPydanticPlugin.get_method_hook�s�����[�)�+�+�rYc�H�|tk(rtdkrtjSy)z�Mark pydantic.dataclasses as dataclass.

        Mypy version 1.1.1 added support for `@dataclass_transform` decorator.
        )�r�N)�DATACLASS_FULLNAME�MYPY_VERSION_TUPLEr3�dataclass_class_maker_callbackr{s  rW�get_class_decorator_hookz'PydanticPlugin.get_class_decorator_hook�s$��
�)�)�.@�6�.I��=�=�=�rYc��|jS)zjReturn all plugin config data.

        Used by mypy to determine if cache needs to be discarded.
        )r`)rc�ctxs  rW�report_config_dataz!PydanticPlugin.report_config_data�s��
� � � rYc��t|j|j|j|j�}|j�Sr\)�PydanticModelTransformer�cls�reason�apir^�	transform)rcr��transformers   rWrtz3PydanticPlugin._pydantic_model_class_maker_callback�s3��.�s�w�w��
�
�C�G�G�T�M_�M_�`���$�$�&�&rYc���|jjry|jjj}|sJd��t|jdd�rd|j_yy)z�Reset dataclass_transform_spec attribute of ModelMetaclass.

        Let the plugin handle it. This behavior can be disabled
        if 'debug_dataclass_transform' is set to True', for testing purposes.
        Nz-callback not passed from 'get_metaclass_hook'�dataclass_transform_spec)r^�debug_dataclass_transformr��info�declared_metaclass�getattr�typer�)rcr��info_metaclasss   rWrzz8PydanticPlugin._pydantic_model_metaclass_marker_callback�s^�����7�7�������8�8���N�N�N�~��>�&�&�(B�D�I�;?�N���8�JrYc�|�	�|j�	|jddk(sJd��|jddk(sJd��|jd}|jd}|r$|r"t|j|j
��	S|r+|jdd}|d}t|t�s|S�	S|r�|jdd}t|t�r|jd}t|t�rH|j}t|dd�}|r+td	�|D��rt�	fd
�|D��|_|S�	S)aoExtract the type of the `default` argument from the Field function, and use it as the return type.

        In particular:
        * Check whether the default and default_factory argument is specified.
        * Output an error if both are specified.
        * Retrieve the type of the argument which is specified, and use it as return type for the function.
        r�defaultz0"default" is no longer first argument in Field()r��default_factoryz9"default_factory" is no longer second argument in Field()�argsNc3�<K�|]}t|t����y�wr\)rprA)rk�args  rWrmz:PydanticPlugin._pydantic_field_callback.<locals>.<genexpr>�s����H�4�C�:�c�;�7�4�s�c3�"�K�|]}����y�wr\�)rk�_�default_any_types  �rWrmz:PydanticPlugin._pydantic_field_callback.<locals>.<genexpr>�s�����-M��1�.>��s�)�default_return_type�callee_arg_namesr��+error_default_and_default_factory_specifiedr��context�	arg_typesrprr=�itemsr:�ret_typer��all�tuple)
rcr��default_args�default_factory_args�default_type�default_arg�default_factory_typer�r�r�s
         @rWrz'PydanticPlugin._pydantic_field_callback�sM����2�2���#�#�A�&�)�3�g�5g�g�3��#�#�A�&�*;�;�x�=x�x�;��x�x��{��"�x�x��{���0�7�������M�#�#���=�=��+�A�.�L�&�q�/�K��k�<�8�#�#�* ��'"�#&�=�=��#3�A�#6� ��.�
�;�';�'A�'A�!�'D�$��.��=�/�8�8���x���6����H�4�H�H�(-�-M��-M�(M��
����rY�rdr+�return�None)rh�strr�z(Callable[[ClassDefContext], bool] | None)rhr�r�z(Callable[[ClassDefContext], None] | None)rhr�r�z(Callable[[FunctionContext], Type] | None)rhr�r�z&Callable[[MethodContext], Type] | None)r�r1r��dict[str, Any])r�r-r��bool)r�r-r�r�)r�r.r�r>)�__name__�
__module__�__qualname__�__doc__rbrwr|r�r�r�r�rtrzr�
__classcell__)res@rWrUrU�s9���#�"�
�����!�'�@�. rYrUc�N�eZdZUdZdZded<ded<ded<ded<dd�Zdd	�Zy
)
r]a�A Pydantic mypy plugin config holder.

    Attributes:
        init_forbid_extra: Whether to add a `**kwargs` at the end of the generated `__init__` signature.
        init_typed: Whether to annotate fields in the generated `__init__`.
        warn_required_dynamic_aliases: Whether to raise required dynamic aliases error.
        debug_dataclass_transform: Whether to not reset `dataclass_transform_spec` attribute
            of `ModelMetaclass` for testing purposes.
    )�init_forbid_extra�
init_typed�warn_required_dynamic_aliasesr�r�r�r�r�r�c���|j�yt|j�}|�q|jdi�jdi�}|jD]?}|j|d�}t	|t
�st
d|����t|||��Ayt�}|j|j�|jD]'}|jt|d��}t|||��)y)N�toolrJFz/Configuration value must be a boolean for key: )�fallback)�config_file�
parse_toml�get�	__slots__rpr��
ValueError�setattrr�read�
getboolean�CONFIGFILE_KEY)rcrd�toml_config�config�key�settingr^s       rWrbzPydanticPluginConfig.__init__s������&�� ��!4�!4�5���"� �_�_�V�R�0�4�4�_�b�I�F��~�~�� �*�*�S�%�0��!�'�4�0�$�'V�WZ�V[�%\�]�]���c�7�+�	&�)�N�M����w�2�2�3��~�~��'�2�2�>�3�QV�2�W����c�7�+�&rYc�V�|jD�cic]}|t||���c}Scc}w)z/Returns a dict of config names to their values.)r�r�)rcr�s  rWr_zPydanticPluginConfig.to_data!s*��37�>�>�B�>�C��W�T�3�'�'�>�B�B��Bs�&Nr��r�r�)r�r�r�r�r��__annotations__rbr_r�rYrWr]r]�s3����I�����#'�'�#�#�,�&CrYr]c��|j}t|t�r|j}t|t�r't|j
t�r
|j
}n]t|t�r|}nJd|�d|jj�d�}t||j|j�|jS|jjjt�}|�|jS|jdi�jd�}|dur5t!|jj"|j|j�|jS)z1Raise an error if from_attributes is not enabled.z
ctx.type: �
 (of type �)r��from_attributesT)r�rpr@�itemr:r�r;rer��error_unexpected_behaviorr�r�r��metadatar��METADATA_KEY�error_from_attributes�name)r��ctx_type�
model_type�detail�pydantic_metadatar�s      rWr�r�&s���x�x�H��(�H�%��=�=���(�L�)�j��9J�9J�H�.U��&�&�
�	�H�h�	'��
��h�Z�z�(�2D�2D�2M�2M�1N�a�P��!�&�#�'�'�3�;�;�?��&�&�&�"���0�0�4�4�\�B��� ��&�&�&�'�+�+�H�b�9�=�=�>O�P�O��d�"��j�o�o�2�2�C�G�G�S�[�[�I��"�"�"rYc��eZdZdZ																d
d�Z														dd�Z	d							d
d�Z	d									dd�Zdd�Ze	dd��Z
dd�Zy	)�PydanticModelFieldz5Based on mypy.plugins.dataclasses.DataclassAttribute.c	�t�||_||_||_||_||_||_||_||_yr\)r��alias�has_dynamic_alias�has_default�line�columnr�r�)	rcr�r�r�r�r�r�r�r�s	         rWrbzPydanticModelField.__init__@s>����	���
�!2���&�����	������	���	rYc���|j||||�}|r|j||�nttj�}t||d|s|jrt��St��S)zABased on mypy.plugins.dataclasses.DataclassAttribute.to_argument.N)�variable�type_annotation�initializer�kind)	�to_varr	r9r?�explicitrr�rr)	rc�current_info�typed�force_optional�	use_aliasr��force_typevars_invariantr�r�s	         rW�to_argumentzPydanticModelField.to_argumentTso���;�;�|�S�)�=U�V��AF�$�*�*�<��=�G�T]�Tf�Tf�Lg����+��"0�D�4D�4D��	
�	
�KT�	
�	
rYc�d�|rFt|jt�r,|jj�}t|_||_|j��t
|jdd���tj|jj�5t|�}|r-|jD]}t|t�s�t|_� t|j|jjj |i�cddd�S|jS#1swY|jSxYw)zABased on mypy.plugins.dataclasses.DataclassAttribute.expand_type.N�	self_type)rpr�rA�
copy_modifiedr�variancer�r�r7�strict_optional_setrd�strict_optionalrDr�r	r��id)rcr�r�r��
modified_type�filled_with_typevarsr�s       rWr	zPydanticModelField.expand_typegs���
$�
�$�)�)�[�1� $�	�	� 7� 7� 9�
�)2�
�&�)��	��9�9� �W�T�Y�Y��T�%J�%V�
�*�*�3�;�;�+F�+F�G�'4�\�'B�$�+�3�8�8��%�c�;�7�+4�C�L� 9�#�4�9�9�t�y�y�/B�/B�/E�/E�G[�.\�]�
H�G��y�y��H��y�y��s�-D�AD�D/c��|r|j�
|j}n|j}t||j|||��S)z<Based on mypy.plugins.dataclasses.DataclassAttribute.to_var.)r�r�r*r	)rcr�r�r�r�r�s      rWr�zPydanticModelField.to_var�s?������/��:�:�D��9�9�D��4��)�)�,��=U�V�W�WrYc���|jsJ�|j|j|j|j|j
|j|jj�d�S)�?Based on mypy.plugins.dataclasses.DataclassAttribute.serialize.)r�r�r�r�r�r�r�)r�r�r�r�r�r�r��	serialize�rcs rWrzPydanticModelField.serialize�sV���y�y��y��I�I��Z�Z�!%�!7�!7��+�+��I�I��k�k��I�I�'�'�)�
�	
rYc�n�|j�}t|jd�|�}|d||d�|��S)�ABased on mypy.plugins.dataclasses.DataclassAttribute.deserialize.r�)r�r�r�)�copyr4�pop)r�r��datar��typs     rW�deserializezPydanticModelField.deserialize�s9���y�y�{��(����&�)9�3�?���/��$�/�$�/�/rYc���|j�Ytj|jj�5t|j||j�|_ddd�yy#1swYyxYw)zxExpands type vars in the context of a subtype when an attribute is inherited
        from a generic super type.
        N)r�r7r�rdr�r8r�)rc�sub_typer�s   rW�expand_typevar_from_subtypez.PydanticModelField.expand_typevar_from_subtype�sS���9�9� ��*�*�3�;�;�+F�+F�G�3�D�I�I�x����S��	�H�G�!�G�G�s�'A'�'A0N)r�r�r�z
str | Noner�r�r�r�r��intr�rr��Type | Noner�r))r�r)r�r�r�r�r�r�r�r2r�r�r�r�F)r�r)r�r2r�r�r�r)
r�r)r�r2r�r�r�r�r�r*�r�r)r�r)rrr�r2r�r�)rr)r�r2r�r�)r�r�r�r�rbr�r	r�r�classmethodrrr�rYrWr�r�=s-��?������ �	�
���
�������(
��
��
��	
�
�
�-�

�#'�
�
�
�(ns��$��+J��fj��	��D*/�
X��
X�-�
X��	
X�
#'�
X�

�

X�
��0��0�TrYr�c�0�eZdZdZd�Zedd��Zdd�Zy)�PydanticModelClassVarz�Based on mypy.plugins.dataclasses.DataclassAttribute.

    ClassVars are ignored by subclasses.

    Attributes:
        name: the ClassVar name
    c��||_yr\�r�)rcr�s  rWrbzPydanticModelClassVar.__init__�s	����	rYc�2�|j�}|di|��S)r	r�)r
)r�rs  rWrz!PydanticModelClassVar.deserialize�s���y�y�{���{�T�{�rYc��d|jiS)rr�rrs rWrzPydanticModelClassVar.serialize�s��
�D�I�I�
�	
rYN)rrr�rr)r�r�r�r�rbrrrr�rYrWrr�s%��������

rYrc�F�eZdZUdZhd�Zded<										dd�Zdd�Zdd�Zdd�Z							dd	�Z
dd
�Zdd�Z								dd�Z
d d
�Z										d!d�Z								d"d�Zd#d�Zd$d%d�Zed&d��Zed'd��Z	d$													d(d�Zd)d�Zed*d��Zy)+r�z�Transform the BaseModel subclass according to the plugin settings.

    Attributes:
        tracked_config_fields: A set of field configs that the plugin has to track their value.
    >�extra�frozen�alias_generatorr��populate_by_namezset[str]�tracked_config_fieldsc�<�||_||_||_||_yr\)�_cls�_reason�_apir^)rcr�r�r�r^s     rWrbz!PydanticModelTransformer.__init__�s!����	������	�*��rYc���|jj}td�|jddD��}|j	�}|j||�\}}|�|�y|D]}|j��ytd�|jddD��}|j||||�|s|j|||�|j||j|jdu��|j�|D�cic]}|j|j���c}|D�cic]}|j|j���c}|j�d�|j t"<ycc}wcc}w)	a�Configures the BaseModel subclass according to the plugin settings.

        In particular:

        * determines the model config and fields,
        * adds a fields-aware signature for the initializer and construct methods
        * freezes the class if frozen = True
        * stores the fields, config, and if the class is settings in the mypy metadata for access by subclasses
        c3�@K�|]}t|jv���y�wr\)�ROOT_MODEL_FULLNAMErhrjs  rWrmz5PydanticModelTransformer.transform.<locals>.<genexpr>�s����[�]�T�/�4�=�=�@�]�s�N���Fc3�BK�|]}|jtk(���y�wr\)rh�BASESETTINGS_FULLNAMErjs  rWrmz5PydanticModelTransformer.transform.<locals>.<genexpr>�s����[�]�T�$�-�-�+@�@�]�rnT)r)�fields�
class_varsr�)r$r�rrrs�collect_config�collect_fields_and_class_varsr��add_initializer�add_model_construct_method�
set_frozenr&r�adjust_decorator_signaturesr�r�get_values_dictr�r�)	rcr��
is_root_modelr�r-r.�field�is_settings�	class_vars	         rWr�z"PydanticModelTransformer.transform�s^���y�y�~�~���[�T�X�X�VY�WY�]�[�[�
��$�$�&��!�?�?��
�V���
��>�Z�/���E��z�z�!����[�T�X�X�VY�WY�]�[�[�����V�V�[�-�H���+�+�F�F�K�H������	�	�&�-�-�4�2G��H��(�(�*�CI�I�&��u�z�z�5�?�?�#4�4�&�I�R\�]�R\�Y�9�>�>�9�+>�+>�+@�@�R\�]��,�,�.�'
��
�
�l�#���J��]s�;"E+�#"E0c�,��|jjjj�D]�\}}t	|j
t�s�!|j
jd�t	�t�s�Kt	�jt�s�f�jjtvs���jjtk(r(t�fd�t�j �D��r��d|j
j"_��y)a�When we decorate a function `f` with `pydantic.validator(...)`, `pydantic.field_validator`
        or `pydantic.serializer(...)`, mypy sees `f` as a regular method taking a `self` instance,
        even though pydantic internally wraps `f` with `classmethod` if necessary.

        Teach mypy this by marking any function whose outermost decorator is a `validator()`,
        `field_validator()` or `serializer()` call as a `classmethod`.
        rc3��K�|]<\}}�j|dk(xr!t|t�xr|jdk(���>y�w)�mode�afterN)�	arg_namesrpr%�value)rk�ir��	first_decs   �rWrmzGPydanticModelTransformer.adjust_decorator_signatures.<locals>.<genexpr>sO����� �*C���3�&�/�/��2�f�<�r��C�QX�AY�r�^a�^g�^g�kr�^r�r�*C�s�AATN)r$r��namesr�rprqr�original_decoratorsr�calleer rh�DECORATOR_FULLNAMES�MODEL_VALIDATOR_FULLNAMErr�	enumerater��func�is_class)rcr�rvrAs   @rWr4z4PydanticModelTransformer.adjust_decorator_signatures
s���������-�-�3�3�5�I�D�#��#�(�(�I�.��H�H�8�8��;�	��y�(�3�"�9�#3�#3�X�>�!�(�(�1�1�5H�H�"�(�(�1�1�5M�M�� �*3�I�N�N�*C� ��.2�C�H�H�M�M�*�#6rYc	��|j}t�}d}d}|jj�D]-\}}|j	||�}|s�d}|j|��/d}|jjD�]}t|ttf�s�t|t��r"|jd}	t|	t�r|	jdk7r�[t|jt�rdt!|jj"|jj$�D]+\}
}|
��	|j|j	|
|d����-�nt|jt&�r�|jjD]A\}}
t|t(�s�|j|j	|j*|
���Cn�t|t�r�|jdk7r��o|jjD]h}t|t�s�|jd}	t|	t�s�4|j|j	|	j|j���j|r|j,j/d|�nd}��|s|rF|rD|j0r8|j2s,|j4j6rt9|j,|�|j:j<d	dD]�}t>|j@vr�|j,jCtE|jF��|j@t>d
j�D]\}}|jI||����|S)zhCollects the values of the config attributes that are used by the plugin, accounting for parent classes.FTNr�model_config)�	lax_extra�ConfigzYSpecifying config in two places is ambiguous, use either Config attribute or class kwargsr�r�)%r$�ModelConfigData�keywordsr��get_config_update�update�defs�bodyrprr�lvaluesr r��rvaluer�zipr>r�rr%r?r&�fail�has_alias_generatorr!r^r��error_required_dynamic_aliasesr�rsr�r��add_plugin_dependencyr6rh�
setdefault)rcr�r��has_config_kwargs�has_config_from_namespacer��expr�config_data�stmt�lhs�arg_namer��key_expr�
value_expr�substmtr�r?s                 rWr/z'PydanticModelTransformer.collect_config%s����i�i�� �"��!��$)�!��,�,�,�,�.�J�D�$��0�0��t�<�K��$(�!��
�
�k�*�	/�"&���H�H�M�M�D��d�^�X�$>�?���$��/��l�l�1�o��!�#�x�0�C�H�H��4N���d�k�k�8�4�),�T�[�[�-B�-B�D�K�K�DT�DT�)U�
��#�#�+�$��
�
�d�&<�&<�X�s�VZ�&<�&[�\�*V� ����X�6�04���0A�0A�,��*�)�(�G�<�$��
�
�d�&<�&<�X�^�^�Z�&X�Y�1B�
�D�(�+��9�9��(��#�y�y�~�~�G�%�g�~�>� �!�/�/�!�,�C�%�c�8�4� ��M�M�$�"8�"8����7�>�>�"R�S�
 .�!��	�	���o����(,�%�M"�P� 9���.�.��/�/��&�&�D�D�.�t�y�y�$�?��H�H�L�L���$�D��4�=�=�0��
�I�I�+�+�,A�$�-�-�,P�Q�#�}�}�\�:�8�D�J�J�L���e��!�!�$��.� M�
%��
rYc���|j}i}i}t|jjdd�D�]v}t|j
vr�|jjt|j��|j
tdj�D]�\}}tj|||j�}	|	j|j|j�|	||<|jjj|�}
|
s�z|
j s��t#|
j t$�r��|jj'd|
j ���|j
tdj�D]\}}t(j|�||<���yt+�}t+�}|j-|j.�D]�}
|j1|
||�}t#|t�rb|
j2d}|r&|j4dk7rt7|j|
��]|j9|j4�|||j4<��t#|t(�s��|
j2d}|j9|j4�|||j4<��t;|j=��t;|j=��fS)zACollects the fields for the model, accounting for parent classes.r�r*r-z7BaseModel field may only be overridden by another fieldr.r�root)r$�reversedr�rsr�r�r&rZr6rhr�r�rrrBr�rqrpr*rWr�set�%_get_assignment_statements_from_blockrR�$collect_field_or_class_var_from_stmtrTr�� error_extra_fields_on_root_model�add�list�values)rcrKr6r��found_fields�found_class_varsr�r�rr7�sym_node�current_field_names�current_class_vars_namesr`�maybe_fieldras                rWr0z6PydanticModelTransformer.collect_fields_and_class_varsqsH���i�i��79��=?���S�X�X�\�\�!�B�/�0�D��4�=�=�0��
�I�I�+�+�,A�$�-�-�,P�Q�"�m�m�L�9�(�C�I�I�K�
��d�*�6�6�t�T�4�9�9�M��
�1�1�#�(�(�D�I�I�F�%*��T�"��8�8�>�>�-�-�d�3����
�
�j����PS�6T��I�I�N�N�Q� �
�
��L� #�m�m�L�9�,�G�M�M�O�
��d�)>�)J�)J�4�)P� ��&�P�51�<),���-0�U� ��>�>�s�x�x�H�D��C�C�D�,�Xh�i�K��+�'9�:��l�l�1�o�� �S�X�X��%7�4�T�Y�Y��E�'�+�+�C�H�H�5�-8�L����*��K�)>�?��l�l�1�o��(�,�,�S�X�X�6�-8� ����*�I��L�'�'�)�*�D�1A�1H�1H�1J�,K�K�KrYc#�K�|jD](}|jr�|j|�Ed{����*|j�;|jjs$|j|j�Ed{���yyy7�N7�	�wr\)rS�is_unreachablerj�	else_body)rcr`rSs   rW�,_get_assignment_statements_from_if_statementzEPydanticModelTransformer._get_assignment_statements_from_if_statement�st�����I�I�D��&�&��E�E�d�K�K�K���>�>�%�d�n�n�.K�.K��A�A�$�.�.�Q�Q�Q�/L�%�L��Q�s'�B�B�B�AB�:B�;B�Bc#�K�|jD]A}t|t�r|���t|t�s�)|j	|�Ed{����Cy7��wr\)rSrprrry)rc�blockr`s   rWrjz>PydanticModelTransformer._get_assignment_statements_from_block�sG�����J�J�D��$��/��
��D�&�)��L�L�T�R�R�R�	�S�s�5A�A�A�
Ac
��|j}|jd}t|t�r.t	j
|j�r|jdk(ry|js�t|jt�r�t|jjt�r_t|jjjt�r1|jjjjtvry|j|vryt|j|�y|jd}t|t�syt	j
|j�r|jdk(ry|jj j#|j�}|�y|j$}t|t&�ryt|t(�r|jj+d|�yt|t,�sy|j.rt1|j�St3|j4�}t|t6�r5|j4jdk(r|jj+d|�|j9|�}	|j4��|j:rw|j<rk|jj?|jd��}
|
r|
|_n:|jj+d	|�tAtBjD�|_|jG|�\}}|r8|jHs,|jJjLrtO|j|�|jQ||j|�}
tS|j||	||jT|jV|
|j�
�S)a^Get pydantic model field from statement.

        Args:
            stmt: The statement.
            model_config: Configuration settings for the model.
            class_vars: ClassVars already known to be defined on the model.

        Returns:
            A pydantic model field if it could find the field in statement. Otherwise, `None`.
        rrKNzFType aliases inside BaseModel definitions are not supported at runtimezdataclasses.InitVarz%InitVar is not supported in BaseModelT)�is_finalzGNeed type argument for Final[...] with non-literal default in BaseModel)r�r�r�r�r�r�r�r�),r$rTrpr rG�is_valid_field_namer��
new_syntaxrUrrDrhrE�error_untyped_fieldsr&r�rBr�rqr"r(rWr*�is_classvarrrCr�r;�get_has_defaultr}�is_inferred�analyze_simple_literal_typer9r?�
from_error�get_alias_infor!r^r�rY�_infer_dataclass_attr_init_typer�r�r�)rcr`rKr.r�rarvrq�	node_typer�r
r�r��	init_types              rWrkz=PydanticModelTransformer.collect_field_or_class_var_from_stmt�s����i�i���l�l�1�o���#�x�(��0K�0K�C�H�H�0U�Y\�Ya�Ya�es�Ys������4�;�;��1��t�{�{�1�1�8�<��t�{�{�1�1�8�8�(�C��K�K�&�&�-�-�6�6�:M�M�
��x�x�:�%��
!����D�1���l�l�1�o���#�x�(���*�*�3�8�8�4����N�8R���h�h�n�n� � ����*���;���x�x���d�O�,�
��d�I�&��I�I�N�N�X��
���$��$�
����(����2�2�$�D�I�I�.�	��i��*�y�~�~�/F�/F�J_�/_��I�I�N�N�7��
�
�*�*�4�0���8�8���
�
�$�2B�2B��)�)�7�7����d�7�S�C����	��	�	���]���$�I�$8�$8�9��	�#'�#6�#6�t�#<� �� ��\�%B�%B�t�GY�GY�Gw�Gw�*�4�9�9�d�;��8�8��c�h�h��M�	�!����/�#������;�;�����	
�		
rYc�8�|j}|jr|St|j�}t|t�s|S|jjd�}|�r:t|jt�r�|jjd�}|sJ�|jr+tt|j|j|��}nttj�St|t�r7|jtttgk(rt!|j"d|�S|j$j'd|jj(�d�|�|S|j$j'd|jj(�d�|�|S)zvInfer __init__ argument type for an attribute.

        In particular, possibly use the signature of __set__.
        �__set__rSz(Unsupported signature for "__set__" in "�"zUnsupported "__set__" in ")r��implicitrCrpr;r�rqr�get_containing_type_infor8r9r?�unannotatedr:�	arg_kindsrr
r�r&rWr�)	rcrvr�r�r��t�setter�
super_info�setter_types	         rWr�z8PydanticModelTransformer._infer_dataclass_attr_init_type=sG��
�(�(���<�<��N��C�H�H�%���!�X�&��N������I�&����&�+�+�w�/��V�V�<�<�Y�G�
�!�!�z��;�;�"1�2I�&�+�+�WX�W]�W]�_i�2j�"k�K�"�9�#8�#8�9�9��k�<�8�[�=R�=R����W�>�
3�;�3H�3H��3K�Q�O�O��I�I�N�N�%M�a�f�f�k�k�]�Z[�#\�^e�f����	�	���!;�A�F�F�K�K�=��J�G�T��rYc	���d|jjjvr.|jjjdjsy|jj
}|jdu}t|jxr
|j�}|j|||||d��}|r3tdkr*|djtk(rtnt|d_|r�|jj!t"�j$}	d|	jvr�|	jdj$}
|
��|
j&��|
j&}t)|j*�D]}\}}
|
j-d�s|
j-d�s�)|jj/|j0|�}t3|
|�}|j5t7||dt���|j9||�sCt3d	�}|j5t7|t;t<j>�dt@��tC|j|jd|tE��
�y)z�Adds a fields-aware `__init__` method to the class.

        The added `__init__` will be annotated with types vs. all `Any` depending on the plugin settings.
        rbNT)r��requires_dynamic_aliasesr�r8r�)r�rr�r�__r��kwargs)r��return_type)#r$r�rB�plugin_generatedr^r�r!r�rX�get_field_argumentsr�r�rrr
r&ror,rqr�rGr>�
startswith�	anal_typer�r*�appendr�should_init_forbid_extrar9r?r�r�
add_methodr<)rcr-r�r8r6r�r�r�r��base_settings_node�base_settings_init_node�	func_type�arg_idxrb�analyzed_variable_typer��vars                 rWr1z(PydanticModelTransformer.add_initializercs��������-�-�-�d�i�i�n�n�6J�6J�:�6V�6g�6g���"�"�-�-���+�+�4�7�	�#'��(B�(B�(b�6�Kb�Kb�Gb�#c� ��'�'���%=��#�%)�
(�
���/�9�<�'+�1�g�l�l�i�&?�7�W�D��G�L��!%���!A�!A�BW�!X�!]�!]���/�5�5�5�*<�*B�*B�:�*N�*S�*S�'�*�6�;R�;W�;W�;c� 7� <� <�I�-6�y�7J�7J�-K�)���#�.�.�t�4�H�<O�<O�PS�<T�$�15���1D�1D�Y�EX�EX�Y`�Ea�1b�.�#&�x�1G�#H�����H�X�7M�t�U\�$]�^�.L��,�,�V�V�<��h�-�C��K�K���g�i�.@�.@�&A�4��S�T��4�9�9�d�i�i��$�H�J�WrYc	���|jjt�d�|jjt�d��g�}t|t	�g�}tt
d|�|dt�}tj|jjj�5|j|ddd|��}ddd�|j||�sCt
d�}jt|tt j"�dt$��|gz}t'|j|j(d	|t+|j(j,�d�
�y#1swY��xYw)z�Adds a fully typed `model_construct` classmethod to the class.

        Similar to the fields-aware __init__ method, but always uses the field names (not aliases),
        and does not treat settings fields as optional.
        z.setz.str�_fields_setNTF)r�r�r�r8r��model_construct)r�r��is_classmethod)r&�
named_type�
BUILTINS_NAMErBr<rr*r
r7r�rdr�r�r�r�r9r?r�rr�r$rDr�)	rcr-r�r8�set_str�optional_set_str�fields_set_argumentr�r�s	         rWr2z3PydanticModelTransformer.add_model_construct_method�s3���)�)�&�&�-���'=��	�	�@T�@T�Xe�Wf�fj�Uk�@l�?m�n��$�g�x�z�%:�;��&�s�=�:J�'K�M]�_c�el�m��
�
&�
&�t�y�y�'8�'8�'H�'H�
I��+�+��d�U�e�al�,��D�J��,�,�V�V�<��h�-�C��K�K���g�i�.@�.@�&A�4��S�T�#�$�t�+����I�I��I�I���%�d�i�i�n�n�5��
	
�J�
I�s�)E&�&E/c���|jj}|D�]:}|jj|j�}|��|j
}t
|t�r||_�Ot
|t�r1|jjs|jj���	t|�}d|�d|j �d�}	t#|	|j|j���|j%||d��}||_||_|j&dz|jz|_t+t,|�|j|j<��=y#t$rt|�}Y��wxYw)z�Marks all fields as properties so that attempts to set them trigger mypy errors.

        This is the same approach used by the attrs and dataclasses plugins.
        Nzsym_node.node: r�r�F)r��.)r$r�rBr�r�rqrpr*�is_propertyr"r&�final_iteration�deferr��	TypeError�reprrer�r�rh�	_fullnamer&r)
rcr-r�rr�r7rrr��var_strr�s
          rWr3z#PydanticModelTransformer.set_frozen�s ��
�y�y�~�~���E��z�z�~�~�e�j�j�1�H��#��m�m���c�3�'�&,�C�O���_�5�d�i�i�>W�>W��I�I�O�O�%�,�"%�c�(�� /�w�i�z�#�-�-��PQ�R�F�-�f�d�i�i����K��l�l�4���l�>�����"(��� $�
�
�� 3�c�h�h� >��
�'6�t�S�'A��
�
�3�8�8�$�/��%�,�"&�s�)��,�s�*E�E/�.E/c��||jvry|dk(rft|t�r|jdk(}n:t|t�r|j
dk(}n|st
||j|�yt|��S|dk(r/d}t|t�r|jdk(rd}t|�	�St|t�r(|jd
vrtdi||jdk(i��St
||j|�y)
z�Determines the config update due to a single kwarg in the ConfigDict definition.

        Warns if a tracked config attribute is set to a value the plugin doesn't know how to interpret (e.g., an int)
        Nr�forbid)�forbid_extrar T�
builtins.NoneF)rX)�
builtins.Truezbuiltins.Falser�r�)r"rpr%r?rr��error_invalid_config_valuer&rNr rh)rcr�r�rLr�rXs      rWrPz*PydanticModelTransformer.get_config_update�s���
�t�1�1�1���7�?��#�w�'�"�y�y�H�4���C��,�"�x�x�8�3�� �/�t�T�Y�Y��D��"��=�=��$�$�"&���#�x�(�S�\�\�_�-L�&+�#�"�7J�K�K��c�8�$����9\�)\�"�M�d�C�L�L�O�,K�%L�M�M�"�4����C�8�rYc���|j}t|t�ryt|t�r�t|jt
�r�|jjtk(rmt|j|j�D]I\}}|�|dk(r|jtucS|dk(s�'t|t�xr|jdk(cSyt|t�S)zUReturns a boolean indicating whether the field defined in `stmt` is a required field.Fr�r�r�)rUrpr'rrDr#rhr~rVr�r>rerr )r`r^r�r�s    rWr�z(PydanticModelTransformer.get_has_default�s����{�{���d�H�%���d�H�%�*�T�[�[�'�*J�t�{�{�Oc�Oc�gu�Ou�
!����D�N�N�;�	��T��<�4�9�#4��=�=��<�<��,�,� *�3�� 9� ]�c�l�l�o�>]�^�^�<���d�L�1�1�1rYc�t�|j}t|t�ryt|t�r7t|jt
�r|jjtk(syt|j�D];\}}|dk7r�|j|}t|t�r|jdfcSyy)aReturns a pair (alias, has_dynamic_alias), extracted from the declaration of the field defined in `stmt`.

        `has_dynamic_alias` is True if and only if an alias is provided, but not as a string literal.
        If `has_dynamic_alias` is True, `alias` will be None.
        )NFr�F)NT)
rUrpr'rrDr#rhr~rGr>r�r%r?)r`r^r@rbr�s     rWr�z'PydanticModelTransformer.get_alias_infos����{�{���d�H�%��
�t�X�&�:�d�k�k�7�+K�PT�P[�P[�Pd�Pd�hv�Pv��$�T�^�^�4�K�A�x��7�"���)�)�A�,�C��#�w�'��y�y�%�'�'�!�5�rYc��|jj}|D�cgc]5}|r|js%|j|||xs|||j|����7}	}|	Scc}w)z�Helper function used during the construction of the `__init__` and `model_construct` method signatures.

        Returns a list of mypy Argument instances for use in the generated signatures.
        )r�r�r�r�r�)r$r�r�r�r&)
rcr-r�r�r�r8r�r�r7�	argumentss
          rWr�z,PydanticModelTransformer.get_field_arguments#sz���y�y�~�~�� �
� ���%�"9�"9�
�����7�F�;�#��I�I�)A�

�
� �	�
����
s�:Ac��|js&|j|t|j��ry|jry|j
jS)a@Indicates whether the generated `__init__` should get a `**kwargs` at the end of its signature.

        We disallow arbitrary kwargs if the extra config setting is "forbid", or if the plugin config says to,
        *unless* a required dynamic alias is present (since then we can't determine a valid signature).
        FT)r!�is_dynamic_alias_presentr�rXr�r^r�)rcr-r�s   rWr�z1PydanticModelTransformer.should_init_forbid_extra?sI���&�&��,�,�V�T�&�:T�:T�5U�V�������!�!�3�3�3rYc�\�|D]}|js�y|r|D]}|j��yy)z�Returns whether any fields on the model have a "dynamic alias", i.e., an alias that cannot be
        determined during static analysis.
        TF)r�r�)r-rXr7s   rWr�z1PydanticModelTransformer.is_dynamic_alias_presentLs;��
�E��&�&�������;�;�&�� �rYN)
r�rr�zExpression | Statementr�r2r^r]r�r�)r�r�)r�r�)r�rN)rKrNr6r�r�zJtuple[list[PydanticModelField] | None, list[PydanticModelClassVar] | None])r`rr��Iterator[AssignmentStmt])r{rr�r�)r`rrKrNr.z dict[str, PydanticModelClassVar]r�z1PydanticModelField | PydanticModelClassVar | None)rvr&r�r�r�rr�r)
r-�list[PydanticModelField]r�rNr8r�r6r�r�r�)r-r�r�rNr8r�r�r�)r-r�r�r2rr�r�r�r)r�r�r�rrLr�r��ModelConfigData | None)r`rr�r�)r`rr�ztuple[str | None, bool])r-r�r�r�r�r�r�r�r8r�r�r�r��list[Argument])r-r�r�rNr�r�)r-r�rXr�r�r�)r�r�r�r�r"r�rbr�r4r/r0ryrjrkr�r1r2r3rP�staticmethodr�r�r�r�r�r�rYrWr�r��s����'��8��+�
�+�'�+�-�	+�
,�+�
�
+�#�J2�6J�X?L�+�?L�<@�?L�	S�?L�BR�S�{
�"�{
�2A�{
�Oo�{
�	:�{
�z$�L,X�.�,X�8G�,X�VZ�,X�ko�,X�	
�,X�\
�.�
�8G�
�VZ�
�	
�
�<B�>!�F�2��2�*����D*/��(�����	�
#'���
�#'��
��84����rYr�c�N�eZdZdZ					d									dd�Zd	d�Zd
d�Zdd�Zy)rNz(Pydantic mypy plugin model config class.Nc�J�||_||_||_||_||_yr\)r�rr�r!rX)rcr�rr�r!rXs      rWrbzModelConfigData.__init__^s+��)������.��� 0���#6�� rYc�p�|jj�D��cic]\}}|��	||��
c}}Scc}}w)z�Returns a dict of Pydantic model config names to their values.

        It includes the config if config value is not `None`.
        )�__dict__r�)rc�k�vs   rWr5zModelConfigData.get_values_dictls7��
"&���!4�!4�!6�H�!6���A�!�-��1��!6�H�H��Hs�
2�2c�p�|�y|j�j�D]\}}t|||��y)z$Update Pydantic model config values.N)r5r�r�)rcr�r�r�s    rWrQzModelConfigData.updatess6���>���*�*�,�2�2�4�D�A�q��D�!�Q��5rYc�8�t||��t|||�yy)zFSet default value for Pydantic model config if config value is `None`.N)r�r�)rcr�r?s   rWr[zModelConfigData.setdefaultzs ���4���%��D�#�u�%�&rY)NNNNN)
r��bool | Nonerr�r�r�r!r�rXr�r�)r�r�r�r�)r�r�r?rr�r�)r�r�r�r�rbr5rQr[r�rYrWrNrN[s[��2�%)�"�'+�(,�+/�
7�!�7��7�%�	7�
&�7�)�
7�I� �&rYrNzpydantic-ormzInvalid from_attributes call�Pydanticzpydantic-configzInvalid config valuezpydantic-aliaszDynamic alias disallowedzpydantic-unexpectedzUnexpected behaviorzpydantic-fieldzUntyped field disallowedzInvalid Field defaultsz!Extra field on RootModel subclassc�<�|jd|�d�|t��y)zCEmits an error when the model does not have `from_attributes=True`.r�z$" does not have from_attributes=True��codeN)rW�	ERROR_ORM)�
model_namer�r�s   rWr�r��s���H�H�q���@�
A�7�QZ�H�[rYc�<�|jd|�d�|t��y)z0Emits an error when the config value is invalid.zInvalid value for "Config.r�r�N)rW�ERROR_CONFIG)r�r�r�s   rWr�r��s���H�H�)�$��q�
1�7��H�NrYc�4�|jd|t��y)znEmits required dynamic aliases error.

    This will be called when `warn_required_dynamic_aliases=True`.
    z#Required dynamic aliases disallowedr�N)rW�ERROR_ALIAS�r�r�s  rWrYrY�s��
�H�H�
2�G�+�H�NrYc�V�d}d|�d�}|d|�d�z
}|j||t��y)z Emits unexpected behavior error.z6https://github.com/pydantic/pydantic/issues/new/choosez7The pydantic mypy plugin ran into unexpected behavior: �
z&Please consider reporting this bug at z so we can try to fix it!r�N)rW�ERROR_UNEXPECTED)r�r�r��link�full_messages     rWr�r��sA��
D�D�L�V�H�TV�W�L��<�T�F�B[�\�\�L��H�H�\�7�)9�H�:rYc�4�|jd|t��y)z;Emits an error when there is an untyped field in the model.zUntyped fields disallowedr�N)rW�
ERROR_UNTYPEDr�s  rWr�r��s���H�H�
(�'�
�H�FrYc�4�|jd|t��y)z]Emits an error when there is more than just a root field defined for a subclass of RootModel.z2Only `root` is allowed as a field of a `RootModel`r�N)rW�ERROR_EXTRA_FIELD_ROOT_MODELr�s  rWrlrl�s���H�H�
A�7�Qm�H�nrYc�4�|jd|t��y)zNEmits an error when `Field` has both `default` and `default_factory` together.z>Field default and default_factory cannot be specified togetherr�N)rW�ERROR_FIELD_DEFAULTSr�s  rWr�r��s���H�H�
M�w�]q�H�rrYc�D�|j}||jvrd|j|}	|	jrIt|	jt
�r/|jjj|	j�t|t�r|jd�}
n|jdg�}
|r6|xstt|��}ttd�|dt d�g}n+|xst|�}ttd�|dt �g}||z}ggg}}
}|D]p}|j"sJd��|j%|j"�|
j%|j&j(�|j%|j*��rt-|||
||
�}|r|g|_t||t1t3�g��}||_t5||�|_||_|j:dz|z|_|j>|_||jvr2tA||j�}|j||j|<|rud|_!t||j6�}||_|j<|_d|_"tG|tId�g|�}|j>|_tKtL|�}	ntKtL|�}	d|	_|	|j|<|jNjjj%|�y)	zhVery closely related to `mypy.plugins.common.add_method_to_class`, with a few pydantic-specific changes.zbuiltins.functionr$NT�__pydantic_self__z"All arguments must be fully typed.r�r)(r�rBr�rprqrrRrS�remover2r��named_generic_typer@rDrr*rr�r�r�r�r�r:�	variablesrr!r5r�rIrhr�r�rE�is_decoratedr�rr r&r�defn)r�r�r�r�r�r��tvar_defr�r�rv�
function_type�firstr�r>r�r��	signaturerH�r_namer��decs                     rWr�r��s����8�8�D��t�z�z���j�j�������J�s�x�x��$A��H�H�M�M� � ����*��#�6�7����':�;�
��.�.�/B�B�G�
���>��-��*=�!>�	��#�f�+�y�$���F�G���4��t�!4�	��#�1�2�I�t�W�M�N���4�<�D�&(�"�b�)�y�I����"�"�H�$H�H�"�����,�,�-�������*�*�+�������"�	��Y�	�9�k�=�Y�I��'�j�	���4��u�h�j�\�2�3�D��D�I�!�)�T�2�D�I�"�D�M��]�]�S�(�4�/�D�N��	�	�D�I��t�z�z��-�d�D�J�J�?��!�Z�Z��-��
�
�6��
� �����d�i�i� ������n�n��������x�
�6�7��;���9�9����d�C�(���d�D�)���C���D�J�J�t���I�I�N�N�����t�$rYc��|jd�sytjdk\rddl}n	ddl}t|d�5}|j|�cddd�S#t
$rddl}|jd�YywxYw#1swYyxYw)z�Returns a dict of config keys to values.

    It reads configs from toml file and returns `None` if the file is not a toml file.
    z.tomlN)��rzJNo TOML parser installed, cannot read configuration from `pyproject.toml`.�rb)
r��sys�version_info�tomllib�tomli�ImportError�warnings�warn�open�load)r��toml_r�rfs    rWr�r�
s|��
����(��
���7�"��	�!�
�k�4�	 �B��z�z�"�~�
!�	 ��
�	���M�M�f�g��		��
!�	 �s�A�A;�A8�7A8�;B)rVr�r�ztype[Plugin])r�r/r�r>)r�r�r�r,r�rr�r�)r�r�r�r2r�rr�r�)r�r2r�rr�r�)r�r�r�z8CheckerPluginInterface | SemanticAnalyzerPluginInterfacer�rr�r�)r�r,r�rr�r�)NNF)r�z8SemanticAnalyzerPluginInterface | CheckerPluginInterfacer�rr�r�r�r�r�r>r�rr�zTypeVarDef | Noner�r�r�r�)r�r�r�zdict[str, Any] | None)�r��
__future__rr��configparserr�typingrrr�mypy.errorcodesr�mypy.expandtyper	r
�
mypy.nodesrrr
rrrrrrrrrrrrrrrrrrr r!r"r#r$r%r&r'r(r)r*�mypy.optionsr+�mypy.pluginr,r-r.r/r0r1r2�mypy.pluginsr3�mypy.plugins.commonr4�mypy.semanalr5�mypy.server.triggerr6�
mypy.stater7�mypy.typeopsr8�
mypy.typesr9r:r;r<r=r>r?r@rArBrC�
mypy.typevarsrD�	mypy.utilrE�mypy.versionrF�mypy_version�pydantic._internalrG�pydantic.versionrHrIr�r�r�rir,r)ryr~r�rFrEr�r�rXrUr]r�r�rr�rNr�r�r�r�r�r�r�r�r�rYr�r�rlr�r�r�r�rYrW�<module>rs���d�"�
�%�*�*�%�@�!�!�!�!�!�!�!�!�!�D!����%��+�5��0�����(�2�4�&�/�5�%�
!��'��.��=��5��R��(��5��K����(��5��0�H�<�
�.�
����s �V�s �l+C�+C�\#�.pT�pT�f
�
�2O
�O
�d"&�"&�J
�n�&D�j�Q�	��*�,B�J�O���(�*D�j�Q���2�4I�:�V���*�,F�
�S�
� �!1�3K�Z�X��(�)9�;^�`j�k��\�
O�
O�;��;�N�;�Y`�;�	�;�G�
o�
s�"�"&� �U%�	A�U%�	�U%��U%��	U%�
�U%��
U%� �U%��U%�
�U%�p��q%�5�4�4�5�s�$G � G/�.G/

if you don't want to be vaporized in a nuclear explosion, i simply have to become nuclear myself… i am atomic