o
    Ú­j+î  ã                   @  sF  d Z ddlmZ ddlZddlmZ ddlmZ ddl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/m0Z0 dd
l1m2Z2 ddl3m4Z4m5Z5m6Z6m7Z7m8Z8m9Z9m:Z: ddl;m<Z< ddl=m>Z> ddl?m@Z@ ddlAmBZB ddlCmDZD ddlEmFZF ddlGmHZHmIZImJZJmKZKmLZLmMZMmNZNmOZOmPZPmQZQ ddlRmSZS ddlTmUZU ddlVmWZX ddlYmZZZ ddl[m\Z\ dZ]dZ^dZ_dZ`dZadZbdZcdZdd Zed!Zfh d"£Zgegd#h Zhe\eXƒZid$Zjd%ZWdyd*d+„ZkG d,d-„ d-e8ƒZlG d.d/„ d/ƒZmdzd3d4„ZnG d5d6„ d6ƒZoG d7d8„ d8ƒZpG d9d:„ d:ƒZqG d;d<„ d<eDƒZrG d=d>„ d>ƒZsd{dBdC„ZtedDdEdFƒZuedGdHdFƒZvedIdJdFƒZwedKdLdFƒZxedMdNdFƒZyedMdOdFƒZzedMdPdFƒZ{d|dWdX„Z|d}d[d\„Z}d~d]d^„Z~ddadb„Zd~dcdd„Z€d€dedf„Z�			gd�d‚dsdt„Z‚dƒdwdx„ZƒdS )„z^This module includes classes and functions designed specifically for use with the mypy plugin.é    )ÚannotationsN)ÚIterator)ÚConfigParser)ÚAnyÚCallable)Ú	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ÚDynamicClassDefContextÚMethodContextÚPluginÚReportConfigContextÚSemanticAnalyzerPluginInterface)Údeserialize_and_fixup_type)Úset_callable_name)Úmake_wildcard_trigger)Ústate)ÚTypeTranslator)Úmap_type_from_supertype)
ÚAnyTypeÚCallableTypeÚInstanceÚNoneTypeÚTypeÚ	TypeOfAnyÚTypeTypeÚTypeVarTypeÚ	UnionTypeÚget_proper_type)Úfill_typevars)Úget_unique_redefinition_name)Ú__version__)Ú_fields)Úparse_mypy_versionúpydantic-mypyzpydantic-mypy-metadatazpydantic.main.BaseModelzpydantic.main.create_modelz#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_validatorú3pydantic.deprecated.class_validators.root_validatorrH   ú0pydantic.functional_serializers.model_serializerrM   Úbuiltinsé   ÚversionÚstrÚreturnútype[Plugin]c                 C  s   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)rP   © rU   úJ/var/www/html/CropPilot/venv/lib/python3.10/site-packages/pydantic/mypy.pyÚplugino   s   rW   c                      sr   e Zd ZdZd"‡ fdd„Zd#dd„Zd#dd„Zd$dd„Zd%dd„Zd&dd„Z	d'dd„Z
d'dd„Zd(d d!„Z‡  ZS ))rT   zThe Pydantic mypy plugin.Úoptionsr*   rR   ÚNonec                   s&   t |ƒ| _| j ¡ | _tƒ  |¡ d S ©N)ÚPydanticPluginConfigÚplugin_configÚto_dataÚ_plugin_dataÚsuperÚ__init__)ÚselfrX   ©Ú	__class__rU   rV   r`   �   s   
zPydanticPlugin.__init__ÚfullnamerQ   ú(Callable[[ClassDefContext], None] | Nonec                 C  s0   |   |¡}|rt|jtƒr|j t¡r| jS dS )zUpdate Pydantic model class.N)Úlookup_fully_qualifiedÚ
isinstanceÚnoder(   Úhas_baseÚBASEMODEL_FULLNAMEÚ$_pydantic_model_class_maker_callback)ra   rd   ÚsymrU   rU   rV   Úget_base_class_hook†   s
   
z"PydanticPlugin.get_base_class_hookc                 C  ó   |t kr| jS dS )z,Update Pydantic `ModelMetaclass` definition.N)ÚMODEL_METACLASS_FULLNAMEÚ)_pydantic_model_metaclass_marker_callback©ra   rd   rU   rU   rV   Úget_metaclass_hook�   ó   z!PydanticPlugin.get_metaclass_hookú&Callable[[MethodContext], Type] | Nonec                 C  s   |  d¡rtS dS )z-Adjust return type of `from_orm` method call.z	.from_ormN)ÚendswithÚfrom_attributes_callbackrq   rU   rU   rV   Úget_method_hook•   s   
zPydanticPlugin.get_method_hookú/Callable[[DynamicClassDefContext], None] | Nonec                 C  rn   )zARecognize `create_model()` calls as dynamic BaseModel subclasses.N)ÚCREATE_MODEL_FULLNAMEÚ_pydantic_create_model_callbackrq   rU   rU   rV   Úget_dynamic_class_hook›   rs   z%PydanticPlugin.get_dynamic_class_hookÚctxr0   údict[str, Any]c                 C  s   | j S )zjReturn all plugin config data.

        Used by mypy to determine if cache needs to be discarded.
        )r^   )ra   r|   rU   rU   rV   Úreport_config_data¡   s   z!PydanticPlugin.report_config_datar,   c                 C  s"   t |j|j|j| jƒ}| ¡  d S rZ   )ÚPydanticModelTransformerÚclsÚreasonÚapir\   Ú	transform)ra   r|   ÚtransformerrU   rU   rV   rk   ¨   s   z3PydanticPlugin._pydantic_model_class_maker_callbackc                 C  s@   | j jrdS |jjj}|sJ dƒ‚t|jddƒrd|j_dS dS )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…   )ra   r|   Úinfo_metaclassrU   rU   rV   rp   ¬   s   
