
    ]f                    
   d Z ddlmZ ddlZddlmZ ddlmZmZm	Z	 ddl
mZ ddlmZmZ ddlmZmZmZmZmZ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#m$Z$m%Z%m&Z&m'Z'm(Z(m)Z)m*Z*m+Z+m,Z,m-Z-m.Z.m/Z/ dd	l0m1Z1 dd
l2m3Z3m4Z4m5Z5m6Z6m7Z7m8Z8m9Z9 ddl:m;Z; ddl<m=Z= ddl>m?Z? ddl@mAZA ddlBmCZC ddlDmEZE ddlFmGZGmHZHmIZImJZJmKZKmLZLmMZMmNZNmOZOmPZPmQZQ ddlRmSZS ddlTmUZU ddlVmWZX ddlYmZZZ ddl[m\Z\ 	 ddlFm]Z] n# e^$ r	 ddlFmOZ] Y nw xY wdZ_dZ`dZadZbdZcdZddZed Zfd!Zgh d"Zh e\eX          Zieid#k    rd$nd%Zjd&ZWdkd+Zk G d, d-e7          Zl G d. d/          Zmdld3Zn G d4 d5          Zo G d6 d7          Zp G d8 d9          Zq G d: d;          Zr ed<d=d>          Zs ed?d@d>          Zt edAdBd>          Zu edCdDd>          Zv edEdFd>          Zw edEdGd>          Zx edEdHd>          ZydmdOZzdndRZ{dodSZ|dpdVZ}dodWZ~dqdXZdqdYZ	 	 	 drdsdgZdtdjZdS )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-mypyzpydantic-mypy-metadatazpydantic.main.BaseModelz#pydantic_settings.main.BaseSettingszpydantic.root_model.RootModelz5pydantic._internal._model_construction.ModelMetaclasszpydantic.fields.Fieldzpydantic.dataclasses.dataclass.pydantic.functional_validators.model_validator>   *pydantic.functional_serializers.serializer.pydantic.deprecated.class_validators.validator.pydantic.functional_validators.field_validator0pydantic.functional_serializers.model_serializer3pydantic.deprecated.class_validators.root_validatorrK   )r   i  builtins__builtins__   versionstrreturntype[Plugin]c                    t           S )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)rT   s    ?/var/www/html/env/lib/python3.11/site-packages/pydantic/mypy.pypluginr[   s   s
         c                  l     e Zd ZdZd fdZdd
ZddZd dZd!dZddZ	d"dZ
d#dZd$dZd%dZ xZS )&rY   zThe Pydantic mypy plugin.optionsr+   rV   Nonec                    t          |          | _        | j                                        | _        t	                                          |           d S N)PydanticPluginConfigplugin_configto_data_plugin_datasuper__init__)selfr^   	__class__s     rZ   rg   zPydanticPlugin.__init__   sH    1':: .6688!!!!!r\   fullnamerU   (Callable[[ClassDefContext], bool] | Nonec                    |                      |          }|rDt          |j        t                    r*t	          d |j        j        D                       r| j        S dS )zUpdate Pydantic model class.c              3  6   K   | ]}|j         t          k    V  d S ra   )rj   BASEMODEL_FULLNAME.0bases     rZ   	<genexpr>z5PydanticPlugin.get_base_class_hook.<locals>.<genexpr>   s*      PP44=$66PPPPPPr\   N)lookup_fully_qualified
isinstancenoder)   anymro$_pydantic_model_class_maker_callbackrh   rj   syms      rZ   get_base_class_hookz"PydanticPlugin.get_base_class_hook   sd    ))(33 	A:ch11 	APP38<PPPPP A@@tr\   (Callable[[ClassDefContext], None] | Nonec                *    |t           k    r| j        S dS )z,Update Pydantic `ModelMetaclass` definition.N)MODEL_METACLASS_FULLNAME)_pydantic_model_metaclass_marker_callbackrh   rj   s     rZ   get_metaclass_hookz!PydanticPlugin.get_metaclass_hook   s    ///AAtr\   (Callable[[FunctionContext], Type] | Nonec                b    |                      |          }|r|j        t          k    r| j        S dS )z/Adjust the return type of the `Field` function.N)rs   rj   FIELD_FULLNAME_pydantic_field_callbackry   s      rZ   get_function_hookz PydanticPlugin.get_function_hook   s7    ))(33 	13<>1100tr\   &Callable[[MethodContext], Type] | Nonec                >    |                     d          rt          S dS )z-Adjust return type of `from_orm` method call.z	.from_ormN)endswithfrom_attributes_callbackr   s     rZ   get_method_hookzPydanticPlugin.get_method_hook   s#    [)) 	,++tr\   c                J    |t           k    rt          dk     rt          j        S dS )zMark 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     rZ   get_class_decorator_hookz'PydanticPlugin.get_class_decorator_hook   s)    
 ))).@6.I.I==tr\   ctxr1   dict[str, Any]c                    | j         S )zjReturn all plugin config data.

        Used by mypy to determine if cache needs to be discarded.
        )re   )rh   r   s     rZ   report_config_dataz!PydanticPlugin.report_config_data   s    
   r\   r-   boolc                v    t          |j        |j        |j        | j                  }|                                S ra   )PydanticModelTransformerclsreasonapirc   	transform)rh   r   transformers      rZ   rx   z3PydanticPlugin._pydantic_model_class_maker_callback   s0    .sw
CGTM_``$$&&&r\   c                    | j         j        rdS |j        j        j        }|s
J d            t          |j        dd          rd|j        _        dS dS )zReset 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)rc   debug_dataclass_transformr   infodeclared_metaclassgetattrtyper   )rh   r   info_metaclasss      rZ   r   z8PydanticPlugin._pydantic_model_metaclass_marker_callback   sm     7 	F8NNNNN~>&(BDII 	@;?N888	@ 	@r\   r.   r>   c                  	 |j         	|j        d         dk    s
J d            |j        d         dk    s
J d            |j        d         }|j        d         }|r|rt          |j        |j                   	S |r3|j        d         d         }|d         }t          |t                    s|S n|r|j        d         d         }t          |t                    r|j
        d         }t          |t                    rU|j        }t          |dd          }|r9t          d	 |D                       r t          	fd
