o
     d[                     @   s  d dl Z d dlmZ d dlmZmZmZmZmZm	Z	m
Z
mZmZ d dlmZ d dlmZmZmZmZmZmZmZmZmZmZ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l.m/Z/ d dl0m1Z1m2Z2m3Z3m4Z4m5Z5m6Z6m7Z7 d dl8m9Z9 d d	l:m;Z; d d
l<m=Z= d dl>m?Z?m@Z@mAZAmBZBmCZCmZmDZDmEZEmFZFmGZGmHZH d dlImJZJ d dlKmLZL d dlMmNZO d dlPmQZQ zd dl>mRZR W n eSy   d dl>mFZR Y nw dZTdZUdZVdZWdZXdZYdeZde
e[df fddZ\e\eOZ]e]dkrdndZ^deZdd fd!d"Z_G d#d$ d$e5Z`G d%d& d&Zad'e4defd(d)ZbG d*d+ d+ZcG d,d- d-ZdG d.d/ d/Zeed0d1d2Zfed3d4d2Zged5d6d2Zhed7d8d2Zied9d:d2Zjed9d;d2Zkd<eZd=e1d>eddfd?d@ZldAeZd=e7d>eddfdBdCZmd=e7d>eddfdDdEZndFeZd=e1d>eddfdGdHZod=e7d>eddfdIdJZpd=e1d>eddfdKdLZq			M	Md^d'e2dAeZdNee dOedPee dQeeR dRerdSerddfdTdUZsdVeee(f deZfdWdXZtdVeee(f deZfdYdZZud[eZdeeeZef  fd\d]ZvdS )_    N)ConfigParser)	AnyCallableDictListOptionalSetTupleTypeUnion)	ErrorCode)	ARG_NAMEDARG_NAMED_OPTARG_OPTARG_POS	ARG_STAR2MDEFArgumentAssignmentStmtBlockCallExprClassDefContext	DecoratorEllipsisExprFuncBaseFuncDefJsonDict
MemberExprNameExprPassStmtPlaceholderNodeRefExprStrExpr
SymbolNodeSymbolTableNodeTempNodeTypeInfoTypeVarExprVar)Options)CheckerPluginInterfaceClassDefContextFunctionContextMethodContextPluginReportConfigContextSemanticAnalyzerPluginInterface)dataclasses)set_callable_name)make_wildcard_trigger)AnyTypeCallableTypeInstanceNoneType
Overloadedr
   	TypeOfAnyTypeTypeTypeVarType	UnionTypeget_proper_type)fill_typevars)get_unique_redefinition_name)__version__)is_valid_field)
TypeVarDef)r<   pydantic-mypyzpydantic-mypy-metadatazpydantic.main.BaseModelz"pydantic.env_settings.BaseSettingszpydantic.fields.Fieldzpydantic.dataclasses.dataclassversionreturn.c                 C   s$   t dd | ddd dD S )Nc                 s   s    | ]}t |V  qd S N)int).0part rK   8/usr/local/lib/python3.10/dist-packages/pydantic/mypy.py	<genexpr>T   s    z%parse_mypy_version.<locals>.<genexpr>+   r   .)tuplesplitrE   rK   rK   rL   parse_mypy_versionS   s   $rT   )r   i  builtins__builtins__zTypingType[Plugin]c                 C   s   t S )z
    `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).
    )PydanticPluginrS   rK   rK   rL   plugin[   s   rX   c                       s   e Zd Zdeddf fddZdeddfdd	Zdedd
fddZdedee	e
gef  fddZdedee	egdf  fddZdedeeef fddZdeddfddZdeddfddZ  ZS )rW   optionsrF   Nc                    s&   t || _| j | _t | d S rG   )PydanticPluginConfigplugin_configto_data_plugin_datasuper__init__)selfrY   	__class__rK   rL   r_   f   s   
zPydanticPlugin.__init__fullnamez+Optional[Callable[[ClassDefContext], None]]c                 C   s:   |  |}|rt|jtrtdd |jjD r| jS d S )Nc                 s       | ]	}t |tkV  qd S rG   )get_fullnameBASEMODEL_FULLNAMErI   baserK   rK   rL   rM   o       z5PydanticPlugin.get_base_class_hook.<locals>.<genexpr>)lookup_fully_qualified
isinstancenoder'   anymro$_pydantic_model_class_maker_callbackr`   rc   symrK   rK   rL   get_base_class_hookk   s
   