ÿz8PydanticPlugin._pydantic_model_metaclass_marker_callbackr-   c           	      C  s  t }t|jj|jjƒD ]0\}}|dkr;t|tƒr;|jdur;t|jtƒr(|jj	}qt|jt
ƒr;t|jjtƒr;|jjjj	}q|j |¡}|du sLt|jtƒs^|j t ¡}|du s\t|jtƒs^dS |j}t|ƒ}t|tƒslJ ‚|j |j||jj¡}|j|_|j |jtt|ƒ¡ dS )zFMake variables assigned from `create_model()` usable as types by mypy.Ú__base__N)rj   ÚzipÚcallÚ	arg_namesÚargsrg   r"   rh   r(   rd   r)   rŠ   r:   r‚   Úlookup_fully_qualified_or_nonerB   Úbasic_new_typeinfoÚnameÚlineÚmetaclass_typeÚadd_symbol_table_noder%   r   )	ra   r|   Úbase_fullnameÚarg_nameÚarg_exprÚbase_symÚ	base_infoÚbase_instancer‡   rU   rU   rV   rz   ¹   s&   
€z.PydanticPlugin._pydantic_create_model_callback©rX   r*   rR   rY   )rd   rQ   rR   re   )rd   rQ   rR   rt   )rd   rQ   rR   rx   )r|   r0   rR   r}   )r|   r,   rR   rY   )r|   r-   rR   rY   )Ú__name__Ú
__module__Ú__qualname__Ú__doc__r`   rm   rr   rw   r{   r~   rk   rp   rz   Ú__classcell__rU   rU   rb   rV   rT   ~   s    

	




rT   c                   @  sJ   e Zd ZU dZdZded< ded< ded< ded< ddd„Zddd„ZdS )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†   Úboolr£   r¤   r¥   r†   rX   r*   rR   rY   c                 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ÚtoolrG   Fz/Configuration value must be a boolean for key: )Úfallback)Úconfig_fileÚ
parse_tomlÚgetÚ	__slots__rg   r¦   Ú
ValueErrorÚsetattrr   ÚreadÚ
getbooleanÚCONFIGFILE_KEY)ra   rX   Útoml_configÚconfigÚkeyÚsettingr\   rU   rU   rV   r`   ë   s"   



ü
þzPydanticPluginConfig.__init__r}   c                   s   ‡ fdd„ˆ j D ƒS )z/Returns a dict of config names to their values.c                   s   i | ]}|t ˆ |ƒ“qS rU   )r‰   )Ú.0r´   ©ra   rU   rV   Ú
<dictcomp>   ó    z0PydanticPluginConfig.to_data.<locals>.<dictcomp>)r¬   r·   rU   r·   rV   r]   þ   ó   zPydanticPluginConfig.to_dataNr�   ©rR   r}   )rž   rŸ   r    r¡   r¬   Ú__annotations__r`   r]   rU   rU   rU   rV   r[   Õ   s   
 

r[   r|   r.   r<   c                 C  sÒ   | j }t|tƒr|j}t|tƒrt|jtƒr|j}nt|tƒr"|}nd|› d|jj› d�}t	|| j
| jƒ | jS |j j t¡}|du rF| jS |j  t¡sO| jS | di ¡ d¡}|durft|j j| j
| jƒ | jS )z1Raise an error if from_attributes is not enabled.z
ctx.type: z
 (of type ú)Nr³   Úfrom_attributesT)rŠ   rg   r>   Úitemr9   Úret_typer:   rc   rž   Úerror_unexpected_behaviorr‚   ÚcontextÚdefault_return_typeÚmetadatar«   ÚMETADATA_KEYri   rj   Úerror_from_attributesr“   )r|   Úctx_typeÚ
model_typeÚdetailÚpydantic_metadatar¾   rU   rU   rV   rv     s&   

rv   c                   @  sd   e Zd ZdZd4dd„Zd5d d!„Z	"	"d6d7d$d%„Z	"d8d9d'd(„Zd:d*d+„Ze	d;d-d.„ƒZ
d<d1d2„Zd3S )=ÚPydanticModelFieldz5Based on mypy.plugins.dataclasses.DataclassAttribute.r“   rQ   Úaliasú
str | NoneÚ	is_frozenr¦   Úhas_dynamic_aliasÚhas_defaultÚstrictúbool | Noner”   ÚintÚcolumnrŠ   úType | Noner‡   r(   c                 C  s@   || _ || _|| _|| _|| _|| _|| _|| _|	| _|
| _	d S rZ   )
r“   rÌ   rÎ   rÏ   rÐ   rÑ   r”   rÔ   rŠ   r‡   )ra   r“   rÌ   rÎ   rÏ   rÐ   rÑ   r”   rÔ   rŠ   r‡   rU   rU   rV   r`      s   
zPydanticModelField.__init__Úcurrent_infoÚtypedÚmodel_strictÚforce_optionalÚ	use_aliasr‚   r1   Úforce_typevars_invariantÚis_root_model_rootrR   r   c	                 C  sv   |   ||||¡}	| jdu r|n| j}
|s|
r| j||dd�}nttjƒ}t|	|d|r.td�S |s3| jr7t	d�S t
d�S )zABased on mypy.plugins.dataclasses.DataclassAttribute.to_argument.NT)Úinclude_root_type)ÚvariableÚtype_annotationÚinitializerÚkind)Úto_varrÑ   r   r8   r=   Úexplicitr   r   rÐ   r   r
   )ra   rÖ   r×   rØ   rÙ   rÚ   r‚   rÛ   rÜ   rÞ   rÑ   rß   rU   rU   rV   Úto_argument8  s    