|D                       |_        |S 	S )ao  Extract 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()argsNc              3  @   K   | ]}t          |t                    V  d S ra   )rt   rA   )rp   args     rZ   rr   z:PydanticPlugin._pydantic_field_callback.<locals>.<genexpr>   s,      HHC:c;77HHHHHHr\   c              3     K   | ]}V  d S ra    )rp   _default_any_types     rZ   rr   z:PydanticPlugin._pydantic_field_callback.<locals>.<genexpr>   s$      -M-M1.>-M-M-M-M-M-Mr\   )default_return_typecallee_arg_namesr   +error_default_and_default_factory_specifiedr   context	arg_typesrt   r   r=   itemsr:   ret_typer   alltuple)
rh   r   default_argsdefault_factory_argsdefault_typedefault_argdefault_factory_typer   r   r   s
            @rZ   r   z'PydanticPlugin._pydantic_field_callback   s    2#A&)3335g333#A&*;;;;=x;;;x{"x{ 	$0 	$7MMM## 	 =+A.L&q/K k<88 $##$ " 	 #&=#3A#6  .
;; E';'A!'D$.== 	 /8 x66 NHH4HHHHH N(--M-M-M-M-M-M-M(M(Mr\   r^   r+   rV   r_   )rj   rU   rV   rk   )rj   rU   rV   r|   )rj   rU   rV   r   )rj   rU   rV   r   )r   r1   rV   r   )r   r-   rV   r   )r   r-   rV   r_   )r   r.   rV   r>   )__name__
__module____qualname____doc__rg   r{   r   r   r   r   r   rx   r   r   __classcell__)ri   s   @rZ   rY   rY      s        ##" " " " " "
               ! ! ! !' ' ' '@ @ @ @.  .  .  .  .  .  .  . r\   rY   c                  P    e Zd ZU dZdZded<   ded<   ded<   ded<   ddZddZdS )rb   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   r^   r+   rV   r_   c                   |j         d S t          |j                   }||                    di                               di           }| j        D ]P}|                    |d          }t	          |t
                    st          d|           t          | ||           Qd S t                      }|	                    |j                    | j        D ]0}|
                    t          |d          }t          | ||           1d S )NtoolrJ   Fz/Configuration value must be a boolean for key: )fallback)config_file
parse_tomlget	__slots__rt   r   
ValueErrorsetattrr   read
getbooleanCONFIGFILE_KEY)rh   r^   toml_configconfigkeysettingrc   s          rZ   rg   zPydanticPluginConfig.__init__  s$   &F !455" __VR0044_bIIF~ , , **S%00!'400 ^$%\WZ%\%\]]]c7++++	, , )NNMw2333~ , ,'22>3QV2WWc7++++, ,r\   r   c                *      fd j         D             S )z/Returns a dict of config names to their values.c                2    i | ]}|t          |          S r   )r   )rp   r   rh   s     rZ   
<dictcomp>z0PydanticPluginConfig.to_data.<locals>.<dictcomp>#  s%    BBBCWT3''BBBr\   )r   rh   s   `rZ   rd   zPydanticPluginConfig.to_data!  s    BBBB4>BBBBr\   Nr   rV   r   )r   r   r   r   r   __annotations__rg   rd   r   r\   rZ   rb   rb      s          I ''''####, , , ,&C C C C C Cr\   rb   r   r/   r>   c                \   | j         }t          |t                    r|j        }t          |t                    r"t          |j        t                    r|j        }nMt          |t                    r|}n5d| d|j        j         d}t          || j
        | j                   | j        S |j         j                            t                    }|| j        S |                    di                               d          }|dur%t!          |j         j        | j
        | j                   | j        S )z1Raise an error if from_attributes is not enabled.z
ctx.type: 
 (of type )Nr   from_attributesT)r   rt   r@   itemr:   r   r;   ri   r   error_unexpected_behaviorr   r   r   metadatar   METADATA_KEYerror_from_attributesname)r   ctx_type
model_typedetailpydantic_metadatar   s         rZ   r   r   &  s%    xH(H%% !=(L)) 'j9JH.U.U '&

	Hh	'	' '

PhPP(2D2MPPP!&#'3;???&&"044\BB &&'++Hb99==>OPPOd""jo2CGS[III""r\   c                  b    e Zd ZdZd'dZd(dZ	 d)d*dZ	 d)d+dZd,d Ze	d-d"            Z
d.d%Zd&S )/PydanticModelFieldz5Based on mypy.plugins.dataclasses.DataclassAttribute.r   rU   alias
str | Nonehas_dynamic_aliasr   has_defaultlineintcolumnr   Type | Noner   r)   c	                v    || _         || _        || _        || _        || _        || _        || _        || _        d S ra   )r   r   r   r   r   r   r   r   )	rh   r   r   r   r   r   r   r   r   s	            rZ   rg   zPydanticModelField.__init__@  sB     	
!2&					r\   current_infotypedforce_optional	use_aliasr   r2   force_typevars_invariantrV   r   c                    |                      ||||          }|r|                     ||          nt          t          j                  }t          ||d|s| j        rt          nt                    S )zABased on mypy.plugins.dataclasses.DataclassAttribute.to_argument.N)variabletype_annotationinitializerkind)	to_varr	   r9   r?   explicitr   r   r   r   )	rh   r   r   r   r   r   r   r   r   s	            rZ   to_argumentzPydanticModelField.to_argumentT  s{     ;;|S)=UVVAFg$**<===GT]TfLgLg+"0SD4DS)	
 
 
 	