z"PydanticPlugin.get_base_class_hookz+Optional[Callable[[FunctionContext], Type]]c                 C   s"   |  |}|r|jtkr| jS d S rG   )rj   rc   FIELD_FULLNAME_pydantic_field_callbackrp   rK   rK   rL   get_function_hooks   s   
z PydanticPlugin.get_function_hookc                 C   s   | drtS d S )Nz	.from_orm)endswithfrom_orm_callbackr`   rc   rK   rK   rL   get_method_hooky   s   
zPydanticPlugin.get_method_hookc                 C   s   |t krtjS d S rG   )DATACLASS_FULLNAMEr2   dataclass_class_maker_callbackrx   rK   rK   rL   get_class_decorator_hook~   s   z'PydanticPlugin.get_class_decorator_hookctxc                 C      | j S )zjReturn all plugin config data.

        Used by mypy to determine if cache needs to be discarded.
        )r]   )r`   r}   rK   rK   rL   report_config_data   s   z!PydanticPlugin.report_config_datac                 C   s   t || j}|  d S rG   )PydanticModelTransformerr[   	transform)r`   r}   transformerrK   rK   rL   ro      s   z3PydanticPlugin._pydantic_model_class_maker_callbackr
   c           	         s  |j  |jd dksJ d|jd dksJ d|jd }|jd }|r0|r0t|j|j  S |rF|jd d }|d }t|tsD|S  S |r|jd d }t|t	rdt
dkr^|jd }n| d }t|tr|j}t|dd	}|rtd
d |D rt fdd|D |_|S  S )ax  
        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()rO   default_factoryz9"default_factory" is no longer second argument in Field())r   i  argsNc                 s       | ]}t |tV  qd S rG   )rk   r<   )rI   argrK   rK   rL   rM          z:PydanticPlugin._pydantic_field_callback.<locals>.<genexpr>c                 3   s    | ]} V  qd S rG   rK   )rI   _default_any_typerK   rL   rM      s    )default_return_typecallee_arg_namesr   +error_default_and_default_factory_specifiedapicontext	arg_typesrk   r   r9   MYPY_VERSION_TUPLEitemsr6   ret_typegetattrallrQ   )	r`   r}   default_argsdefault_factory_argsdefault_typedefault_argdefault_factory_typer   r   rK   r   rL   rt      s8   	




z'PydanticPlugin._pydantic_field_callback)__name__
__module____qualname__r*   r_   strrr   ru   r   r   r.   r
   ry   r,   r|   r0   r   r   r   ro   r-   rt   __classcell__rK   rK   ra   rL   rW   e   s      rW   c                   @   sZ   e Zd ZU dZeed< eed< eed< eed< deddfd	d
Zdee	e
f fddZdS )rZ   )init_forbid_extra
init_typedwarn_required_dynamic_aliaseswarn_untyped_fieldsr   r   r   r   rY   rF   Nc                 C   s   |j d u rd S t|j }|d ur:|di di }| jD ]}||d}t|ts1td| t| || qd S t }|	|j  | jD ]}|j
t|dd}t| || qFd S )NtoolrD   Fz/Configuration value must be a boolean for key: )fallback)config_file
parse_tomlget	__slots__rk   bool
ValueErrorsetattrr   read
getbooleanCONFIGFILE_KEY)r`   rY   toml_configconfigkeysettingr[   rK   rK   rL   r_      s"   




zPydanticPluginConfig.__init__c                    s    fdd j D S )Nc                    s   i | ]}|t  |qS rK   )r   )rI   r   r`   rK   rL   
<dictcomp>       z0PydanticPluginConfig.to_data.<locals>.<dictcomp>)r   r   rK   r   rL   r\         zPydanticPluginConfig.to_data)r   r   r   r   r   __annotations__r*   r_   r   r   r   r\   rK   rK   rK   rL   rZ      s   
 rZ   r}   c                 C   s   t | jtrt | jjtr| jj}n"t | jtr| j}nd| j d| jjj d}t|| j| j	 | j
S |jjt}|du rB| j
S |di d}|durZtt|j| j| j	 | j
S )z3
    Raise an error if orm_mode is not enabled
    z