ÿüúúzPydanticModelField.to_argumentFrÝ   c                 C  s  |rt | jtƒr| j ¡ }t|_|| _| jdur‡| jjdur‡t 	|j
j¡�Z t|ƒ}t |tƒs1J ‚|rA|jD ]
}t |tƒr@t|_q6t| j| jjj|iƒ}|rvt |tƒrvt|jƒrv|jd j}	|	du rk|W  d  ƒ S t|	|ƒ}
t||
gƒ}|W  d  ƒ S 1 s‚w   Y  | jS )zABased on mypy.plugins.dataclasses.DataclassAttribute.expand_type.NÚroot)rg   rŠ   r?   Úcopy_modifiedr   Úvariancer‡   Ú	self_typer5   Ústrict_optional_setrX   Ústrict_optionalrB   r:   r�   r   ÚidÚis_root_modelr	   r@   )ra   rÖ   r‚   rÛ   rÝ   Úmodified_typeÚfilled_with_typevarsÚargÚexpanded_typeÚ	root_typeÚexpanded_root_typerU   rU   rV   r   U  s2   


€ð
 ízPydanticModelField.expand_typer)   c                 C  s0   |r| j dur| j }n| j}t||  |||¡ƒS )z<Based on mypy.plugins.dataclasses.DataclassAttribute.to_var.N)rÌ   r“   r)   r   )ra   rÖ   r‚   rÚ   rÛ   r“   rU   rU   rV   râ   ‚  s   zPydanticModelField.to_varr   c              
   C  s8   | j sJ ‚| j| 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Ï   rÐ   rÑ   r”   rÔ   Ú	serializer·   rU   rU   rV   rô   ‘  s   
÷zPydanticModelField.serializeÚdatac                 C  s,   |  ¡ }t| d¡|ƒ}| d||dœ|¤ŽS )úABased on mypy.plugins.dataclasses.DataclassAttribute.deserialize.rŠ   )rŠ   r‡   NrU   )Úcopyr2   Úpop)r€   r‡   rõ   r‚   ÚtyprU   rU   rV   Údeserialize   s   zPydanticModelField.deserializeÚsub_typerY   c                 C  sT   | j dur(t |jj¡� t| j || jƒ| _ W d  ƒ dS 1 s!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Š   r5   ré   rX   rê   r7   r‡   )ra   rû   r‚   rU   rU   rV   Úexpand_typevar_from_subtype§  s
   
"ÿÿz.PydanticModelField.expand_typevar_from_subtypeN)r“   rQ   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‚   r1   rÛ   r¦   rÜ   r¦   rR   r   )FF)
rÖ   r(   r‚   r1   rÛ   r¦   rÝ   r¦   rR   rÕ   ©F)
rÖ   r(   r‚   r1   rÚ   r¦   rÛ   r¦   rR   r)   ©rR   r   )r‡   r(   rõ   r   r‚   r1   rR   rË   )rû   r(   r‚   r1   rR   rY   )rž   rŸ   r    r¡   r`   rä   r   râ   rô   Úclassmethodrú   rü   rU   rU   rU   rV   rË     s    

!û2û
rË   c                   @  s0   e Zd ZdZdd„ Zeddd„ƒZdd	d
„ZdS )ÚPydanticModelClassVarz•Based on mypy.plugins.dataclasses.DataclassAttribute.

    ClassVars are ignored by subclasses.

    Attributes:
        name: the ClassVar name
    c                 C  s
   || _ d S rZ   ©r“   )ra   r“   rU   rU   rV   r`   ¹  s   
zPydanticModelClassVar.__init__rõ   r   rR   c                 C  s   |  ¡ }| di |¤ŽS )rö   NrU   )r÷   )r€   rõ   rU   rU   rV   rú   ¼  s   z!PydanticModelClassVar.deserializec                 C  s
   d| j iS )ró   r“   r  r·   rU   rU   rV   rô   Â  s   ÿzPydanticModelClassVar.serializeN)rõ   r   rR   r   rþ   )rž   rŸ   r    r¡   r`   rÿ   rú   rô   rU   rU   rU   rV   r   °  s    r   c                   @  s  e Zd ZU dZh d£Zded< d`dd„Zdadd„Zdbdd„Zdcdd„Z	dddd„Z
ded!d"„Zdfd%d&„Zdgd+d,„Zdhd4d5„Zdid:d;„Zdid<d=„Zdjd?d@„ZdkdldFdG„ZedmdHdI„ƒZedndKdL„ƒZedodNdO„ƒZedmdPdQ„ƒZ	AdkdpdXdY„ZdqdZd[„Zedrd]d^„ƒZd_S )sr   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ÚfrozenrÑ   Úalias_generatorr¾   Úpopulate_by_nameÚvalidate_by_nameÚvalidate_by_aliaszset[str]Útracked_config_fieldsr€   r   r�   úExpression | Statementr‚   r1   r\   r[   rR   rY   c                 C  s   || _ || _|| _|| _d S rZ   )Ú_clsÚ_reasonÚ_apir\   )ra   r€   r�   r‚   r\   rU   rU   rV   r`   Û  s   
z!PydanticModelTransformer.__init__r¦   c                 C  sÎ   | j j}t|ƒ}|  ¡ }|  ||¡\}}|du s|du rdS |D ]
}|jdu r* dS q | t¡}|  ||||¡ |  	||||¡ | j
|| j|jdu d� |  ¡  dd„ |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
        NFT)r  c                 S  ó   i | ]}|j | ¡ “qS rU   ©r“   rô   ©r¶   ÚfieldrU   rU   rV   r¸     r¹   z6PydanticModelTransformer.transform.<locals>.<dictcomp>c                 S  r  rU   r  )r¶   Ú	class_varrU   rU   rV   r¸     r¹   )ÚfieldsÚ