r\   Fc                
   |rFt          | j        t                    r,| j                                        }t          |_        || _        | j        t          | j        dd          t          j	        |j
        j                  5  t          |          }|r+|j        D ]#}t          |t                    rt          |_        $t          | j        | j        j        j        |i          cddd           S # 1 swxY w Y   | j        S )zABased on mypy.plugins.dataclasses.DataclassAttribute.expand_type.N	self_type)rt   r   rA   copy_modifiedr   variancer   r   r7   strict_optional_setr^   strict_optionalrD   r   r	   r  id)rh   r   r   r   modified_typefilled_with_typevarsr   s          rZ   r	   zPydanticModelField.expand_typeg  sL   
 $ 	*
 $)[11 * $	 7 7 9 9)2&)	9 WTYT%J%J%V
 *3;+FGG ^ ^'4\'B'B$+ 538 5 5%c;77 5+4CL"49ty/B/EG[.\]]^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ys   A"C33C7:C7r*   c                |    |r| j         | j         }n| j        }t          ||                     |||                    S )z<Based on mypy.plugins.dataclasses.DataclassAttribute.to_var.)r   r   r*   r	   )rh   r   r   r   r   r   s         rZ   r  zPydanticModelField.to_var  sF      	/:DD9D4)),=UVVWWWr\   r   c                    | j         sJ | j        | j        | j        | j        | j        | j        | j                                         dS )?Based on mypy.plugins.dataclasses.DataclassAttribute.serialize.)r   r   r   r   r   r   r   )r   r   r   r   r   r   r   	serializer   s    rZ   r  zPydanticModelField.serialize  sO    yyIZ!%!7+IkI''))
 
 	
r\   datac                    |                                 }t          |                    d          |          } | d||d|S )ABased on mypy.plugins.dataclasses.DataclassAttribute.deserialize.r   )r   r   r   )copyr4   pop)r   r   r  r   typs        rZ   deserializezPydanticModelField.deserialize  sI     yy{{(&)9)93??s/$//$///r\   sub_typer_   c                    | j         Yt          j        |j        j                  5  t          | j         || j                  | _         ddd           dS # 1 swxY w Y   dS dS )zxExpands type vars in the context of a subtype when an attribute is inherited
        from a generic super type.
        N)r   r7   r  r^   r	  r8   r   )rh   r  r   s      rZ   expand_typevar_from_subtypez.PydanticModelField.expand_typevar_from_subtype  s     9 *3;+FGG T T3DIxSS	T T T T T T T T T T T T T T T T T T ! s   !AAAN)r   rU   r   r   r   r   r   r   r   r   r   r   r   r   r   r)   )r   r)   r   r   r   r   r   r   r   r2   r   r   rV   r   F)r   r)   r   r2   r   r   rV   r   )
r   r)   r   r2   r   r   r   r   rV   r*   rV   r   )r   r)   r  r   r   r2   rV   r   )r  r)   r   r2   rV   r_   )r   r   r   r   rg   r  r	   r  r  classmethodr  r  r   r\   rZ   r   r   =  s        ??   (
 
 
 
( ns    D */X X X X X
 
 
 
 0 0 0 [0T T T T T Tr\   r   c                  8    e Zd ZdZd Zed	d            Zd
dZdS )PydanticModelClassVarzBased on mypy.plugins.dataclasses.DataclassAttribute.

    ClassVars are ignored by subclasses.

    Attributes:
        name: the ClassVar name
    c                    || _         d S ra   r   )rh   r   s     rZ   rg   zPydanticModelClassVar.__init__  s    			r\   r  r   rV   c                :    |                                 } | di |S )r  r   )r  )r   r  s     rZ   r  z!PydanticModelClassVar.deserialize  s#     yy{{s{{T{{r\   c                    d| j         iS )r  r   r!  r   s    rZ   r  zPydanticModelClassVar.serialize  s     DI
 	
r\   N)r  r   rV   r  r  )r   r   r   r   rg   r  r  r  r   r\   rZ   r  r    sa               [

 
 
 
 
 
r\   r  c                      e Zd ZU dZh dZded<   dHdZdIdZdJdZdKdZ	dLdZ
dMdZdNdZdOd$ZdPd,ZdQd1ZdRd2ZdSd4ZdTdUd:ZedVd;            ZedWd=            Z	 dTdXdCZdYdDZedZdF            ZdGS )[r   zTransform 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_namezset[str]tracked_config_fieldsr   r   r   Expression | Statementr   r2   rc   rb   rV   r_   c                >    || _         || _        || _        || _        d S ra   )_cls_reason_apirc   )rh   r   r   r   rc   s        rZ   rg   z!PydanticModelTransformer.__init__  s'     		*r\   r   c                ~   | j         j        }t          d |j        dd         D                       }|                                 }|                     ||          \  }}||dS |D ]}|j         dS t          d |j        dd         D                       }|                     ||||           |s|                     |||           | 	                    || j
        |j        du            |                                  d |D             d	 |D             |                                d