ctx.type: z
 (of type )Nr   orm_modeT)rk   typer6   r   r7   rb   r   error_unexpected_behaviorr   r   r   metadatar   METADATA_KEYerror_from_ormget_name)r}   
model_typedetailpydantic_metadatar   rK   rK   rL   rw      s   
rw   c                   @   sn  e Zd ZU h dZee ed< dededdfddZ	d2d	d
Z
d2ddZd3ddZddded fddZded dddeddfddZded ddfddZded deddfddZdeded fdd Zed!ed"ed#edefd$d%Zed"edeee ef fd&d'Zded d(ed)ed*edee f
d+d,Zded dddefd-d.Zeded d/edefd0d1ZdS )4r   >   extrafrozenr   allow_mutationalias_generatorallow_population_by_field_nametracked_config_fieldsr}   r[   rF   Nc                 C   s   || _ || _d S rG   )_ctxr[   )r`   r}   r[   rK   rK   rL   r_     s   
z!PydanticModelTransformer.__init__c                 C   s   | j }| j jj}|   |  }| |}|D ]}||j jdu r*|jj	s*|j
  qtdd |jdd D }| ||| | | | j||jdu pQ|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 allow_mutation = False or frozen = True
        * stores the fields, config, and if the class is settings in the mypy metadata for access by subclasses
        Nc                 s   rd   rG   )re   BASESETTINGS_FULLNAMErg   rK   rK   rL   rM     ri   z5PydanticModelTransformer.transform.<locals>.<genexpr>FT)r   c                 S   s   i | ]}|j | qS rK   )name	serializerI   fieldrK   rK   rL   r     r   z6PydanticModelTransformer.transform.<locals>.<dictcomp>)fieldsr   )r   clsinfoadjust_validator_signaturescollect_configcollect_fieldsr   r   r   final_iterationdeferrm   rn   add_initializeradd_construct_method
set_frozenr   r   set_values_dictr   r   )r`   r}   r   r   r   r   is_settingsrK   rK   rL   r     s"   




z"PydanticModelTransformer.transformc                 C   sb   | j jjj D ]&\}}t|jtr.|jjd }t|t	r.t|j
tr.|j
jdkr.d|jj_qdS )a[  When we decorate a function `f` with `pydantic.validator(...), 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()` call as a classmethod.
        r   z#pydantic.class_validators.validatorTN)r   r   r   namesr   rk   rl   r   original_decoratorsr   calleer   rc   funcis_class)r`   r   rq   	first_decrK   rK   rL   r   #  s   


z4PydanticModelTransformer.adjust_validator_signaturesModelConfigDatac           	      C   s   | j }|j}t }|jjD ]2}t|tsq|jdkr?|jjD ]}t|ts&q|	| 
| q|jr?|js?| jjr?t|j| q|jjdd D ]&}t|jvrPqH|jtt| |jt d  D ]
\}}||| qcqH|S )zz
        Collects the values of the config attributes that are used by the plugin, accounting for parent classes.
        ConfigrO   Nr   )r   r   r   defsbodyrk   r   r   r   updateget_config_updatehas_alias_generatorr   r[   r   error_required_dynamic_aliasesr   r   rn   r   r   add_plugin_dependencyr4   re   r   
setdefault)	r`   r}   r   r   stmtsubstmtr   r   valuerK   rK   rL   r   5  s6   



z'PydanticModelTransformer.collect_configmodel_configPydanticModelFieldc                    s  | j }| j j}g }t }|jjD ]x}t|tsq|jd }t|tr't	|j
s(q|js5| jjr5t|j| |jj|j
}|du rBq|j}	t|	trKqt|	tsQq|	jrUq| |||}
| |\}}|rr|jsr| jjrrt|j| |t|j
|
|||j|jd | |j
 q|! }|jj"dd D ]O}t#|j$vrqg }|j%t&t'| |j$t# d ( D ]-\ } |vrt)||}|   || q fdd|D \}|*| || q|| }q|S )zR
        Collects the fields for the model, accounting for parent classes
        r   Nr   is_requiredaliashas_dynamic_aliaslinecolumnrO   r   c                 3   s    | ]
}|j  kr|V  qd S rG   r   )rI   ar   rK   rL   rM     s    z:PydanticModelTransformer.collect_fields.<locals>.<genexpr>)+r   r   setr   r   rk   r   lvaluesr   rB   r   
new_syntaxr[   r   error_untyped_fieldsr   r   r   r   rl   r!   r)   is_classvarget_is_requiredget_alias_infor   r   r   appendr   r   r   addcopyrn   r   r   r   r4   re   r   deserializeremove)r`   r   r}   r   r   known_fieldsr   lhsrq   rl   r   r   r   
all_fieldsr   superclass_fieldsdatar   rK   r   rL   r   T  st   