class_varsr³   )r
  r‡   rì   Úcollect_configÚcollect_fields_and_class_varsrŠ   ri   ÚBASESETTINGS_FULLNAMEÚadd_initializerÚadd_model_construct_methodÚ
set_frozenr  r  Úadjust_decorator_signaturesÚget_values_dictrÄ   rÅ   )ra   r‡   Úis_a_root_modelr³   r  r  r  Úis_settingsrU   rU   rV   rƒ   è  s(   

ÿ
ýz"PydanticModelTransformer.transformc                   s„   | j jj ¡ D ]8}t|jtƒr?|jjd ‰ tˆ tƒr?tˆ j	t
ƒr?ˆ j	jtv r?ˆ j	jtkr:t‡ fdd„tˆ jƒD ƒƒs?d|jj_q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  s6   � | ]\}}ˆ j | d kot|tƒo|jdkV  qdS )ÚmodeÚafterN)r�   rg   r$   Úvalue)r¶   Úirï   ©Ú	first_decrU   rV   Ú	<genexpr>  s
   €  ÿ
ÿzGPydanticModelTransformer.adjust_decorator_signatures.<locals>.<genexpr>TN)r
  r‡   ÚnamesÚvaluesrg   rh   r   Úoriginal_decoratorsr   Úcalleer   rd   Ú(IMPLICIT_CLASSMETHOD_DECORATOR_FULLNAMESÚMODEL_VALIDATOR_FULLNAMEÚanyÚ	enumerater�   ÚfuncÚis_class)ra   rl   rU   r"  rV   r    s    ÿ