|j        t          <   dS )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
        c              3  2   K   | ]}t           |j        v V  d S ra   )ROOT_MODEL_FULLNAMErj   ro   s     rZ   rr   z5PydanticModelTransformer.transform.<locals>.<genexpr>  s*      [[T/4=@[[[[[[r\   NFc              3  6   K   | ]}|j         t          k    V  d S ra   )rj   BASESETTINGS_FULLNAMEro   s     rZ   rr   z5PydanticModelTransformer.transform.<locals>.<genexpr>  s*      [[T$-+@@[[[[[[r\   T)r&  c                B    i | ]}|j         |                                S r   r   r  )rp   fields     rZ   r   z6PydanticModelTransformer.transform.<locals>.<dictcomp>  s&    IIIuz5??#4#4IIIr\   c                B    i | ]}|j         |                                S r   r6  )rp   	class_vars     rZ   r   z6PydanticModelTransformer.transform.<locals>.<dictcomp>  s(    ]]]Y9>9+>+>+@+@]]]r\   )fields
class_varsr   )r,  r   rv   rw   collect_configcollect_fields_and_class_varsr   add_initializeradd_model_construct_method
set_frozenr.  r&  adjust_decorator_signaturesget_values_dictr   r   )rh   r   is_root_modelr   r:  r;  r7  is_settingss           rZ   r   z"PydanticModelTransformer.transform  s{    y~[[TXVYWYVY][[[[[$$&&!??VV
>Z/5 	 	Ez!uu " [[TXVYWYVY][[[[[VV[-HHH 	I++FFKHHH	&-42GHHH((*** JI&III]]R\]]],,..'
 '
l# tr\   c                   | j         j        j                                        D ]\  }}t	          |j        t                    r|j        j        d         t	          t                    rt	          j	        t                    rfj	        j        t          v rSj	        j        t          k    r-t          fdt          j                  D                       sd|j        j        _        dS )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`.
        r   c              3     K   | ]8\  }}j         |         d k    ot          |t                    o
|j        dk    V  9dS )modeafterN)	arg_namesrt   r%   value)rp   ir   	first_decs      rZ   rr   zGPydanticModelTransformer.adjust_decorator_signatures.<locals>.<genexpr>  sg           &3 &/2f<rCQXAYAYr^a^gkr^r           r\   TN)r,  r   namesr   rt   ru   r   original_decoratorsr   calleer    rj   DECORATOR_FULLNAMESMODEL_VALIDATOR_FULLNAMErv   	enumerater   funcis_class)rh   r   rz   rL  s      @rZ   rA  z4PydanticModelTransformer.adjust_decorator_signatures
  s     -3355 	2 	2ID##(I.. 2H8;	y(332"9#3X>>2 "(15HHH "(15MMM        *3IN*C*C        N .2CHM*#	2 	2r\   ModelConfigDatac           	        | j         }t                      }d}d}|j                                        D ]4\  }}|                     ||          }|rd}|                    |           5d}|j        j        D ]}t          |t          t          f          s t          |t                    r|j        d         }	t          |	t                    r|	j        dk    rdt          |j        t                    rZt!          |j        j        |j        j                  D ]3\  }
}|
|                    |                     |
|d                     4nt          |j        t&                    rV|j        j        D ]I\  }}t          |t(                    s|                    |                     |j        |                     Jnt          |t                    r|j        dk    rk|j        j        D ]n}t          |t                    s|j        d         }	t          |	t                    s;|                    |                     |	j        |j                             o|r| j                            d|            nd}	|s|r1|r/|j        r(|j        s!| j        j        rt9          | j        |           |j        j        d	d         D ]}t>          |j         vr| j        !                    tE          |j#                             |j         t>                   d
                                         D ]\  }}|$                    ||           |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,  rU  keywordsr   get_config_updateupdatedefsbodyrt   r   r   lvaluesr    r   rvaluer   ziprI  r   r   r%   rJ  r.  failhas_alias_generatorr(  rc   r   error_required_dynamic_aliasesr   rw   r   r   add_plugin_dependencyr6   rj   
setdefault)rh   r   r   has_config_kwargshas_config_from_namespacer   exprconfig_datastmtlhsarg_namer   key_expr
value_exprsubstmtr   rJ  s                    rZ   r<  z'PydanticModelTransformer.collect_config%  s   i ""!$)! ,,,.. 	+ 	+JD$00t<<K +$(!k*** "&HM &	- &	-Dd^X$>?? $// Tl1o!#x00 CH4N4Ndk844 	Z),T[-BDKDT)U)U ] ]##+$d&<&<XsVZ&<&[&[\\\\]  X66 Z040A Z Z,*)(G<< %$d&<&<X^Z&X&XYYYYD(++ 	T9((#y~ T TG%g~>> ! !/!,C%c844 ! MM$"8"87>"R"RSSSS  	o   (,%% 	@ 9 	@@.@ /@ &D	@ /ty$???HL$ 	/ 	/D4=00 I++,A$-,P,PQQQ#}\:8DJJLL / /e!!$..../r\   rW  rC  Jtuple[list[PydanticModelField] | None, list[PydanticModelClassVar] | None]c                   | j         }i }i }t          |j        j        dd                   D ]c}t          |j        vr| j                            t          |j	                             |j        t                   d         
                                D ]\  }}t                              ||| j                  }	|	                    |j        | j                   |	||<   |j        j                            |          }
|
rA|
j        r:t#          |
j        t$                    s | j                            d|
j                   |j        t                   d         
                                D ]"\  }}t(                              |          ||<   #et+                      }t+                      }|                     |j                  D ]}|                     |||          }t#          |t                    rU|j        d         }|r!|j        dk    rt7          | j        |           ^|                    |j                   |||j        <   t#          |t(                    r1|j        d         }|                    |j                   |||j        <   t;          |                                          t;          |                                          fS )zACollects the fields for the model, accounting for parent classes.r   r2  r:  z7BaseModel field may only be overridden by another fieldr;  r   root)r,  reversedr   rw   r   r   r.  re  r6   rj   r   r   r  r  rM  r   ru   rt   r*   rb  r  set%_get_assignment_statements_from_blockr]  $collect_field_or_class_var_from_stmtr_  r    error_extra_fields_on_root_modeladdlistvalues)rh   rW  rC  r   found_fieldsfound_class_varsr   r   r  r7  sym_nodecurrent_field_namescurrent_class_vars_namesrk  maybe_fieldrl  s                   rZ   r=  z6PydanticModelTransformer.collect_fields_and_class_varsq  s    i 79=?SX\!B$/00 	Q 	QD 4=00 I++,A$-,P,PQQQ"mL9(CIIKK  
d*66tT49MM
 11#(DIFFF%*T"8>--d33  jPS6T6T INNQ   
 #mL9,GMMOO Q Q
d)>)J)J4)P)P &&Q ),-0UU >>sxHH 	9 	9DCCD,XhiiK+'9:: 
9l1o  9SX%7%74TYEEEE'++CH555-8L**K)>?? 9l1o(,,SX666-8 *L''))**D1A1H1H1J1J,K,KKKr\   rk  r   Iterator[AssignmentStmt]c              #     K   |j         D ]$}|j        s|                     |          E d {V  %|j        .|j        j        s$|                     |j                  E d {V  d S d S d S ra   )r^  is_unreachablerv  	else_body)rh   rk  r^  s      rZ   ,_get_assignment_statements_from_if_statementzEPydanticModelTransformer._get_assignment_statements_from_if_statement  s      I 	L 	LD& LEEdKKKKKKKKK>%dn.K%AA$.QQQQQQQQQQQ &%%%r\   blockr   c              #     K   |j         D ]L}t          |t                    r|V  t          |t                    r|                     |          E d {V  Md S ra   )r^  rt   r   r   r  )rh   r  rk  s      rZ   rv  z>PydanticModelTransformer._get_assignment_statements_from_block  s}      J 	S 	SD$// S