z'PydanticModelTransformer.collect_fieldsr   r   r   c           
      C   s   | j }| jj}|jdu}|pt|jo|j }| j||||d}| ||s7td}	|	t
|	ttjdt d|jjjvrHt|d|t  dS dS )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.
        Ttypedforce_all_optional	use_aliaskwargsNr_   )r   r[   r   r   r   r   get_field_argumentsshould_init_forbid_extrar)   r  r   r5   r:   explicitr   r   r   r   
add_methodr8   )
r`   r   r   r   r}   r  r  r  init_argumentsvarrK   rK   rL   r     s   
z(PydanticModelTransformer.add_initializerc              	   C   s   | j }|jt d|jt dg}t|t g}ttd||dt}| j	|dddd}|g| }|jt d}d	}|j
jd
 | }	t||	dg |}
t||	g |}tt||j
jj|< t|
trh|
}nt|
}t|d||||
dd dS )z
        Adds a fully typed `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_setNTFr  z.object_PydanticBaseModelrP   r   	construct)return_type	self_typetvar_defis_classmethod)r   r   
named_typeBUILTINS_NAMEr=   r8   r   r)   r   r  r   rc   rC   r(   r%   r   r   r   rk   r<   r  )r`   r   r}   set_stroptional_set_strfields_set_argumentconstruct_argumentsobj_typeself_tvar_nametvar_fullnametvdself_tvar_exprr  rK   rK   rL   r     s0   $


z-PydanticModelTransformer.add_construct_methodr   c                 C   s   | j jj}|D ]=}|j|j}|dur"|j}t|tsJ ||_	q|j
|dd}||_||_	t|d t| |_tt||jt|< qdS )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.
        NF)r  rP   )r   r   r   r   r   r   rl   rk   r)   is_propertyto_varre   r   	_fullnamer%   r   )r`   r   r   r   r   sym_noder  rK   rK   rL   r     s   
z#PydanticModelTransformer.set_frozenr   c                 C   s   |j d }t|tr|j| jv sdS |jdkrAt|jtr$|jjdk}nt|jtr1|jjdk}nt	|j| j
j| dS t|dS |jdkr[d}t|jtrV|jjdkrVd	}t|d
S t|jtru|jjdv rutdi |j|jjdkiS t	|j| j
j| dS )z
        Determines the config update due to a single statement in the Config class definition.

        Warns if a tracked config attribute is set to a value the plugin doesn't know how to interpret (e.g., an int)
        r   Nr   forbid)forbid_extrar   Tzbuiltins.NoneF)r   )builtins.Truezbuiltins.Falser0  rK   )r   rk   r   r   r   rvaluer#   r   r   error_invalid_config_valuer   r   r   rc   )r`   r   r	  r/  r   rK   rK   rL   r     s(   




z*PydanticModelTransformer.get_config_updater   r   r	  c                 C   s   |j }t|tr$t| j|j j}t|tr"tdd |j	D r"dS dS t|t
rYt|jtrY|jjtkrYt|j|jD ]\}}|du sH|dkrO|jtu   S |dkrV dS q<dS t|tS )zg
        Returns a boolean indicating whether the field defined in `stmt` is a required field.
        c                 s   r   rG   )rk   r8   )rI   itemrK   rK   rL   rM     r   z;PydanticModelTransformer.get_is_required.<locals>.<genexpr>FTNr   r   )r1  rk   r&   r>   r   r   r   r=   rm   r   r   r   r"   rc   rs   zipr   	arg_namesrb   r   )r   r   r	  expr