þþÿ
€ïz4PydanticModelTransformer.adjust_decorator_signaturesÚModelConfigDatac              	   C  s&  | j }tƒ }d}d}|j ¡ D ]\}}|  ||¡}|r"d}| |¡ qd}|jjD ]Ÿ}t|t	t
fƒs3q)t|t	ƒr�|jd }	t|	tƒrG|	jdkrHq)t|jtƒrmt|jj|jjƒD ]\}
}|
du r`qW| | j|
|dd�¡ qWnNt|jtƒrŒ|jjD ]\}}t|tƒs�qw| |  |j|¡¡ qwn.t|t
ƒr»|jdkr˜q)|jjD ]}t|t	ƒs¤qœ|jd }	t|	tƒs¯qœ| |  |	j|j¡¡ qœ|rÆ| j d|¡  nd}q)|sÍ|râ|râ|jrâ|jsâ|jsâ| jjrât| j|ƒ |jjd	d… D ]&}t |j!vròqê| j "t#|j$ƒ¡ |j!t  d
  ¡ D ]\}}| %||¡ �qqê|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 kwargsé   r³   )&r
  r/  ÚkeywordsÚitemsÚget_config_updateÚupdateÚdefsÚbodyrg   r   r   Úlvaluesr   r“   Úrvaluer   r�   r�   r�   r   r$   r   r  ÚfailÚhas_alias_generatorr  r  r\   r¥   Úerror_required_dynamic_aliasesr‡   ÚmrorÅ   rÄ   Úadd_plugin_dependencyr4   rd   Ú
setdefault)ra   r€   r³   Úhas_config_kwargsÚhas_config_from_namespacer“   ÚexprÚconfig_dataÚstmtÚlhsr˜   rï   Úkey_exprÚ
value_exprÚsubstmtr‡   r   rU   rU   rV   r  '  s†   
€

ý
€




þÿþýýü
ÿz'PydanticModelTransformer.collect_configr0  rì   úJtuple[list[PydanticModelField] | None, list[PydanticModelClassVar] | None]c                 C  s°  | j }i }i }t|jjdd… ƒD ]d}t|jvrq| j t|j	ƒ¡ |jt d  
¡ D ]4\}}t ||| j¡}	|	 |j| j¡ |	||< |jj |¡}
|
r_|
jr_t|
jttfƒs_| j d|
j¡ q+|jt d  
¡ D ]\}}t |¡||< qiqtƒ }tƒ }|  |j¡D ]I}|  |||¡}|du r�q‚|jd }t|tƒsœJ ‚t|tƒr»|r¯|jdkr¯t| j|ƒ q‚| |j¡ |||j< q‚t|tƒrË| |j¡ |||j< q‚t|  ¡ ƒt|  ¡ ƒfS )	zACollects the fields for the model, accounting for parent classes.r3  éÿÿÿÿr  z7BaseModel field may only be overridden by another fieldr  Nr   rå   )!r
  Úreversedr‡   r?  rÅ   rÄ   r  r@  r4   rd   r5  rË   rú   rü   r%  r«   rh   rg   r)   r!   r<  r   ÚsetÚ%_get_assignment_statements_from_blockr8  Ú$collect_field_or_class_var_from_stmtr:  r   r“   Ú error_extra_fields_on_root_modelÚaddÚlistr&  )ra   r0  rì   r€   Úfound_fieldsÚfound_class_varsr‡   r“   rõ   r  Úsym_nodeÚcurrent_field_namesÚcurrent_class_vars_namesrF  Úmaybe_fieldrG  rU   rU   rV   r  s  sN   
þ€ÿ



€z6PydanticModelTransformer.collect_fields_and_class_varsrF  r   úIterator[AssignmentStmt]c                 c  sT   � |j D ]}|js|  |¡E d H  q|jd ur&|jjs(|  |j¡E d H  d S d S d S rZ   )r9  Úis_unreachablerO  Ú	else_body)ra   rF  r9  rU   rU   rV   Ú,_get_assignment_statements_from_if_statement·  s   €
€ÿzEPydanticModelTransformer._get_assignment_statements_from_if_statementÚblockr   c                 c  s>   � |j D ]}t|tƒr|V  qt|tƒr|  |¡E d H  qd S rZ   )r9  rg   r   r   r]  )ra   r^  rF  rU   rU   rV   rO  ¾  s   €


€üz>PydanticModelTransformer._get_assignment_statements_from_blockr   r  ú dict[str, PydanticModelClassVar]ú1PydanticModelField | PydanticModelClassVar | Nonec                 C  sN  | j }|jd }t|tƒrt |j¡r|jdkrdS |jsKt|jt	ƒr<t|jj
t	ƒr<t|jj
j
tƒr<|jj
j
jtv r<dS |j|v rCdS t| j|ƒ dS |jd }t|tƒsWdS t |j¡rb|jdkrddS |jj |j¡}|du rrdS |j}t|tƒr|dS t|tƒrŠ| j d|¡ dS t|tƒs‘dS |jr™t|jƒS t|jƒ}t|tƒr°|jjdkr°| j d|¡ |  |¡}	|  |¡}
|jdu rá|jrá|jrá| jj |jdd�}|rÔ||_n| j d	|¡ t!t"j#ƒ|_|jrë|	rët|jƒS |  $|¡\}}|�r|j%�s|j&�s| j'j(�rt)| j|ƒ |  *|¡}|  +||j|¡}t,|j||	|
|||j-|j.||jd
�
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   r0  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‡   )/r
  r:  rg   r   rE   Úis_valid_field_namer“   Ú
new_syntaxr;  r   r(  rd   ÚDECORATOR_FULLNAMESÚerror_untyped_fieldsr  r‡   r%  r«   rh   r!   r'   r<  r)   Úis_classvarr   rA   rŠ   r:   Úget_has_defaultÚ
get_strictra  Úis_inferredÚanalyze_simple_literal_typer8   r=   Ú
from_errorÚget_alias_infor  r  r\   r¥   r>  Úis_field_frozenÚ_infer_dataclass_attr_init_typerË   r”   rÔ   )ra   rF  r0  r  r€   rG  rl   rh   Ú	node_typerÐ   rÑ   rù   rÌ   rÏ   rÎ   Ú	init_typerU   rU   rV   rP  Å  s¢   
 
ÿþý




þ


þ

þ

ÿþþý
öz=PydanticModelTransformer.collect_field_or_class_var_from_stmtrl   r%   r“   rQ   rÂ   r   rÕ   c           	      C  sä   |j }|jr|S t|j ƒ}t|tƒs|S |j  d¡}|rpt|jtƒrc|j  d¡}|s,J ‚|j r:tt	|j |j |ƒƒ}nt
tjƒS t|tƒrT|jtttgkrTt|jd |ƒS | j d|j j› d�|¡ |S | j d|j j› d�|¡ |S )zvInfer __init__ argument type for an attribute.

        In particular, possibly use the signature of __set__.
        Ú__set__rO   z(Unsupported signature for "__set__" in "ú"zUnsupported "__set__" in ")rŠ   ÚimplicitrA   rg   r:   r«   rh   r   Úget_containing_type_infor7   r8   r=   Úunannotatedr9   Ú	arg_kindsr   r	   Ú	arg_typesr  r<  r“   )	ra   rl   r“   rÂ   ÚdefaultÚtÚsetterÚ
super_infoÚsetter_typerU   rU   rV   rn  N  s0   


ýþz8PydanticModelTransformer._infer_dataclass_attr_init_typer  úlist[PydanticModelField]r³   r  c              
   C  s®  d| j jjv r| j jjd jsdS | jj}t|jƒ}|jp|j	 o%|j
du}t|jo-|j ƒ}| j|||||||dd�}	|r²| j t¡j}
t|
tƒsLJ ‚d|
jv r²|
jd j}t|tƒs^J ‚|dur²|jdur²|j}t|tƒsqJ ‚t|jƒD ];\}}|du sˆ| d¡sˆ| d¡s‰qv| j |j| ¡}|dur¢|dv r¢| ttjƒ¡}t||ƒ}|	  t!||dt"ƒ¡ qv|  #||¡sÉtd	ƒ}|	  t!|t$tj%ƒdt&ƒ¡ t'| j| j d|	t(ƒ d
� 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.
        r`   NFT)r×   rØ   Úrequires_dynamic_aliasesrÚ   r  rì   rÛ   Ú__Ú_)Ú_cli_settings_sourceÚ_build_sourcesÚkwargs)r�   Úreturn_type))r
  r‡   r%  Úplugin_generatedr\   r¤   r¦   rÑ   r  r  r  r=  Úget_field_argumentsr  rf   r  rh   rg   r(   r   rŠ   r9   r,  r�   Ú
startswithÚ	anal_typerw  ÚacceptÚChangeExplicitTypeOfAnyr=   Úfrom_omitted_genericsr)   Úappendr   r   Úshould_init_forbid_extrar8   rã   r   Ú
add_methodr;   )ra   r  r³   r  rì   r×   rØ   rÚ   r~  r�   Úbase_settings_nodeÚbase_settings_init_nodeÚ	func_typeÚarg_idxr˜   Úanalyzed_variable_typerÞ   ÚvarrU   rU   rV   r  t  sN   
ø
ÿ
z(PydanticModelTransformer.add_initializerc           
   
   C  sþ   | j  t› d�| j  t› d�¡g¡}t|tƒ gƒ}ttd|ƒ|dtƒ}t 	| j j