D&)) SLLTRRRRRRRRR		S 	Sr\   r   r;   dict[str, PydanticModelClassVar]1PydanticModelField | PydanticModelClassVar | Nonec           
        | j         }|j        d         }t          |t                    r$t	          j        |j                  r|j        dk    rdS |j        st          |j        t                    rbt          |j        j
        t                    rCt          |j        j
        j
        t                    r|j        j
        j
        j        t          v rdS |j        |v rdS t          | j        |           dS |j        d         }t          |t                    sdS t	          j        |j                  r|j        dk    rdS |j        j                            |j                  }|dS |j        }t          |t&                    rdS t          |t(                    r| j                            d|           dS t          |t,                    sdS |j        rt1          |j                  S t3          |j                  }t          |t6                    r+|j        j        dk    r| j                            d|           |                     |          }	|j        r|j        rk|j        rd| j                            |j        d          }
|
r|
|_        n9| j                            d	|           tA          tB          j"                  |_        | #                    |          \  }}|r(|j$        s!| j%        j&        rtO          | j        |           | (                    ||j        |          }tS          |j        ||	||j*        |j+        ||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`.
        r   rW  NzFType aliases inside BaseModel definitions are not supported at runtimezdataclasses.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,  r_  rt   r    rG   is_valid_field_namer   
new_syntaxr`  r   rO  rj   rP  error_untyped_fieldsr.  r   rM  r   ru   r"   r(   rb  r*   is_classvarr  rC   r   r;   get_has_defaultr  is_inferredanalyze_simple_literal_typer9   r?   
from_errorget_alias_infor(  rc   r   rd  _infer_dataclass_attr_init_typer   r   r   )rh   rk  rW  r;  r   rl  rz   ru   	node_typer   r  r   r   	init_types                 rZ   rw  z=PydanticModelTransformer.collect_field_or_class_var_from_stmt  s^    il1o#x(( 	0KCH0U0U 	Y\YaesYsYs4 	4;11	t{18<<	 t{18(CC	 K&-6:MMM
 tx:%%t !D1114l1o#x(( 	4*3844 	N8R8R4hn  **; 4xdO,, 	
 4dI&& 	INNX   4$$$ 	
 4  	3(222 $DI..	i** 	y~/FJ_/_/_INN7  
 **4008$2B )77d7SSC :			]   $I$899	#'#6#6t#<#<   	<\%B 	<tGYGw 	<*49d;;;88chMM	!/#;	
 	
 	
 		
r\   rz   r&   r   rU   r   r   r   c                   |j         }|j        r|S t          |j                   }t          |t                    s|S |j                             d          }|r!t          |j        t                    r|j                             d          }|sJ |j         r)t          t          |j         |j         |                    }nt          t          j                  S t          |t                    r8|j        t          t          t          gk    rt!          |j        d         |          S | j                            d|j         j         d|           n)| j                            d|j         j         d|           |S )zvInfer __init__ argument type for an attribute.

        In particular, possibly use the signature of __set__.
        __set__rS   z(Unsupported signature for "__set__" in ""zUnsupported "__set__" in ")r   implicitrC   rt   r;   r   ru   r   get_containing_type_infor8   r9   r?   unannotatedr:   	arg_kindsr   r
   r   r.  rb  r   )	rh   rz   r   r   r   tsetter
super_infosetter_types	            rZ   r  z8PydanticModelTransformer._infer_dataclass_attr_init_type=  sq   
 (< 	NCH%% !X&& 	NI&& 	U&+w// UV<<YGG
!!!z; :"12I&+WXW]_i2j2j"k"kKK"9#8999k<88 g[=RW > >
 3;3H3KQOOOINN#\afk#\#\#\^effff	JAFKJJJGTTTr\   r:  list[PydanticModelField]r   rD  c           	        d| j         j        j        v r| j         j        j        d         j        sdS | j        j        }|j        du}t          |j        o|j                   }| 	                    |||||d          }|r:t          dk    r/|d         j        t          k    rt          nt          |d         _        |r| j                            t"                    j        }	d|	j        v r|	j        d         j        }
|
|
j        |
j        }t)          |j                  D ]\  }}|                    d          s|                    d          s0| j                            |j        |                   }t3          ||          }|                    t7          ||dt                               |                     ||          sPt3          d	          }|                    t7          |t;          t<          j                  dt@                               tC          | j        | j         d|tE                      
           dS )zAdds a fields-aware `__init__` method to the class.

        The added `__init__` will be annotated with types vs. all `Any` depending on the plugin settings.
        rg   NT)r   requires_dynamic_aliasesr   rD  r   )r   r   r   r   __r   kwargs)r   return_type)#r,  r   rM  plugin_generatedrc   r   r(  r   rc  get_field_argumentsr   r   r   r   r   r.  rs   r4  ru   r   rR  rI  
startswith	anal_typer   r*   appendr   should_init_forbid_extrar9   r?   r  r   
add_methodr<   )rh   r:  r   rD  rC  r   r   r  r   base_settings_nodebase_settings_init_node	func_typearg_idxrm  analyzed_variable_typer   vars                    rZ   r>  z(PydanticModelTransformer.add_initializerc  s:    ---din6J:6V6g-F"-+47	#'(B(b6KbGb#c#c ''%=#%) ( 
 
  	M/9<< '+1gli&?&?77WDGL 	_!%!A!ABW!X!X!]/555*<*B:*N*S'*6;R;W;c 7 <I-6y7J-K-K _ _)#..t44 %H<O<OPS<T<T %$151D1DYEXY`Ea1b1b.#&x1G#H#HHX7MtU\$]$]^^^^,,VV<< 	Uh--CKKgi.@&A&A4SSTTT49di$HJJWWWWWWr\   c           	         | j                             t           d| j                             t           d          g          }t          |t	                      g          }t          t          d|          |dt                    }t          j	        | j         j
        j                  5  |                     |ddd|          }ddd           n# 1 swxY w Y   |                     ||          sPt          d          }|                    t          |t          t           j                  dt$                               |g|z   }t'          | j         | j        d	|t+          | j        j                  d
           dS )zAdds 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   rD  r  model_construct)r   r  is_classmethod)r.  