value_typer   r   rK   rK   rL   r    s   
"
z(PydanticModelTransformer.get_is_requiredc                 C   s   | 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+q"|j
| }t|tr<|jdf  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)r1  rk   r&   r   r   r"   rc   rs   	enumerater5  r   r#   r   )r   r6  iarg_namer   rK   rK   rL   r  .  s$   




z'PydanticModelTransformer.get_alias_infor  r  r  c                    s&   | j jj fdd|D }|S )z
        Helper function used during the construction of the `__init__` and `construct` method signatures.

        Returns a list of mypy Argument instances for use in the generated signatures.
        c                    s(   g | ]}r	|j s|j d qS ))r  force_optionalr  )r   to_argumentr   r  r   r  r  rK   rL   
<listcomp>T  s    z@PydanticModelTransformer.get_field_arguments.<locals>.<listcomp>)r   r   r   )r`   r   r  r  r  	argumentsrK   r=  rL   r  K  s
   
z,PydanticModelTransformer.get_field_argumentsc                 C   s.   |j s| |t|jrdS |jrdS | jjS )aH  
        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   r   r/  r[   r   )r`   r   r   rK   rK   rL   r  [  s   z1PydanticModelTransformer.should_init_forbid_extrar   c                 C   s8   | D ]}|j r
 dS q|r| D ]
}|jdu r dS qdS )z
        Returns 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   r   r   rK   rK   rL   r@  i  s   
z1PydanticModelTransformer.is_dynamic_alias_present)rF   N)rF   r   ) r   r   r   r   r   r   r   r,   rZ   r_   r   r   r   r   r   r   r   r   r   r   r   r   staticmethodr   r   r  r	   r  r   r  r  r@  rK   rK   rK   rL   r      s:   
 	


T% 
 r   c                   @   s   e Zd Zdededee dededefddZd	ed
ede	fddZ
d	ededed
edef
ddZdefddZed	ededd fddZdS )r   r   r   r   r   r   r   c                 C   (   || _ || _|| _|| _|| _|| _d S rG   r   )r`   r   r   r   r   r   r   rK   rK   rL   r_   z  s   
zPydanticModelField.__init__r   r  rF   c                 C   s,   | j }|r| jd ur| j}t||| j  jS rG   )r   r   r)   r   )r`   r   r  r   rK   rK   rL   r+    s   zPydanticModelField.to_varr  r;  c                 C   sV   |r|| j  jd ur|| j  j}nttj}t| |||d |s#| js'tdS t	dS )N)variabletype_annotationinitializerkind)
r   r   r5   r:   r  r   r+  r   r   r   )r`   r   r  r;  r  rD  rK   rK   rL   r<    s   

zPydanticModelField.to_argumentc                 C   r~   rG   )__dict__r   rK   rK   rL   r     s   zPydanticModelField.serializer  c                 C   s   | di |S )NrK   rK   )r   r   r  rK   rK   rL   r    s   zPydanticModelField.deserializeN)r   r   r   r   r   r   rH   r_   r'   r)   r+  r   r<  r   r   classmethodr  rK   rK   rK   rL   r   y  s&    

r   c                   @   s   e Zd Z						ddee dee dee dee dee dee fdd	Zd
eeef fddZ	ded  d
dfddZ
deded
dfddZdS )r   Nr/  r   r   r   r   r   c                 C   rB  rG   )r/  r   r   r   r   r   )r`   r/  r   r   r   r   r   rK   rK   rL   r_     s   	
zModelConfigData.__init__rF   c                 C   s   dd | j  D S )Nc                 S   s   i | ]\}}|d ur||qS rG   rK   )rI   kvrK   rK   rL   r     s    z3ModelConfigData.set_values_dict.<locals>.<dictcomp>)rG  r   r   rK   rK   rL   r     r   zModelConfigData.set_values_dictr   c                 C   s2   |d u rd S |   D ]
\}}t| || qd S rG   )r   r   r   )r`   r   rI  rJ  rK   rK   rL   r     s
   zModelConfigData.updater   r   c                 C   s"   t | |d u rt| || d S d S rG   )r   r   )r`   r   r   rK   rK   rL   r     s   zModelConfigData.setdefault)NNNNNN)r   r   r   r   r   r_   r   r   r   r   r   r   rK   rK   rK   rL   r     s.    