j¡� | j|dt|jƒdd||d�}W d  ƒ n1 sEw   Y  |  ||¡satdƒ}	| t|	ttjƒdtƒ¡ |rh||g n|g| }t| j | jd	|t| jjƒdd
� dS )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~  rÚ   r  rì   rƒ  Úmodel_construct)r�   r„  Úis_classmethod)r  Ú
named_typeÚBUILTINS_NAMEr@   r;   r   r)   r   r5   ré   rX   rê   r†  r¦   rÑ   r�  rŒ  r8   r=   rã   r   rŽ  r
  rB   r‡   )
ra   r  r³   r  rì   Úset_strÚoptional_set_strÚfields_set_argumentr�   r”  rU   rU   rV   r  ­  s4   $ùÿ


úz3PydanticModelTransformer.add_model_construct_methodr  c                 C  s¨   | j j}|D ]K}|j |j¡}|dur1|j}t|tƒr"|p|j|_	qt|t
ƒr0| jjs0| j ¡  q|j||dd�}||_||_	|jd |j |_tt|ƒ|j|j< 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Ú   Ú.)r
  r‡   r%  r«   r“   rh   rg   r)   rÎ   Úis_propertyr!   r  Úfinal_iterationÚdeferrâ   rd   Ú	_fullnamer%   r   )ra   r  r‚   r  r‡   r  rV  r”  rU   rU   rV   r  Õ  s    

€ïz#PydanticModelTransformer.set_frozenFrï   r   r1  úModelConfigData | Nonec                 C  sÎ   || j vrdS |dkr1t|tƒr|jdk}nt|tƒr!|jdk}n|s*t|| j|ƒ dS t|d�S |dkrHd}t|t	ƒrC|j
dkrCd}t|d	�S t|t	ƒr^|j
d
v r^tdi ||j
dki¤ŽS t|| j|ƒ dS )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)r=  )úbuiltins.Trueúbuiltins.Falser¦  rU   )r  rg   r$   r   r   r“   Úerror_invalid_config_valuer  r/  r   rd   )ra   r“   rï   r1  r¤  r=  rU   rU   rV   r6  î  s(   


	

z*PydanticModelTransformer.get_config_updatec                 C  sž   | j }t|tƒr
dS t|tƒrIt|jtƒrI|jjtkrIt|j	|j
ƒD ]$\}}|du s.|dkr5|jtu  S |dkrFt|tƒoB|jdk   S q"dS t|tƒ S )zUReturns a boolean indicating whether the field defined in `stmt` is a required field.FNrx  Údefault_factoryr¥  )r;  rg   r&   r   r(  r"   rd   ÚFIELD_FULLNAMEr�   r�   r�   rc   r   r   ©rF  rD  rï   r“   rU   rU   rV   rg    s   
"ÿz(PydanticModelTransformer.get_has_defaultrÒ   c                 C  s|   | j }t|tƒr<t|jtƒr<|jjtkr<t|j|j	ƒD ] \}}|dkr$qt|t
ƒr9|jdkr1 dS |jdkr9 dS  dS dS )zEReturns a the `strict` value of a field if defined, otherwise `None`.rÑ   r¦  Tr§  FN)r;  rg   r   r(  r"   rd   rª  r�   r�   r�   r   r«  rU   rU   rV   rh  '  s   "


z#PydanticModelTransformer.get_strictútuple[str | None, bool]c                 C  s’   | j }t|tƒr
dS t|tƒrt|jtƒr|jjtksdS d|jv r,|j	|j 
d¡ }nd|jv r;|j	|j 
d¡ }ndS t|tƒrG|jdf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.
        )NFÚvalidation_aliasrÌ   F)NT)r;  rg   r&   r   r(  r"   rd   rª  r�   r�   Úindexr$   r   )rF  rD  rï   rU   rU   rV   rl  7  s"   
ÿ
ÿ



z'PydanticModelTransformer.get_alias_infoc                 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;|j
| }t|tƒo8|jdk  S q"dS )al  Returns whether the field is frozen, extracted from the declaration of the field defined in `stmt`.

        Note that this is only whether the field was declared to be frozen in a `<field_name> = Field(frozen=True)`
        sense; this does not determine whether the field is frozen because the entire model is frozen; that is
        handled separately.
        Fr  r¦  )r;  rg   r&   r   r(  r"   rd   rª  r,  r�   r�   r   )rF  rD  r!  r˜   rï   rU   rU   rV   rm  U  s   
ÿ
ÿ
þz(PydanticModelTransformer.is_field_frozenr×   rØ   rÚ   r~  rÛ   úlist[Argument]c	           
   	     s.   ˆj j‰‡ ‡‡‡‡‡‡‡‡f	dd„|D ƒ}	|	S )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.
        c                   s@   g | ]}ˆr	|j s|jˆˆˆˆpˆˆˆjˆ ˆo|jd kd�‘qS )rå   )r×   rØ   rÙ   rÚ   r‚   rÛ   rÜ   )rÏ   rä   r  r“   r  ©	rÛ   r‡   rì   r  rØ   r~  ra   r×   rÚ   rU   rV   Ú