named_typeBUILTINS_NAMErB   r<   r   r*   r   r7   r  r^   r	  r  r  r  r9   r?   r  r   r  r,  rD   r   )	rh   r:  r   rD  set_stroptional_set_strfields_set_argumentr   r  s	            rZ   r?  z3PydanticModelTransformer.add_model_construct_method  s    )&&-'='='=	@T@TXeUkUkUk@l@l?mnn$gxzz%:;;&s=:J'K'KM]_celmm&ty'8'HII 	 	++dUeal ,  D	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 ,,VV<< 	Uh--CKKgi.@&A&A4SSTTT#$t+II%din55	
 	
 	
 	
 	
 	
s   *CCCr&  c                   | j         j        }|D ]<}|j                            |j                  }||j        }t          |t                    r||_        Ht          |t                    r&| j
        j        s| j
                                         	 t          |          }n# t          $ r t          |          }Y nw xY wd| d|j         d}	t#          |	| j
        | j                    |                    ||d          }||_        ||_        |j        dz   |j        z   |_        t+          t,          |          |j        |j        <   >dS )zMarks 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.
        Nzsym_node.node: r   r   F)r   .)r,  r   rM  r   r   ru   rt   r*   is_propertyr"   r.  final_iterationdeferrU   	TypeErrorreprri   r   r  rj   	_fullnamer&   r   )
rh   r:  r   r&  r   r7  r~  r  var_strr   s
             rZ   r@  z#PydanticModelTransformer.set_frozen  sd   
 y~ 	B 	BEz~~ej11H#mc3'' L&,COO_55 Ldi>W LIOO%%%%,"%c(($ , , ,"&s)), SwRR#-RRRF-fdiKKKKll4l>>"( $ 3ch >'6tS'A'A
38$$/	B 	Bs   B##B?>B?Fr   r   rX  ModelConfigData | Nonec                
   || j         vrdS |dk    rlt          |t                    r|j        dk    }n;t          |t                    r|j        dk    }n|st          || j        |           dS t          |          S |dk    r4d}t          |t                    r|j
        dk    rd}t          |	          S t          |t                    r |j
        d
v rt          di ||j
        dk    iS t          || j        |           dS )zDetermines 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)rc  )builtins.Truezbuiltins.Falser  r   )r)  rt   r%   rJ  r   r   error_invalid_config_valuer.  rU  r    rj   )rh   r   r   rX  r  rc  s         rZ   r[  z*PydanticModelTransformer.get_config_update  s6   
 t11147??#w'' "yH4C,, "x83  	E /tTYDDDt"====$$$"&#x(( ,S\_-L-L&+#"7JKKKKc8$$ 	N9\)\)\"MMdCLO,K%LMMM"4C888tr\   c                   | j         }t          |t                    rdS t          |t                    rt          |j        t
                    rx|j        j        t          k    rct          |j	        |j
                  D ]F\  }}||dk    r|j        t          uc S |dk    r#t          |t                    o
|j        dk     c S GdS t          |t                     S )zUReturns a boolean indicating whether the field defined in `stmt` is a required field.FNr   r   r  )r`  rt   r'   r   rO  r#   rj   r   ra  r   rI  ri   r   r    )rk  ri  r   r   s       rZ   r  z(PydanticModelTransformer.get_has_default  s     {dH%% 	5dH%% 	*T['*J*J 	t{OcguOuOu
 !DN;; _ _	T<49#4#4=<<<<,,, *3 9 9 ]clo>]^^^^ -5dL1111r\   tuple[str | None, bool]c                n   | j         }t          |t                    rdS t          |t                    r/t          |j        t
                    r|j        j        t          k    sdS t          |j	                  D ];\  }}|dk    r|j
        |         }t          |t                    r|j        dfc S  dS dS )a  Returns 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)r`  rt   r'   r   rO  r#   rj   r   rR  rI  r   r%   rJ  )rk  ri  rK  rm  r   s        rZ   r  z'PydanticModelTransformer.get_alias_info  s     {dH%% 	; tX&&	+5dk7+K+K	PTP[PdhvPvPv ;$T^44 	" 	"KAx7"")A,C#w'' "y%''''!zz{r\   r   r   r  r   list[Argument]c                T      j         j         fd|D             }|S )zHelper 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.
        c           
     f    g | ]-}r|j         |                    pj                   .S ))r   r   r   r   r   )r   r  r.  )	rp   r7  r   r   rD  r  rh   r   r   s	     rZ   