r   zpydantic-ormzInvalid from_orm callPydanticzpydantic-configzInvalid config valuezpydantic-aliaszDynamic alias disallowedzpydantic-unexpectedzUnexpected behaviorzpydantic-fieldzUntyped field disallowedzInvalid Field defaults
model_namer   r   c                 C      |j d|  d|td d S )N"z" does not have orm_mode=Truecode)fail	ERROR_ORM)rL  r   r   rK   rK   rL   r        r   r   c                 C   rM  )NzInvalid value for "Config.rN  rO  )rQ  ERROR_CONFIG)r   r   r   rK   rK   rL   r2    rS  r2  c                 C      | j d|td d S )Nz#Required dynamic aliases disallowedrO  )rQ  ERROR_ALIASr   r   rK   rK   rL   r     r   r   r   c                 C   s4   d}d|  d}|d| d7 }|j ||td d S )Nz6https://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!rO  )rQ  ERROR_UNEXPECTED)r   r   r   linkfull_messagerK   rK   rL   r     s   r   c                 C   rU  )NzUntyped fields disallowedrO  )rQ  ERROR_UNTYPEDrW  rK   rK   rL   r     r   r   c                 C   rU  )Nz>Field default and default_factory cannot be specified togetherrO  )rQ  ERROR_FIELD_DEFAULTSrW  rK   rK   rL   r     r   r   Fr   r  r  r  r  is_newc                 C   s   | j j}||jv r |j| }	|	jr t|	jtr | j jj	|	j |p%t
|}|s*|r8ttdt|dtg}
n|p=t
|}ttd|dtg}
|
| }g g g }}}|D ]}|js_J d||j |t|j ||j qV| jt d}t|||||}|r|g|_t||tt g}||_t|||_||_t|d | |_ |j!|_!||jv rt"||j}|j| |j|< |rd|_#t||j}||_|j |_ d|_$t%|t&dg|}|j!|_!t't(|}	nt't(|}	d|	_|	|j|< |j)jj| dS )	z}
    Adds a new method to a class.

    This can be dropped if/when https://github.com/python/mypy/issues/7301 is merged
    _clsN__pydantic_self__z"All arguments must be fully typed.z	.functionrP   TrH  )*r   r   r   plugin_generatedrk   rl   r   r   r   r  r?   r   r)   r;   make_normalizedr   rD  r  r   rC  rF  r   r  r   r6   	variablesr   r    r3   r   r   re   r,  r   r@   is_decoratedr  r   r   r%   r   defn)r}   r   r   r  r  r  r  r^  r   rq   firstr   r5  	arg_kindsr   function_type	signaturer   r_namerJ  decrK   rK   rL   r    sV   




r  xc                 C      | j }t|r
| S |S zc
    Used for compatibility with mypy 0.740; can be dropped once support for 0.740 is dropped.
    )rc   callablerl  fnrK   rK   rL   re   4     re   c                 C   rm  rn  )r   ro  rp  rK   rK   rL   r   >  rr  r   r   c                 C   s   |  dsd S d}tjdkrdd l}n-zdd l}W n& ty?   d}zdd l}W n ty<   dd l}|d Y Y d S w Y nw t	| |}|
|W  d    S 1 sUw   Y  d S )Nz.tomlrb)      r   rzJNo TOML parser installed, cannot read configuration from `pyproject.toml`.)rv   sysversion_infotomllibtomliImportErrortomlwarningswarnopenload)r   	read_modetoml_r}  rfrK   rK   rL   r   H  s*   



$r   )NNFF)wrw  configparserr   typingr   r   r   r   r   r   r	   r
   
TypingTyper   mypy.errorcodesr   
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)   mypy.optionsr*   mypy.pluginr+   r,   r-   r.   r/   r0   r1   mypy.pluginsr2   mypy.semanalr3   mypy.server.triggerr4   
mypy.typesr5   r6   r7   r8   r9   r:   r;   r<   r=   r>   mypy.typevarsr?   	mypy.utilr@   mypy.versionrA   mypy_versionpydantic.utilsrB   rC   r{  r   r   rf   r   rs   rz   r   rH   rT   r   r   rX   rW   rZ   rw   r   r   r   rR  rT  rV  rY  r\  r]  r   r2  r   r   r   r   r   r  re   r   r   rK   rK   rK   rL   <module>   s    ,|$	4
_   %	

S
"