<listcomp>~  s"    ôôøÿz@PydanticModelTransformer.get_field_arguments.<locals>.<listcomp>)r
  r‡   )
ra   r  r×   rØ   rÚ   r~  r  rì   rÛ   Ú	argumentsrU   r°  rV   r†  n  s
   õz,PydanticModelTransformer.get_field_argumentsc                 C  s4   |j s|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  r  Úis_dynamic_alias_presentr¦   r=  r¤  r\   r£   )ra   r  r³   rU   rU   rV   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  rU   rU   rV   r³  ›  s   ÿ
ÿz1PydanticModelTransformer.is_dynamic_alias_presentN)
r€   r   r�   r	  r‚   r1   r\   r[   rR   rY   )rR   r¦   )rR   rY   )rR   r/  )r0  r/  rì   r¦   rR   rK  )rF  r   rR   rZ  )r^  r   rR   rZ  )rF  r   r0  r/  r  r_  rR   r`  )rl   r%   r“   rQ   rÂ   r   rR   rÕ   )
r  r}  r³   r/  r  r¦   rì   r¦   rR   rY   )r  r}  r‚   r1   r  r¦   rR   rY   rý   )r“   rQ   rï   r   r1  r¦   rR   r¢  )rF  r   rR   r¦   )rF  r   rR   rÒ   )rF  r   rR   r¬  )r  r}  r×   r¦   rØ   r¦   rÚ   r¦   r~  r¦   r  r¦   rì   r¦   rÛ   r¦   rR   r¯  )r  r}  r³   r/  rR   r¦   )r  r}  r=  r¦   rR   r¦   )rž   rŸ   r    r¡   r  r¼   r`   rƒ   r  r  r  r]  rO  rP  rn  r  r  r  r6  Ústaticmethodrg  rh  rl  rm  r†  r�  r³  rU   rU   rU   rV   r   É  s<   
 


$

L
D

 


&
9
(#!÷
 r   c                      s,   e Zd ZdZd‡ fdd„Zddd„Z‡  ZS )rŠ  z<A type translator used to change type of Any's, if explicit.Útype_of_anyrÓ   rR   rY   c                   s   || _ tƒ  ¡  d S rZ   )Ú_type_of_anyr_   r`   )ra   rµ  rb   rU   rV   r`   ­  s   z ChangeExplicitTypeOfAny.__init__ry  r8   r<   c                 C  s   |j tjkr|j| jd�S |S )N)rµ  )rµ  r=   rã   ræ   r¶  )ra   ry  rU   rU   rV   Ú	visit_any±  s   z!ChangeExplicitTypeOfAny.visit_any)rµ  rÓ   rR   rY   )ry  r8   rR   r<   )rž   rŸ   r    r¡   r`   r·  r¢   rU   rU   rb   rV   rŠ  ª  s    rŠ  c                   @  sJ   e Zd ZdZ								dddd„Zddd„Zd dd„Zd!dd„ZdS )"r/  z(Pydantic mypy plugin model config class.Nr¤  rÒ   r  r¾   r  r  r  r=  rÑ   c	           	      C  s4   || _ || _|| _|| _|| _|| _|| _|| _d S rZ   )r¤  r  r¾   r  r  r  r=  rÑ   )	ra   r¤  r  r¾   r  r  r  r=  rÑ   rU   rU   rV   r`   »  s   
zModelConfigData.__init__rR   r}   c                 C  s   dd„ | j  ¡ D ƒS )z†Returns a dict of Pydantic model config names to their values.

        It includes the config if config value is not `None`.
        c                 S  s   i | ]\}}|d ur||“qS rZ   rU   )r¶   ÚkÚvrU   rU   rV   r¸   Ô  s    z3ModelConfigData.get_values_dict.<locals>.<dictcomp>)Ú__dict__r5  r·   rU   rU   rV   r  Ï  ó   zModelConfigData.get_values_dictr³   r¢  rY   c                 C  s2   |du rdS |  ¡  ¡ D ]
\}}t| ||ƒ qdS )z$Update Pydantic model config values.N)r  r5  r®   )ra   r³   r¸  r¹  rU   rU   rV   r7  Ö  s
   ÿzModelConfigData.updater´   rQ   r   r   c                 C  s"   t | |ƒdu rt| ||ƒ dS dS )zFSet default value for Pydantic model config if config value is `None`.N)r‰   r®   )ra   r´   r   rU   rU   rV   rA  Ý  s   ÿzModelConfigData.setdefault)NNNNNNNN)r¤  rÒ   r  rÒ   r¾   rÒ   r  rÒ   r  rÒ   r  rÒ   r=  rÒ   rÑ   rÒ   r»   )r³   r¢  rR   rY   )r´   rQ   r   r   rR   rY   )rž   rŸ   r    r¡   r`   r  r7  rA  rU   rU   rU   rV   r/  ¸  s    ÷

r/  r‡   r(   r¦   c                 C  s
   |   t¡S )zXReturn whether the type info is a root model subclass (or the `RootModel` class itself).)ri   ÚROOT_MODEL_FULLNAME)r‡   rU   rU   rV   rì   ã  s   