<listcomp>z@PydanticModelTransformer.get_field_arguments.<locals>.<listcomp>1  sl     
 
 
 
 #("9
7F;#I)A   
 
 
r\   )r,  r   )	rh   r:  r   r   r  rD  r   	argumentsr   s	   ` ````` @rZ   r  z,PydanticModelTransformer.get_field_arguments#  sd     y~
 
 
 
 
 
 
 
 
 
  
 
 
	 r\   c                    |j         s*|                     |t          |j                            rdS |j        rdS | 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   rc  r  rc   r   )rh   r:  r   s      rZ   r  z1PydanticModelTransformer.should_init_forbid_extra?  sS     & 	,,VT&:T5U5UVV u 	4!33r\   rc  c                F    | D ]}|j         r dS |r| D ]}|j         dS dS )zReturns whether any fields on the model have a "dynamic alias", i.e., an alias that cannot be
        determined during static analysis.
        TNF)r   r   )r:  rc  r7  s      rZ   r  z1PydanticModelTransformer.is_dynamic_alias_presentL  sZ    
  	 	E& tt 	     ;&44 'ur\   N)
r   r   r   r*  r   r2   rc   rb   rV   r_   )rV   r   )rV   r_   )rV   rU  )rW  rU  rC  r   rV   rq  )rk  r   rV   r  )r  r   rV   r  )rk  r   rW  rU  r;  r  rV   r  )rz   r&   r   rU   r   r   rV   r   )
r:  r  r   rU  rD  r   rC  r   rV   r_   )r:  r  r   rU  rD  r   rV   r_   )r:  r  r   r2   r&  r   rV   r_   r  )r   rU   r   r   rX  r   rV   r  )rk  r   rV   r   )rk  r   rV   r  )r:  r  r   r   r   r   r  r   rD  r   r   r   rV   r  )r:  r  r   rU  rV   r   )r:  r  rc  r   rV   r   )r   r   r   r   r)  r   rg   r   rA  r<  r=  r  rv  rw  r  r>  r?  r@  r[  staticmethodr  r  r  r  r  r   r\   rZ   r   r     s         ' ' '    + + + +# # # #J2 2 2 26J J J JX?L ?L ?L ?LBR R R RS S S S{
 {
 {
 {
z$ $ $ $L,X ,X ,X ,X\
 
 
 
<B B B B>! ! ! ! !F 2 2 2 \2*    \D */    84 4 4 4    \  r\   r   c                  >    e Zd ZdZ	 	 	 	 	 ddd	ZddZddZddZdS )rU  z(Pydantic mypy plugin model config class.Nr  bool | Noner&  r   r(  rc  c                L    || _         || _        || _        || _        || _        d S ra   )r  r&  r   r(  rc  )rh   r  r&  r   r(  rc  s         rZ   rg   zModelConfigData.__init__^  s1     ). 0#6   r\   rV   r   c                H    d | j                                         D             S )zReturns a dict of Pydantic model config names to their values.

        It includes the config if config value is not `None`.
        c                    i | ]
\  }}|||S ra   r   )rp   kvs      rZ   r   z3ModelConfigData.get_values_dict.<locals>.<dictcomp>q  s    HHHA!-1---r\   )__dict__r   r   s    rZ   rB  zModelConfigData.get_values_dictl  s'    
 IH!4!4!6!6HHHHr\   r   r  r_   c                    |dS |                                                                 D ]\  }}t          | ||           dS )z$Update Pydantic model config values.N)rB  r   r   )rh   r   r  r  s       rZ   r\  zModelConfigData.updates  sV    >F**,,2244 	  	 DAqD!Q	  	 r\   r   rU   rJ  r   c                L    t          | |          t          | ||           dS dS )zFSet default value for Pydantic model config if config value is `None`.N)r   r   )rh   r   rJ  s      rZ   rf  zModelConfigData.setdefaultz  s2    4%D#u%%%%% &%r\   )NNNNN)
r  r  r&  r  r   r  r(  r  rc  r  r   )r   r  rV   r_   )r   rU   rJ  r   rV   r_   )r   r   r   r   rg   rB  r\  rf  r   r\   rZ   rU  rU  [  s        22 %)"'+(,+/7 7 7 7 7I I I I       & & & & & &r\   rU  zpydantic-ormzInvalid from_attributes callPydanticzpydantic-configzInvalid config valuezpydantic-aliaszDynamic alias disallowedzpydantic-unexpectedzUnexpected behaviorzpydantic-fieldzUntyped field disallowedzInvalid Field defaultsz!Extra field on RootModel subclass
model_namer   r,   r   r   r_   c                H    |                     d|  d|t                     dS )zCEmits an error when the model does not have `from_attributes=True`.r  z$" does not have from_attributes=TruecodeN)rb  	ERROR_ORM)r  r   r   s      rZ   r   r     s-    HHAAAA7QZH[[[[[r\   r   r2   c                H    |                     d|  d|t                     dS )z0Emits an error when the config value is invalid.zInvalid value for "Config.r  r  N)rb  ERROR_CONFIG)r   r   r   s      rZ   r  r    s,    HH1$1117HNNNNNr\   c                @    |                      d|t                     dS )znEmits required dynamic aliases error.

    This will be called when `warn_required_dynamic_aliases=True`.
    z#Required dynamic aliases disallowedr  N)rb  ERROR_ALIASr   r   s     rZ   rd  rd    s#    
 HH2G+HNNNNNr\   r   8CheckerPluginInterface | SemanticAnalyzerPluginInterfacec                b    d}d|  d}|d| dz  }|                     ||t                     dS )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)rb  ERROR_UNEXPECTED)r   r   r   linkfull_messages        rZ   r   r     sO    
 DDWVWWWL\T\\\\LHH\7)9H:::::r\   c                @    |                      d|t                     dS )z;Emits an error when there is an untyped field in the model.zUntyped fields disallowedr  N)rb  ERROR_UNTYPEDr  s     rZ   r  r    s!    HH('HFFFFFr\   c                @    |                      d|t                     dS )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)rb  ERROR_EXTRA_FIELD_ROOT_MODELr  s     rZ   rx  rx    s"    HHA7QmHnnnnnr\   c                @    |                      d|t                     dS )zNEmits an error when `Field` has both `default` and `default_factory` together.z>Field default and default_factory cannot be specified togetherr  N)rb  ERROR_FIELD_DEFAULTSr  s     rZ   r   r     s"    HHMw]qHrrrrrr\   F8SemanticAnalyzerPluginInterface | CheckerPluginInterfacer   r   r   r  r  r  r   tvar_defTypeVarDef | Noner  r   c                ,   |j         }||j        v rR|j        |         }	|	j        r>t          |	j        t
                    r$|j        j                            |	j                   t          | t                    r| 
                    d          }
n|                     dg           }
|rE|pt          t          |                    }t          t          d          |dt           d          g}n6|pt          |          }t          t          d          |dt                     g}||z   }g g g }}}|D ]f}|j        s
J d            |                    |j                   |                    |j        j                   |                    |j                   gt-          |||||
          }|r|g|_        t          ||t1          t3                      g                    }||_         t5          ||          |_        ||_        |j        dz   |z   |_        |j        |_        ||j        v r*tA          ||j                  }|j        |         |j        |<   |rwd|_!        t          ||j                  }||_         |j        |_        d|_"        tG          |tI          d          g|          }|j        |_        tK          tL          |          }	ntK          tL          |          }	d|	_        |	|j        |<   |j'        j        j                            |           dS )	zhVery closely related to `mypy.plugins.common.add_method_to_class`, with a few pydantic-specific changes.zbuiltins.functionr,  NT__pydantic_self__z"All arguments must be fully typed.r  r  )(r   rM  r  rt   ru   r   r]  r^  remover2   r  named_generic_typer@   rD   r   r*   r   r   r  r   r   r   r:   	variablesr   r!   r5   r   rT  rj   r  r   rE   is_decoratedr  r   r    r&   r   defn)r   r   r   r   r  r  r  r  r   rz   function_typefirstr   rI  r  r   	signaturerS  r_namer  decs                        rZ   r  r    s    8D tzj 	+Jsx$A$A 	+HM  ***#677 H':;;../BBGG O>-*=*=!>!>	#f++y$FFG4t!4!4	 #122ItWMMN4<D&("b)yI # #"HH$HHH",---*+++""""Y	9k=YYI )'j	4uhjj\2233DDI!)T22DI"DM]S(4/DN	DI tz-dDJ??!Z-
6
  
* di  nx667;;9dC((dD))CDJtINt$$$$$r\   r   dict[str, Any] | Nonec                8   |                      d          sdS t          j        dk    rddl}n0	 ddl}n*# t
          $ r ddl}|                    d           Y dS w xY wt          | d          5 }|	                    |          cddd           S # 1 swxY w Y   dS )zReturns 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)      r   zJNo 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       rZ   r   r     s   
 (( t
7""	!!!!! 	 	 	OOOMMfggg44		 
k4	 	  Bzz"~~                 s!   3 #AA-BBB)rT   rU   rV   rW   )r   r/   rV   r>   )r  rU   r   r,   r   r   rV   r_   )r   rU   r   r2   r   r   rV   r_   )r   r2   r   r   rV   r_   )r   rU   r   r  r   r   rV   r_   )r   r,   r   r   rV   r_   )NNF)r   r  r   r   r   rU   r   r  r  r>   r  r   r  r  r  r   rV   r_   )r   rU   rV   r  )r   
__future__r   r  configparserr   typingr   r   r   mypy.errorcodesr   mypy.expandtyper	   r
   
mypy.nodesr   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r    r!   r"   r#   r$   r%   r&   r'   r(   r)   r*   mypy.optionsr+   mypy.pluginr,   r-   r.   r/   r0   r1   r2   mypy.pluginsr3   mypy.plugins.commonr4   mypy.semanalr5   mypy.server.triggerr6   
mypy.stater7   mypy.typeopsr8   
mypy.typesr9   r:   r;   r<   r=   r>   r?   r@   rA   rB   rC   mypy.typevarsrD   	mypy.utilrE   mypy.versionrF   mypy_versionpydantic._internalrG   pydantic.versionrH   rI   r  r   r   rn   r4  r1  r~   r   r   rQ  rP  r   r  r[   rY   rb   r   r   r  r   rU  r  r  r  r  r  r  r  r   r  rd  r   r  rx  r   r  r   r   r\   rZ   <module>r1     s)   d d " " " " " " 



 % % % % % % * * * * * * * * * * % % % % % % @ @ @ @ @ @ @ @! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! !D !                            % $ $ $ $ $      + * * * * * 5 5 5 5 5 5       0 0 0 0 0 0                          ( ' ' ' ' ' 2 2 2 2 2 2 4 4 4 4 4 4 & & & & & & / / / / / /5%%%%%%% 5 5 5444444445 !'. = 5 R (5 K     ('55 0H<<

.    s  s  s  s  s V s  s  s l+C +C +C +C +C +C +C +C\# # # #.pT pT pT pT pT pT pT pTf
 
 
 
 
 
 
 
2O
 O
 O
 O
 O
 O
 O
 O
d"& "& "& "& "& "& "& "&J In&DjQQ	y*,BJOOi(*DjQQ924I:VV 	*,F
SS y!13KZXX (y)9;^`jkk \ \ \ \
O O O O
O O O O; ; ; ;G G G G
o o o o
s s s s ""& U% U% U% U% U%p     s   $C+ +C98C9