rì   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   rY   c                 C  ó   |j d| › d�|td� dS )zCEmits an error when the model does not have `from_attributes=True`.rr  z$" does not have from_attributes=True©ÚcodeN)r<  Ú	ERROR_ORM)r¾  r‚   rÂ   rU   rU   rV   rÆ   ñ  ó   rÆ   r“   r1   c                 C  r¿  )z0Emits an error when the config value is invalid.zInvalid value for "Config.rr  rÀ  N)r<  ÚERROR_CONFIG)r“   r‚   rÂ   rU   rU   rV   r¨  ö  rÃ  r¨  c                 C  ó   | j d|td� dS )znEmits required dynamic aliases error.

    This will be called when `warn_required_dynamic_aliases=True`.
    z#Required dynamic aliases disallowedrÀ  N)r<  ÚERROR_ALIAS©r‚   rÂ   rU   rU   rV   r>  û  r»  r>  rÉ   ú8CheckerPluginInterface | SemanticAnalyzerPluginInterfacec                 C  s4   d}d| › d�}|d|› d�7 }|j ||td� 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)r<  ÚERROR_UNEXPECTED)rÉ   r‚   rÂ   ÚlinkÚfull_messagerU   rU   rV   rÁ     s   rÁ   c                 C  rÅ  )z;Emits an error when there is an untyped field in the model.zUntyped fields disallowedrÀ  N)r<  ÚERROR_UNTYPEDrÇ  rU   rU   rV   re    rº   re  c                 C  rÅ  )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)r<  ÚERROR_EXTRA_FIELD_ROOT_MODELrÇ  rU   rU   rV   rQ    rº   rQ  Fú8SemanticAnalyzerPluginInterface | CheckerPluginInterfacer€   r   r�   r¯  r„  rè   rÕ   Útvar_defúTypeVarType | Noner—  c                 C  s  |j }||jv r|j| }	|	jrt|	jtƒr|jj |	j¡ t| t	ƒr)|  
d¡}
n|  dg ¡}
|rE|p8tt|ƒƒ}ttdƒ|dtdƒg}n|pJt|ƒ}ttdƒ|dtƒg}|| }g g g }}}|D ]}|jslJ dƒ‚| |j¡ | |jj¡ | |j¡ qct|||||
|r‹|gndd�}t||ttƒ gƒƒ}||_ t||ƒ|_||_|jd | |_|j|_||jv rÄt||jƒ}|j| |j|< |rìd|_ t||jƒ}||_ |j|_d|_!t"|t#d	ƒg|ƒ}|j|_t$t%|ƒ}	nt$t%|ƒ}	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.)Ú	variablesr�  rÿ   )'r‡   r%  r…  rg   rh   r   r8  r9  Úremover1   r˜  Únamed_generic_typer>   rB   r   r)   r   rß   rŒ  rÞ   r“   rá   r9   r   r    r3   rŠ   r.  rd   r¡  r”   rC   Úis_decoratedr—  r   r   r%   r   Údefn)r‚   r€   r“   r�   r„  rè   rÐ  r—  r‡   rl   Úfunction_typeÚfirstrw  r�   rv  rï   Ú	signaturer-  Úr_namer¹  ÚdecrU   rU   rV   rŽ    sZ   


ÿ


rŽ  r©   údict[str, Any] | Nonec                 C  s’   |   d¡sdS tjdkrddl}nzddl}W n ty,   ddl}|jddd� Y dS w t| dƒ�}| 	|¡W  d  ƒ S 1 sBw   Y  dS )	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)é   é   r   zJNo TOML parser installed, cannot read configuration from `pyproject.toml`.rO   )Ú
stacklevelÚrb)
ru   ÚsysÚversion_infoÚtomllibÚtomliÚImportErrorÚwarningsÚwarnÚopenÚload)r©   Útoml_rç  ÚrfrU   rU   rV   rª   p  s   


ü$ÿrª   )rP   rQ   rR   rS   )r|   r.   rR   r<   )r‡   r(   rR   r¦   )r¾  rQ   r‚   r+   rÂ   r   rR   rY   )r“   rQ   r‚   r1   rÂ   r   rR   rY   )r‚   r1   rÂ   r   rR   rY   )rÉ   rQ   r‚   rÈ  rÂ   r   rR   rY   )r‚   r+   rÂ   r   rR   rY   )NNF)r‚   rÏ  r€   r   r“   rQ   r�   r¯  r„  r<   rè   rÕ   rÐ  rÑ  r—  r¦   rR   rY   )r©   rQ   rR   rÝ  )„r¡   Ú
__future__r   râ  Úcollections.abcr   Úconfigparserr   Útypingr   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.   r/   r0   r1   Úmypy.plugins.commonr2   Úmypy.semanalr3   Úmypy.server.triggerr4   Ú
mypy.stater5   Úmypy.type_visitorr6   Úmypy.typeopsr7   Ú
mypy.typesr8   r9   r:   r;   r<   r=   r>   r?   r@   rA   Úmypy.typevarsrB   Ú	mypy.utilrC   Úmypy.versionrD   Úmypy_versionÚpydantic._internalrE   Úpydantic.versionrF   r±   rÅ   rj   ry   r  r¼  ro   rª  ÚDATACLASS_FULLNAMEr*  rd  r)  ÚMYPY_VERSION_TUPLEr™  rW   rT   r[   rv   rË   r   r   rŠ  r/  rì   rÂ  rÄ  rÆ  rÊ  rÍ  ÚERROR_FIELD_DEFAULTSrÎ  rÆ   r¨  r>  rÁ   re  rQ  rŽ  rª   rU   rU   rU   rV   Ú<module>   s�    ˆ"$	0

W
.      f
+





øX