Ë
    &V.j.Ü  ã                  óˆ  — 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
l2m3Z3m4Z4m5Z5m6Z6m7Z7m8Z8 ddl9m:Z: ddl;m<Z< ddl=m>Z> ddl?m@Z@ ddlAmBZB ddlCmDZDmEZEmFZFmGZGmHZHmIZImJZJmKZKmLZLmMZM ddlNmOZO ddlPmQZQ ddlRmSZT ddlUmVZV ddlWmXZX dZYdZZdZ[dZ\dZ]dZ^dZ_dZ`dZah d£Zb eXeT«      Zcd Zdd!ZSdEd"„Ze G d#„ d$e6«      Zf G d%„ d&«      ZgdFd'„Zh G d(„ d)«      Zi G d*„ d+«      Zj G d,„ d-«      Zk G d.„ d/«      Zl ed0d1d2«      Zm ed3d4d2«      Zn ed5d6d2«      Zo ed7d8d2«      Zp ed9d:d2«      Zq ed9d;d2«      Zr ed9d<d2«      ZsdGd=„ZtdHd>„ZudId?„Zv	 	 	 	 	 	 	 	 dJd@„ZwdIdA„ZxdKdB„Zy	 	 	 dL	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 dMdC„ZzdNdD„Z{y)Oz^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ÚMethodContextÚPluginÚReportConfigContextÚSemanticAnalyzerPluginInterface)Údeserialize_and_fixup_type)Úset_callable_name)Úmake_wildcard_trigger)Ústate)Ú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_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ú0pydantic.functional_serializers.model_serializerú3pydantic.deprecated.class_validators.root_validatorrG   Úbuiltinsé   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)Úversions    úOC:\xampp\htdocs\tradingbinance\backend\.venv\Lib\site-packages\pydantic/mypy.pyÚpluginrS   j   s
   € ô Ðó    c                  óT   ‡ — 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
ˆ xZS )rP   zThe Pydantic mypy plugin.c                ó‚   •— t        |«      | _        | j                  j                  «       | _        t        ‰| �  |«       y ©N)ÚPydanticPluginConfigÚplugin_configÚto_dataÚ_plugin_dataÚsuperÚ__init__)ÚselfÚoptionsÚ	__class__s     €rR   r]   zPydanticPlugin.__init__|   s4   ø€ Ü1°'Ó:ˆÔØ ×.Ñ.×6Ñ6Ó8ˆÔÜ‰Ñ˜Õ!rT   c                óÂ   — | j                  |«      }|rLt        |j                  t        «      r2t	        d„ |j                  j
                  D «       «      r| j                  S y)zUpdate Pydantic model class.c              3  óB   K  — | ]  }|j                   t        k(  –— Œ y ­wrW   ©ÚfullnameÚBASEMODEL_FULLNAME©Ú.0Úbases     rR   Ú	<genexpr>z5PydanticPlugin.get_base_class_hook.<locals>.<genexpr>†   s   è ø€ ÐPÁ<¸4�4—=‘=Ô$6Õ6Á<ùó   ‚N)Úlookup_fully_qualifiedÚ
isinstanceÚnoder)   ÚanyÚmroÚ$_pydantic_model_class_maker_callback)r^   rd   Úsyms      rR   Úget_base_class_hookz"PydanticPlugin.get_base_class_hook�   sG   € à×)Ñ)¨(Ó3ˆÙ”:˜cŸh™h¬Ô1äÑPÀ3Ç8Á8Ç<Â<ÓPÔPØ×@Ñ@Ð@ØrT   c                ó.   — |t         k(  r| j                  S y)z,Update Pydantic `ModelMetaclass` definition.N)ÚMODEL_METACLASS_FULLNAMEÚ)_pydantic_model_metaclass_marker_callback©r^   rd   s     rR   Úget_metaclass_hookz!PydanticPlugin.get_metaclass_hookŠ   s   € àÔ/Ò/Ø×AÑAÐAØrT   c                ó2   — |j                  d«      rt        S y)z-Adjust return type of `from_orm` method call.z	.from_ormN)ÚendswithÚfrom_attributes_callbackrv   s     rR   Úget_method_hookzPydanticPlugin.get_method_hook�   s   € à×Ñ˜[Ô)Ü+Ð+ØrT   c                ó   — | j                   S )zjReturn all plugin config data.

        Used by mypy to determine if cache needs to be discarded.
        )r[   )r^   Úctxs     rR   Úreport_config_dataz!PydanticPlugin.report_config_data–   s   € ð
 × Ñ Ð rT   c                ó�   — t        |j                  |j                  |j                  | j                  «      }|j                  «        y rW   )ÚPydanticModelTransformerÚclsÚreasonÚapirY   Ú	transform)r^   r}   Útransformers      rR   rp   z3PydanticPlugin._pydantic_model_class_maker_callback�   s0   € Ü.¨s¯w©w¸¿
¹
ÀCÇGÁGÈT×M_ÑM_Ó`ˆØ×ÑÕrT   c                óÖ   — | j                   j                  ry|j                  j                  j                  }|sJ d«       ‚t        |j                  dd«      rd|j                  _        yy)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)rY   Údebug_dataclass_transformr�   ÚinfoÚdeclared_metaclassÚgetattrÚtyper‡   )r^   r}   Úinfo_metaclasss      rR   ru   z8PydanticPlugin._pydantic_model_metaclass_marker_callback¡   s^   € ð ×Ñ×7Ò7ØØŸ™Ÿ™×8Ñ8ˆÙÐNÐNÓNˆ~Ü�>×&Ñ&Ð(BÀDÔIØ;?ˆN×ÑÕ8ð JrT   ©r_   r+   ÚreturnÚNone)rd   Ústrr�   z(Callable[[ClassDefContext], None] | None)rd   r‘   r�   z&Callable[[MethodContext], Type] | None)r}   r0   r�   údict[str, Any])r}   r-   r�   r�   )Ú__name__Ú
__module__Ú__qualname__Ú__doc__r]   rr   rw   r{   r~   rp   ru   Ú__classcell__)r`   s   @rR   rP   rP   y   s*   ø„ Ù#õ"ó
óóó!ó ÷@rT   rP   c                  óN   — 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y
)rX   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ˆ   c                óä  — |j                   €y t        |j                   «      }|�q|j                  di «      j                  di «      }| j                  D ]?  }|j                  |d«      }t	        |t
        «      st        d|› �«      ‚t        | ||«       ŒA y t        «       }|j                  |j                   «       | j                  D ]'  }|j                  t        |d¬«      }t        | ||«       Œ) y )NÚtoolrF   Fz/Configuration value must be a boolean for key: )Úfallback)Úconfig_fileÚ
parse_tomlÚgetÚ	__slots__rl   rœ   Ú
ValueErrorÚsetattrr   ÚreadÚ
getbooleanÚCONFIGFILE_KEY)r^   r_   Útoml_configÚconfigÚkeyÚsettingrY   s          rR   r]   zPydanticPluginConfig.__init__Å   sÜ   € Ø×ÑÐ&Øä  ×!4Ñ!4Ó5ˆØÐ"Ø —_‘_ V¨RÓ0×4Ñ4°_ÀbÓIˆFØ—~”~�Ø Ÿ*™* S¨%Ó0�Ü! '¬4Ô0Ü$Ð'VÐWZÐV[Ð%\Ó]Ð]Ü˜˜c 7Õ+ñ	 &ô )›NˆMØ×Ñ˜w×2Ñ2Ô3Ø—~”~�Ø'×2Ñ2´>À3ÐQVÐ2ÓW�Ü˜˜c 7Õ+ñ &rT   c                óV   — | j                   D �ci c]  }|t        | |«      “Œ c}S c c}w )z/Returns a dict of config names to their values.)r£   r‹   )r^   r«   s     rR   rZ   zPydanticPluginConfig.to_dataØ   s*   € à37·>²>ÓB±>¨C�”W˜T 3Ó'Ñ'°>ÑBÐBùÒBs   �&NrŽ   ©r�   r’   )r“   r”   r•   r–   r£   Ú__annotations__r]   rZ   © rT   rR   rX   rX   ¯   s3   … ñð€Ið ÓØÓØ#'Ó'Ø#Ó#ó,ô&CrT   rX   c                ó  — | j                   }t        |t        «      r|j                  }t        |t        «      r't        |j
                  t        «      r|j
                  }n]t        |t        «      r|}nJd|› d|j                  j                  › d�}t        || j                  | j                  «       | j                  S |j                   j                  j                  t        «      }|€| j                  S t!        d„ |j                   j"                  D «       «      s| j                  S |j                  di «      j                  d«      }|dur5t%        |j                   j&                  | j                  | j                  «       | j                  S )z1Raise an error if from_attributes is not enabled.z
ctx.type: ú
 (of type Ú)c              3  óB   K  — | ]  }|j                   t        k(  –— Œ y ­wrW   rc   rf   s     rR   ri   z+from_attributes_callback.<locals>.<genexpr>î   s   è ø€ ÐSÑ?R°tˆt�}‰}Ô 2Õ2Ñ?Rùrj   rª   Úfrom_attributesT)rŒ   rl   r=   Úitemr8   Úret_typer9   r`   r“   Úerror_unexpected_behaviorrƒ   ÚcontextÚdefault_return_typeÚmetadatar¢   ÚMETADATA_KEYrn   ro   Úerror_from_attributesÚname)r}   Úctx_typeÚ
model_typeÚdetailÚpydantic_metadatarµ   s         rR   rz   rz   Ý   s5  € ð �x‰x€HÜ�(œHÔ%Ø—=‘=ˆÜ�(œLÔ)¬j¸×9JÑ9JÌHÔ.UØ×&Ñ&‰
Ü	�HœhÔ	'Ø‰
à˜h˜Z z°(×2DÑ2D×2MÑ2MÐ1NÈaÐPˆÜ! &¨#¯'©'°3·;±;Ô?Ø×&Ñ&Ð&Ø"Ÿ™×0Ñ0×4Ñ4´\ÓBÐØÐ Ø×&Ñ&Ð&ÜÑS¸z¿¹×?RÒ?RÓSÔSà×&Ñ&Ð&Ø'×+Ñ+¨H°bÓ9×=Ñ=Ð>OÓP€OØ˜dÑ"Ü˜jŸo™o×2Ñ2°C·G±G¸S¿[¹[ÔIØ×"Ñ"Ð"rT   c                  óÆ   — 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y	)ÚPydanticModelFieldz5Based on mypy.plugins.dataclasses.DataclassAttribute.c                ó�   — || _         || _        || _        || _        || _        || _        || _        || _        |	| _        |
| _	        y rW   )
r¾   ÚaliasÚ	is_frozenÚhas_dynamic_aliasÚhas_defaultÚstrictÚlineÚcolumnrŒ   r‰   )r^   r¾   rÆ   rÇ   rÈ   rÉ   rÊ   rË   rÌ   rŒ   r‰   s              rR   r]   zPydanticModelField.__init__ú   sL   € ð ˆŒ	ØˆŒ
Ø"ˆŒØ!2ˆÔØ&ˆÔØˆŒØˆŒ	ØˆŒØˆŒ	Øˆ�	rT   c	                ó0  — | j                  ||||«      }	| j                  €|n| j                  }
|s|
r| j                  ||«      }nt        t        j
                  «      }t        |	|d|rt        ¬«      S |s| j                  rt        ¬«      S t        ¬«      S )zABased on mypy.plugins.dataclasses.DataclassAttribute.to_argument.N)ÚvariableÚtype_annotationÚinitializerÚkind)Úto_varrÊ   r	   r7   r<   Úexplicitr   r   rÉ   r   r   )r^   Úcurrent_infoÚtypedÚmodel_strictÚforce_optionalÚ	use_aliasrƒ   Úforce_typevars_invariantÚis_root_model_rootrÎ   rÊ   rÏ   s               rR   Úto_argumentzPydanticModelField.to_argument  sœ   € ð —;‘;˜|¨S°)Ð=UÓVˆà!%§¡Ð!4‘¸$¿+¹+ˆÙ‘FØ"×.Ñ.¨|¸SÓA‰Oä%¤i×&8Ñ&8Ó9ˆOäØØ+Øá!ô ô	
ð 	
ñ $2°T×5EÒ5E”-ô
ð 	
ô LUô
ð 	
rT   c                ó†  — |rFt        | j                  t        «      r,| j                  j                  «       }t        |_        || _        | j                  �Ë| j                  j                  �µt        j                  |j                  j                  «      5  t        |«      }t        |t        «      sJ ‚|r-|j                  D ]  }t        |t        «      sŒt        |_        Œ  t        | j                  | j                  j                  j                   |i«      cddd«       S | j                  S # 1 sw Y   | j                  S xY w)zABased on mypy.plugins.dataclasses.DataclassAttribute.expand_type.N)rl   rŒ   r>   Úcopy_modifiedr   Úvariancer‰   Ú	self_typer5   Ústrict_optional_setr_   Ústrict_optionalrA   r9   Úargsr	   Úid)r^   rÔ   rƒ   rÙ   Úmodified_typeÚfilled_with_typevarsÚargs          rR   r	   zPydanticModelField.expand_type/  sù   € ñ $ô
 ˜$Ÿ)™)¤[Ô1Ø $§	¡	× 7Ñ 7Ó 9�Ü)2�Ô&Ø)�”	à�9‰9Ð  T§Y¡Y×%8Ñ%8Ð%Dô
 ×*Ñ*¨3¯;©;×+FÑ+FÕGÜ'4°\Ó'BÐ$ä!Ð"6¼ÔAÐAÐAÙ+Ø3×8Ô8˜Ü% c¬;Õ7Ü+4˜C�Lð  9ô # 4§9¡9¨t¯y©y×/BÑ/B×/EÑ/EÐG[Ð.\Ó]÷ HÑGð �y‰yÐ÷ Hð �y‰yÐús   Â?D,ÃAD,Ä,E c                óŠ   — |r| j                   �| j                   }n| j                  }t        || j                  |||«      «      S )z<Based on mypy.plugins.dataclasses.DataclassAttribute.to_var.)rÆ   r¾   r*   r	   )r^   rÔ   rƒ   rØ   rÙ   r¾   s         rR   rÒ   zPydanticModelField.to_varM  s?   € ñ ˜Ÿ™Ð/Ø—:‘:‰Dà—9‘9ˆDä�4˜×)Ñ)¨,¸Ð=UÓVÓWÐWrT   c           
     ó  — | j                   sJ ‚| 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Ì   Ú	serialize©r^   s    rR   rê   zPydanticModelField.serialize\  sd   € à�yŠyÐˆyà—I‘IØ—Z‘ZØŸ™Ø!%×!7Ñ!7Ø×+Ñ+Ø—k‘kØ—I‘IØ—k‘kØ—I‘I×'Ñ'Ó)ñ

ð 
	
rT   c                ón   — |j                  «       }t        |j                  d«      |«      } | d||dœ|¤ŽS )úABased on mypy.plugins.dataclasses.DataclassAttribute.deserialize.rŒ   )rŒ   r‰   r°   )Úcopyr2   Úpop)r�   r‰   Údatarƒ   Útyps        rR   ÚdeserializezPydanticModelField.deserializek  s9   € ð �y‰y‹{ˆÜ(¨¯©°&Ó)9¸3Ó?ˆÙÐ/˜ $Ñ/¨$Ñ/Ð/rT   c                óæ   — | j                   �Yt        j                  |j                  j                  «      5  t        | j                   || j                  «      | _         ddd«       yy# 1 sw Y   yxY w)zxExpands type vars in the context of a subtype when an attribute is inherited
        from a generic super type.
        N)rŒ   r5   rà   r_   rá   r6   r‰   )r^   Úsub_typerƒ   s      rR   Úexpand_typevar_from_subtypez.PydanticModelField.expand_typevar_from_subtyper  sS   € ð �9‰9Ð Ü×*Ñ*¨3¯;©;×+FÑ+FÕGÜ3°D·I±I¸xÈÏÉÓS�”	÷ HÐGð !ßGÐGús   ¶'A'Á'A0N)r¾   r‘   rÆ   z
str | NonerÇ   rœ   rÈ   rœ   rÉ   rœ   rÊ   úbool | NonerË   ÚintrÌ   r÷   rŒ   úType | Noner‰   r)   )rÔ   r)   rÕ   rœ   rÖ   rœ   r×   rœ   rØ   rœ   rƒ   r1   rÙ   rœ   rÚ   rœ   r�   r   ©F)rÔ   r)   rƒ   r1   rÙ   rœ   r�   rø   )
rÔ   r)   rƒ   r1   rØ   rœ   rÙ   rœ   r�   r*   ©r�   r   )r‰   r)   rð   r   rƒ   r1   r�   rÄ   )rô   r)   rƒ   r1   r�   r�   )r“   r”   r•   r–   r]   rÛ   r	   rÒ   rê   Úclassmethodrò   rõ   r°   rT   rR   rÄ   rÄ   ÷   sU  „ Ù?ðàðð ðð ð	ð
  ðð ðð ðð ðð ðð ðð óð0
àð
ð ð
ð ð	
ð
 ð
ð ð
ð -ð
ð #'ð
ð !ð
ð 
ó
ð< nsðØ$ðØ+JðØfjðà	óðF */ðXàðXð -ðXð ð	Xð
 #'ðXð 
óXó
ð ò0ó ð0ôTrT   rÄ   c                  ó0   — e Zd ZdZd„ Zedd„«       Zdd„Zy)ÚPydanticModelClassVarz•Based on mypy.plugins.dataclasses.DataclassAttribute.

    ClassVars are ignored by subclasses.

    Attributes:
        name: the ClassVar name
    c                ó   — || _         y rW   ©r¾   )r^   r¾   s     rR   r]   zPydanticModelClassVar.__init__„  s	   € Øˆ�	rT   c                ó2   — |j                  «       } | di |¤ŽS )rí   r°   )rî   )r�   rð   s     rR   rò   z!PydanticModelClassVar.deserialize‡  s   € ð �y‰y‹{ˆÙ‰{�T‰{ÐrT   c                ó   — d| j                   iS )ré   r¾   rÿ   rë   s    rR   rê   zPydanticModelClassVar.serialize�  s   € ð �D—I‘Ið
ð 	
rT   N)rð   r   r�   rý   rú   )r“   r”   r•   r–   r]   rû   rò   rê   r°   rT   rR   rý   rý   {  s%   „ ñòð òó ðô

rT   rý   c                  óv  — e Zd ZU dZh d£Zded<   	 	 	 	 	 	 	 	 	 	 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	 	 	 	 	 	 	 	 	 	 d#d„Z	 	 	 	 	 	 	 	 	 	 d#d„Zd$d„Zd%d&d„Zed'd„«       Zed(d„«       Zed)d„«       Zed'd„«       Z	 d%	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 d*d„Zd+d„Zed,d„«       Zy)-r€   z¸Transform the BaseModel subclass according to the plugin settings.

    Attributes:
        tracked_config_fields: A set of field configs that the plugin has to track their value.
    >   ÚextraÚfrozenrÊ   Úalias_generatorrµ   Úpopulate_by_namezset[str]Útracked_config_fieldsc                ó<   — || _         || _        || _        || _        y rW   )Ú_clsÚ_reasonÚ_apirY   )r^   r�   r‚   rƒ   rY   s        rR   r]   z!PydanticModelTransformer.__init__¤  s!   € ð ˆŒ	ØˆŒØˆŒ	à*ˆÕrT   c                óè  — | j                   j                  }t        d„ |j                  dd D «       «      }| j	                  «       }| j                  ||«      \  }}|�|€y|D ]  }|j                  �Œ y t        d„ |j                  dd D «       «      }| j                  ||||«       | j                  ||||«       | j                  || j                  |j                  du ¬«       | j                  «        |D �ci c]  }|j                  |j                  «       “Œ c}|D �ci c]  }|j                  |j                  «       “Œ c}|j                  «       dœ|j                   t"        <   yc c}w c c}w )	a†  Configures the BaseModel subclass according to the plugin settings.

        In particular:

        * determines the model config and fields,
        * adds a fields-aware signature for the initializer and construct methods
        * freezes the class if frozen = True
        * stores the fields, config, and if the class is settings in the mypy metadata for access by subclasses
        c              3  ó@   K  — | ]  }t         |j                  v –— Œ y ­wrW   )ÚROOT_MODEL_FULLNAMErd   rf   s     rR   ri   z5PydanticModelTransformer.transform.<locals>.<genexpr>¼  s   è ø€ Ð[É]ÀTÔ/°4·=±=Ô@É]ùs   ‚NéÿÿÿÿFc              3  óB   K  — | ]  }|j                   t        k(  –— Œ y ­wrW   )rd   ÚBASESETTINGS_FULLNAMErf   s     rR   ri   z5PydanticModelTransformer.transform.<locals>.<genexpr>Æ  s   è ø€ Ð[É]ÀT˜$Ÿ-™-Ô+@Õ@É]ùrj   T)r  )ÚfieldsÚ
class_varsrª   )r	  r‰   rn   ro   Úcollect_configÚcollect_fields_and_class_varsrŒ   Úadd_initializerÚadd_model_construct_methodÚ
set_frozenr  r  Úadjust_decorator_signaturesr¾   rê   Úget_values_dictr»   r¼   )	r^   r‰   Úis_root_modelrª   r  r  ÚfieldÚis_settingsÚ	class_vars	            rR   r„   z"PydanticModelTransformer.transform±  s]  € ð �y‰y�~‰~ˆÜÑ[ÈTÏXÉXÐVYÐWYÉ]Ó[Ó[ˆØ×$Ñ$Ó&ˆØ!×?Ñ?ÀÈÓVÑˆ�
Øˆ>˜ZÐ/àÛˆEØ�z‰zÑ!Ùð ô Ñ[ÈTÏXÉXÐVYÐWYÉ]Ó[Ó[ˆØ×Ñ˜V V¨[¸-ÔHØ×'Ñ'¨°¸À]ÔSØ�‰˜ §	¡	°&·-±-À4Ð2GˆÔHà×(Ñ(Ô*ñ CIÓIÁ&¸�u—z‘z 5§?¡?Ó#4Ñ4À&ÑIÙR\Ó]ÑR\ÀY˜9Ÿ>™>¨9×+>Ñ+>Ó+@Ñ@ÐR\Ñ]Ø×,Ñ,Ó.ñ'
ˆ�‰”lÑ#ð ùò JùÚ]s   Ã:"E*Ä""E/c                ó&  ‡— | j                   j                  j                  j                  «       D ]ß  }t	        |j
                  t        «      sŒ|j
                  j                  d   Št	        ‰t        «      sŒHt	        ‰j                  t        «      sŒc‰j                  j                  t        v sŒ€‰j                  j                  t        k(  r(t        ˆfd„t        ‰j                   «      D «       «      rŒÅd|j
                  j"                  _        Œá y)a¿  When we decorate a function `f` with `pydantic.validator(...)`, `pydantic.field_validator`
        or `pydantic.serializer(...)`, mypy sees `f` as a regular method taking a `self` instance,
        even though pydantic internally wraps `f` with `classmethod` if necessary.

        Teach mypy this by marking any function whose outermost decorator is a `validator()`,
        `field_validator()` or `serializer()` call as a `classmethod`.
        r   c              3  óŽ   •K  — | ]<  \  }}‰j                   |   d k(  xr! t        |t        «      xr |j                  dk(  –— Œ> y­w)ÚmodeÚafterN)Ú	arg_namesrl   r%   Úvalue)rg   Úiræ   Ú	first_decs      €rR   ri   zGPydanticModelTransformer.adjust_decorator_signatures.<locals>.<genexpr>ç  sO   øè ø€ ð  á*C¡  3ð &×/Ñ/°Ñ2°fÑ<ÒrÄÈCÔQXÓAYÒrÐ^a×^gÑ^gÐkrÑ^rÓrÙ*Cùs   ƒAATN)r	  r‰   ÚnamesÚvaluesrl   rm   r   Úoriginal_decoratorsr   Úcalleer    rd   ÚDECORATOR_FULLNAMESÚMODEL_VALIDATOR_FULLNAMErn   Ú	enumeraterâ   ÚfuncÚis_class)r^   rq   r&  s     @rR   r  z4PydanticModelTransformer.adjust_decorator_signaturesÕ  s¾   ø€ ð —9‘9—>‘>×'Ñ'×.Ñ.Ö0ˆCÜ˜#Ÿ(™(¤IÕ.ØŸH™H×8Ñ8¸Ñ;�	ä˜y¬(Õ3Ü" 9×#3Ñ#3´XÕ>Ø!×(Ñ(×1Ñ1Ô5HÒHð "×(Ñ(×1Ñ1Ô5MÒMÜó  ä*3°I·N±NÔ*Có õ ð .2�C—H‘H—M‘MÕ*ñ# 1rT   c           	     óö  — | j                   }t        «       }d}d}|j                  j                  «       D ]-  \  }}| j	                  ||«      }|sŒd}|j                  |«       Œ/ d}|j                  j                  D �]  }t        |t        t        f«      sŒt        |t        «      �r"|j                  d   }	t        |	t        «      r|	j                  dk7  rŒ[t        |j                  t        «      rdt!        |j                  j"                  |j                  j$                  «      D ]+  \  }
}|
€Œ	|j                  | j	                  |
|d¬«      «       Œ- �nt        |j                  t&        «      rý|j                  j                  D ]A  \  }}t        |t(        «      sŒ|j                  | j	                  |j*                  |«      «       ŒC n¢t        |t        «      r’|j                  dk7  r�Œo|j                  j                  D ]h  }t        |t        «      sŒ|j                  d   }	t        |	t        «      sŒ4|j                  | j	                  |	j                  |j                  «      «       Œj |r| j,                  j/                  d|«        nd}�Œ |s|rF|rD|j0                  r8|j2                  s,| j4                  j6                  rt9        | j,                  |«       |j:                  j<                  d	d D ]�  }t>        |j@                  vrŒ| j,                  jC                  tE        |jF                  «      «       |j@                  t>           d
   j                  «       D ]  \  }}|jI                  ||«       Œ Œƒ |S )zhCollects the values of the config attributes that are used by the plugin, accounting for parent classes.FTNr   Úmodel_config)Ú	lax_extraÚConfigzYSpecifying config in two places is ambiguous, use either Config attribute or class kwargsé   rª   )%r	  ÚModelConfigDataÚkeywordsÚitemsÚget_config_updateÚupdateÚdefsÚbodyrl   r   r   Úlvaluesr    r¾   Úrvaluer   Úzipr#  râ   r   r%   r$  r  ÚfailÚhas_alias_generatorr  rY   r›   Úerror_required_dynamic_aliasesr‰   ro   r¼   r»   Úadd_plugin_dependencyr4   rd   Ú
setdefault)r^   r�   rª   Úhas_config_kwargsÚhas_config_from_namespacer¾   ÚexprÚconfig_dataÚstmtÚlhsÚarg_nameræ   Úkey_exprÚ
value_exprÚsubstmtr‰   r$  s                    rR   r  z'PydanticModelTransformer.collect_configð  sÌ  € à�i‰iˆÜ Ó"ˆà!ÐØ$)Ð!ð Ÿ,™,×,Ñ,Ö.‰JˆD�$Ø×0Ñ0°°tÓ<ˆKÚØ$(Ð!Ø—‘˜kÕ*ð	 /ð "&ˆØ—H‘H—M•MˆDÜ˜d¤^´XÐ$>Ô?Øä˜$¤Õ/Ø—l‘l 1‘o�Ü! #¤xÔ0°C·H±HÀÒ4NØä˜dŸk™k¬8Ô4Ü),¨T¯[©[×-BÑ-BÀDÇKÁK×DTÑDTÖ)U™˜ #Ø#Ð+Ø$ØŸ™ d×&<Ñ&<¸XÀsÐVZÐ&<Ó&[Õ\ò *Vô   §¡¬XÔ6Ø04·±×0AÔ0AÑ,˜ *Ü)¨(´GÔ<Ø$ØŸ™ d×&<Ñ&<¸X¿^¹^ÈZÓ&XÕYñ 1Bô
 ˜D¤(Ô+Ø—9‘9 Ò(ÙØ#Ÿy™yŸ~œ~�GÜ% g¬~Ô>Ø Ø!Ÿ/™/¨!Ñ,�CÜ% c¬8Ô4Ø Ø—M‘M $×"8Ñ"8¸¿¹À7Ç>Á>Ó"RÕSð  .ñ !Ø—	‘	—‘ØoØôñ à(,Ò%ðM "ñP Ñ 9áØ×.Ò.Ø×/Ò/Ø×&Ñ&×DÒDä.¨t¯y©y¸$Ô?à—H‘H—L‘L  Ó$ˆDÜ 4§=¡=Ñ0Øð �I‰I×+Ñ+Ô,AÀ$Ç-Á-Ó,PÔQØ#Ÿ}™}¬\Ñ:¸8ÑD×JÑJÖL‘��eØ×!Ñ! $¨Õ.ñ  Mð %ð ˆrT   c                óÐ  — | j                   }i }i }t        |j                  j                  dd «      D �]v  }t        |j
                  vrŒ| j                  j                  t        |j                  «      «       |j
                  t           d   j                  «       D ]Ç  \  }}t        j                  ||| j                  «      }	|	j                  |j                  | j                  «       |	||<   |j                  j                  j                  |«      }
|
sŒz|
j                   sŒ‡t#        |
j                   t$        «      rŒ¢| j                  j'                  d|
j                   «       ŒÉ |j
                  t           d   j                  «       D ]  \  }}t(        j                  |«      ||<   Œ �Œy t+        «       }t+        «       }| j-                  |j.                  «      D ]×  }| j1                  |||«      }|€Œ|j2                  d   }t#        |t4        «      sJ ‚t#        |t        «      rS|r&|j6                  dk7  rt9        | j                  |«       Œr|j;                  |j6                  «       |||j6                  <   Œ�t#        |t(        «      sŒ®|j;                  |j6                  «       |||j6                  <   ŒÙ t=        |j?                  «       «      t=        |j?                  «       «      fS )zACollects the fields for the model, accounting for parent classes.r4  r  r  z7BaseModel field may only be overridden by another fieldr  r   Úroot) r	  Úreversedr‰   ro   r¼   r»   r  rB  r4   rd   r7  rÄ   rò   rõ   r'  r¢   rm   rl   r*   r?  rý   ÚsetÚ%_get_assignment_statements_from_blockr:  Ú$collect_field_or_class_var_from_stmtr<  r    r¾   Ú error_extra_fields_on_root_modelÚaddÚlistr(  )r^   r1  r  r�   Úfound_fieldsÚfound_class_varsr‰   r¾   rð   r  Úsym_nodeÚcurrent_field_namesÚcurrent_class_vars_namesrH  Úmaybe_fieldrI  s                   rR   r  z6PydanticModelTransformer.collect_fields_and_class_vars<  sT  € ð �i‰iˆð 79ˆØ=?ÐÜ˜SŸX™XŸ\™\¨!¨BÐ/×0ˆDô  4§=¡=Ñ0Øð �I‰I×+Ñ+Ô,AÀ$Ç-Á-Ó,PÔQà"Ÿm™m¬LÑ9¸(ÑC×IÑIÖK‘
��dÜ*×6Ñ6°t¸TÀ4Ç9Á9ÓM�ð
 ×1Ñ1°#·(±(¸D¿I¹IÔFØ%*�˜TÑ"àŸ8™8Ÿ>™>×-Ñ-¨dÓ3�Ú §£´jÀÇÁÔPSÕ6TØ—I‘I—N‘NØQØ Ÿ™õð Lð  #Ÿm™m¬LÑ9¸,ÑG×MÑMÖO‘
��dÜ)>×)JÑ)JÈ4Ó)PÐ  Ò&ò Pð5 1ô< ),«ÐÜ-0«UÐ Ø×>Ñ>¸s¿x¹xÖHˆDØ×CÑCÀDÈ,ÐXhÓiˆKØÐ"Øà—,‘,˜q‘/ˆCÜ˜c¤8Ô,Ð,Ð,Ü˜+Ô'9Ô:Ù  S§X¡X°Ò%7Ü4°T·Y±YÀÕEà'×+Ñ+¨C¯H©HÔ5Ø-8�L §¡Ò*Ü˜KÔ)>Õ?Ø(×,Ñ,¨S¯X©XÔ6Ø-8Ð  §¡Ò*ð Iô" �L×'Ñ'Ó)Ó*¬DÐ1A×1HÑ1HÓ1JÓ,KÐKÐKrT   c              #  ó  K  — |j                   D ](  }|j                  rŒ| j                  |«      E d {  –—†  Œ* |j                  �;|j                  j                  s$| j                  |j                  «      E d {  –—†  y y y 7 ŒN7 Œ	­wrW   )r;  Úis_unreachablerR  Ú	else_body)r^   rH  r;  s      rR   Ú,_get_assignment_statements_from_if_statementzEPydanticModelTransformer._get_assignment_statements_from_if_statement€  st   è ø€ Ø—I”IˆDØ×&Ó&Ø×EÑEÀdÓK×KÑKð ð �>‰>Ð%¨d¯n©n×.KÒ.KØ×AÑAÀ$Ç.Á.ÓQ×QÑQð /LÐ%ð LøàQús'   ‚BŸB³B´ABÁ:BÁ;BÂBc              #  ó°   K  — |j                   D ]A  }t        |t        «      r|–— Œt        |t        «      sŒ)| j	                  |«      E d {  –—†  ŒC y 7 Œ­wrW   )r;  rl   r   r   r`  )r^   ÚblockrH  s      rR   rR  z>PydanticModelTransformer._get_assignment_statements_from_block‡  sG   è ø€ Ø—J”JˆDÜ˜$¤Ô/Ø“
Ü˜D¤&Õ)Ø×LÑLÈTÓR×RÑRñ	 ð Sús   ‚5A¸AÁAÁAc                óÖ  — | j                   }|j                  d   }t        |t        «      r.t	        j
                  |j                  «      r|j                  dk(  ry|j                  sÃt        |j                  t        «      rƒt        |j                  j                  t        «      r_t        |j                  j                  j                  t        «      r1|j                  j                  j                  j                  t        v ry|j                  |v ryt        | j                  |«       y|j                  d   }t        |t        «      syt	        j
                  |j                  «      r|j                  dk(  ry|j                  j                   j#                  |j                  «      }|€y|j$                  }t        |t&        «      ryt        |t(        «      r| j                  j+                  d|«       yt        |t,        «      sy|j.                  rt1        |j                  «      S t3        |j4                  «      }t        |t6        «      r5|j4                  j                  dk(  r| j                  j+                  d|«       | j9                  |«      }	| j;                  |«      }
|j4                  €ƒ|j<                  rw|j>                  rk| j                  jA                  |j                  d¬«      }|r||_        n:| j                  j+                  d	|«       tC        tD        jF                  «      |_        | jI                  |«      \  }}|r8|jJ                  s,| jL                  jN                  rtQ        | j                  |«       | jS                  |«      }| jU                  ||j                  |«      }tW        |j                  ||	|
|||jX                  |jZ                  ||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   r1  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<  rl   r    rD   Úis_valid_field_namer¾   Ú
new_syntaxr=  r   r*  rd   r+  Úerror_untyped_fieldsr  r‰   r'  r¢   rm   r"   r(   r?  r*   Úis_classvarrý   r@   rŒ   r9   Úget_has_defaultÚ
get_strictrd  Úis_inferredÚanalyze_simple_literal_typer7   r<   Ú
from_errorÚget_alias_infor  rY   r›   rA  Úis_field_frozenÚ_infer_dataclass_attr_init_typerÄ   rË   rÌ   )r^   rH  r1  r  r�   rI  rq   rm   Ú	node_typerÉ   rÊ   rñ   rÆ   rÈ   rÇ   Ú	init_types                   rR   rS  z=PydanticModelTransformer.collect_field_or_class_var_from_stmtŽ  s  € ð �i‰iˆà�l‰l˜1‰oˆÜ˜#œxÔ(´×0KÑ0KÈCÏHÉHÔ0UÐY\×YaÑYaÐesÒYsØà�Šä˜4Ÿ;™;¬Ô1Ü˜tŸ{™{×1Ñ1´8Ô<Ü˜tŸ{™{×1Ñ1×8Ñ8¼(ÔCØ—K‘K×&Ñ&×-Ñ-×6Ñ6Ô:MÑMð
 à�x‰x˜:Ñ%àô ! §¡¨DÔ1Øà�l‰l˜1‰oˆÜ˜#œxÔ(Øä×*Ñ*¨3¯8©8Ô4¸¿¹ÀNÒ8RØà�h‰h�n‰n× Ñ  §¡Ó*ˆØˆ;ð à�x‰xˆÜ�dœOÔ,ð
 ä�dœIÔ&Ø�I‰I�N‰NØXØôð ä˜$¤Ô$ð
 ð ×ÒÜ(¨¯©Ó2Ð2ô $ D§I¡IÓ.ˆ	Ü�i¤Ô*¨y¯~©~×/FÑ/FÐJ_Ò/_Ø�I‰I�N‰NØ7Øôð
 ×*Ñ*¨4Ó0ˆØ—‘ Ó&ˆà�8‰8Ð §¢°$×2BÒ2Bð —)‘)×7Ñ7¸¿¹ÈdÐ7ÓSˆCÙØ�•	à—	‘	—‘Ø]Øôô $¤I×$8Ñ$8Ó9�”	à#'×#6Ñ#6°tÓ#<Ñ ˆÐ Ù \×%BÒ%BÀt×GYÑGY×GwÒGwÜ*¨4¯9©9°dÔ;Ø×(Ñ(¨Ó.ˆ	à×8Ñ8¸¸c¿h¹hÈÓMˆ	Ü!Ø—‘Ø/Ø#ØØØØ—‘Ø—;‘;ØØ—‘ô
ð 	
rT   c                ó8  — |j                   }|j                  r|S t        |j                   «      }t        |t        «      s|S |j                   j                  d«      }|�r:t        |j                  t        «      rì|j                   j                  d«      }|sJ ‚|j                   r+t        t        |j                   |j                   |«      «      }nt        t        j                  «      S t        |t        «      r7|j                  t        t        t        gk(  rt!        |j"                  d   |«      S | j$                  j'                  d|j                   j(                  › d�|«       |S | j$                  j'                  d|j                   j(                  › d�|«       |S )zvInfer __init__ argument type for an attribute.

        In particular, possibly use the signature of __set__.
        Ú__set__rN   z(Unsupported signature for "__set__" in "Ú"zUnsupported "__set__" in ")rŒ   Úimplicitr@   rl   r9   r¢   rm   r   Úget_containing_type_infor6   r7   r<   Úunannotatedr8   Ú	arg_kindsr   r
   Ú	arg_typesr  r?  r¾   )	r^   rq   r¾   r¹   ÚdefaultÚtÚsetterÚ
super_infoÚsetter_types	            rR   rp  z8PydanticModelTransformer._infer_dataclass_attr_init_type  sG  € ð
 —(‘(ˆØ�<Š<ØˆNÜ˜CŸH™HÓ%ˆô ˜!œXÔ&ØˆNØ—‘—‘˜IÓ&ˆÚÜ˜&Ÿ+™+¤wÔ/ØŸV™V×<Ñ<¸YÓG�
Ù!Ð!�zØ—;’;Ü"1Ô2IÈ&Ï+É+ÐWX×W]ÑW]Ð_iÓ2jÓ"k‘Kä"¤9×#8Ñ#8Ó9Ð9Ü˜k¬<Ô8¸[×=RÑ=RÜÜÜðWò >ô
 3°;×3HÑ3HÈÑ3KÈQÓOÐOà—I‘I—N‘NÐ%MÈaÏfÉfÏkÉkÈ]ÐZ[Ð#\Ð^eÔfð ˆð —	‘	—‘Ð!;¸A¿F¹F¿K¹K¸=ÈÐJÈGÔTàˆrT   c           
     ó  — d| j                   j                  j                  v r.| j                   j                  j                  d   j                  sy| j                  j
                  }t        |j                  «      }|j                  du}t        |j                  xr |j                   «      }| j                  |||||||d¬«      }	|�r7| j                  j                  t        «      j                  }
t        |
t         «      sJ ‚d|
j                  v rî|
j                  d   j                  }t        |t"        «      sJ ‚|�Á|j$                  �µ|j$                  }t        |t&        «      sJ ‚t)        |j*                  «      D ]  \  }}|�"|j-                  d«      s|j-                  d«      sŒ+| j                  j/                  |j0                  |   «      }t3        ||«      }|	j5                  t7        ||dt8        «      «       Œ� | j;                  ||«      sCt3        d«      }|	j5                  t7        |t=        t>        j@                  «      dtB        «      «       tE        | j                  | j                   d|	tG        «       ¬«       y)	z§Adds a fields-aware `__init__` method to the class.

        The added `__init__` will be annotated with types vs. all `Any` depending on the plugin settings.
        r]   NT)rÕ   rÖ   Úrequires_dynamic_aliasesrØ   r  r  rÙ   Ú__Ú_Úkwargs)râ   Úreturn_type)$r	  r‰   r'  Úplugin_generatedrY   rš   rœ   rÊ   r  r@  Úget_field_argumentsr  rk   r  rm   rl   r)   r   rŒ   r8   r-  r#  Ú
startswithÚ	anal_typerz  r*   Úappendr   r   Úshould_init_forbid_extrar7   r<   rÓ   r   Ú
add_methodr:   )r^   r  rª   r  r  rÕ   rÖ   rØ   r�  râ   Úbase_settings_nodeÚbase_settings_init_nodeÚ	func_typeÚarg_idxrJ  Úanalyzed_variable_typerÎ   Úvars                     rR   r  z(PydanticModelTransformer.add_initializer5  s'  € ð ˜Ÿ™Ÿ™×-Ñ-Ñ-°d·i±i·n±n×6JÑ6JÈ:Ñ6V×6gÒ6gØà×"Ñ"×-Ñ-ˆÜ˜FŸM™MÓ*ˆØ×+Ñ+°4Ð7ˆ	Ü#'¨×(BÑ(BÒ(bÈ6×KbÑKbÐGbÓ#cÐ Ø×'Ñ'ØØØ%Ø%=ØØ#Ø'Ø%)ð (ó 	
ˆò Ø!%§¡×!AÑ!AÔBWÓ!X×!]Ñ!]ÐÜÐ0´(Ô;Ð;Ð;ØÐ/×5Ñ5Ñ5Ø*<×*BÑ*BÀ:Ñ*N×*SÑ*SÐ'Ü!Ð"9¼7ÔCÐCÐCØ*Ð6Ð;R×;WÑ;WÐ;cØ 7× <Ñ <�IÜ% i´Ô>Ð>Ð>Ü-6°y×7JÑ7JÖ-KÑ)˜ Ø#Ð+¨x×/BÑ/BÀ4Ô/HÐPX×PcÑPcÐdgÔPhØ$Ø15·±×1DÑ1DÀY×EXÑEXÐY`ÑEaÓ1bÐ.Ü#& xÐ1GÓ#H˜ØŸ™¤H¨XÐ7MÈtÔU\Ó$]Õ^ð .Lð ×,Ñ,¨V°VÔ<Ü�h“-ˆCØ�K‰Kœ ¤g¬i×.@Ñ.@Ó&AÀ4ÌÓSÔTä�4—9‘9˜dŸi™i¨¸$ÌHËJÖWrT   c           
     ó  — | j                   j                  t        › d�| j                   j                  t        › d�«      g«      }t        |t	        «       g«      }t        t        d|«      |dt        «      }t        j                  | j                   j                  j                  «      5  | j                  |dt        |j                  «      dd||¬«      }ddd«       | j                  ||«      sCt        d«      }	j!                  t        |	t#        t$        j&                  «      dt(        «      «       |r|gz   n|gz   }t+        | j                   | j,                  d	|t/        | j,                  j0                  «      d¬
«       y# 1 sw Y   Œ¯xY w)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à   r_   rá   r‡  rœ   rÊ   r‹  rŠ  r7   r<   rÓ   r   rŒ  r	  rA   r‰   )
r^   r  rª   r  r  Úset_strÚoptional_set_strÚfields_set_argumentrâ   r’  s
             rR   r  z3PydanticModelTransformer.add_model_construct_methodd  sT  € ð —)‘)×&Ñ&¬-¨¸Ð'=ÀÇ	Á	×@TÑ@TÔXeÐWfÐfjÐUkÓ@lÐ?mÓnˆÜ$ g¬x«zÐ%:Ó;ÐÜ&¤s¨=Ð:JÓ'KÐM]Ð_cÔelÓmÐÜ×&Ñ& t§y¡y×'8Ñ'8×'HÑ'HÕIØ×+Ñ+ØØÜ! &§-¡-Ó0Ø).ØØ'Ø+ð ,ó ˆD÷ Jð ×,Ñ,¨V°VÔ<Ü�h“-ˆCØ�K‰Kœ ¤g¬i×.@Ñ.@Ó&AÀ4ÌÓSÔTá/<ˆtÐ*Ð+Ò+ÐCVÐBWÐZ^ÑB^ˆäØ�I‰IØ�I‰IØØÜ% d§i¡i§n¡nÓ5Øö	
÷! JÐIús   Â),FÆFc                ó   — | j                   j                  }|D �]H  }|j                  j                  |j                  «      }|�´|j
                  }t        |t        «      r|xs |j                  |_	        Œ]t        |t        «      r1| j                  j                  s| j                  j                  «        Œž	 t        |«      }d|› d|j"                  › d�}	t%        |	| j                  | j                   «       Œß|j'                  ||d¬«      }||_        ||_	        |j(                  dz   |j                  z   |_        t-        t.        |«      |j                  |j                  <   �ŒK y# t        $ r t!        |«      }Y Œ¹w xY w)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.
        Nzsym_node.node: r²   r³   F)rØ   Ú.)r	  r‰   r'  r¢   r¾   rm   rl   r*   rÇ   Úis_propertyr"   r  Úfinal_iterationÚdeferr‘   Ú	TypeErrorÚreprr`   r¸   rÒ   rd   Ú	_fullnamer&   r   )
r^   r  rƒ   r  r‰   r  rY  r’  Úvar_strrÁ   s
             rR   r  z#PydanticModelTransformer.set_frozenŒ  s)  € ð
 �y‰y�~‰~ˆÜˆEØ—z‘z—~‘~ e§j¡jÓ1ˆHØÐ#Ø—m‘m�Ü˜c¤3Ô'Ø&,Ò&?°·±�C•OÜ ¤_Ô5¸d¿i¹i×>WÒ>Wà—I‘I—O‘OÕ%ð,Ü"% c£(˜ð  /¨w¨i°zÀ#Ç-Á-ÀÐPQÐR�FÜ-¨f°d·i±iÀÇÁÕKà—l‘l 4¨¸�lÓ>�Ø�”Ø"(�”Ø $§¡°Ñ 3°c·h±hÑ >�”Ü'6´t¸SÓ'A�—
‘
˜3Ÿ8™8Ó$ñ/ øô %ò ,ä"& s£)šð,ús   Â8E&Å&E=Å<E=c                óþ  — || j                   vry|dk(  rft        |t        «      r|j                  dk(  }n:t        |t        «      r|j
                  dk(  }n|st        || j                  |«       yt        |¬«      S |dk(  r/d}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                  |«       y)zÐDetermines the config update due to a single kwarg in the ConfigDict definition.

        Warns if a tracked config attribute is set to a value the plugin doesn't know how to interpret (e.g., an int)
        Nr  Úforbid)Úforbid_extrar  Túbuiltins.NoneF)r@  )úbuiltins.Trueúbuiltins.Falser©  r°   )r  rl   r%   r$  r   r¾   Úerror_invalid_config_valuer  r5  r    rd   )r^   r¾   ræ   r2  r§  r@  s         rR   r8  z*PydanticModelTransformer.get_config_update«  sê   € ð
 �t×1Ñ1Ñ1ØØ�7Š?Ü˜#œwÔ'Ø"Ÿy™y¨HÑ4‘Ü˜C¤Ô,Ø"Ÿx™x¨8Ñ3‘á ô /¨t°T·Y±YÀÔDØÜ"°Ô=Ð=ØÐ$Ò$Ø"&ÐÜ˜#œxÔ(¨S¯\©\¸_Ò-LØ&+Ð#Ü"Ð7JÔKÐKÜ�cœ8Ô$¨¯©Ð9\Ñ)\Ü"ÑM d¨C¯L©L¸OÑ,KÐ%LÑMÐMÜ" 4¨¯©°CÔ8ØrT   c                óÆ  — | j                   }t        |t        «      ryt        |t        «      r¤t        |j                  t
        «      rŠ|j                  j                  t        k(  rmt        |j                  |j                  «      D ]I  \  }}|�|dk(  r|j                  t        uc S |dk(  sŒ't        |t        «      xr |j                  dk(   c S  yt        |t        «       S )zUReturns a boolean indicating whether the field defined in `stmt` is a required field.Fr{  Údefault_factoryr¨  )r=  rl   r'   r   r*  r#   rd   ÚFIELD_FULLNAMEr>  râ   r#  r`   r   r    ©rH  rF  ræ   r¾   s       rR   ri  z(PydanticModelTransformer.get_has_defaultÎ  s¹   € ð �{‰{ˆÜ�dœHÔ%àÜ�dœHÔ%¬*°T·[±[Ä'Ô*JÈtÏ{É{×OcÑOcÔguÒOuô
 ! §¡¨D¯N©NÖ;‘	��Tà�< 4¨9Ò#4ØŸ=™=´Ð<Ò<ØÐ,Ó,Ü *¨3´Ó 9Ò ]¸c¿l¹lÈoÑ>]Ð^Ò^ð <ð ä˜d¤LÓ1Ð1Ð1rT   c                ól  — | j                   }t        |t        «      r˜t        |j                  t        «      r~|j                  j
                  t        k(  rat        |j                  |j                  «      D ]>  \  }}|dk7  rŒt        |t        «      r"|j
                  dk(  r y|j
                  dk(  r y y y)zEReturns a the `strict` value of a field if defined, otherwise `None`.rÊ   r©  Trª  FN)r=  rl   r   r*  r#   rd   r®  r>  râ   r#  r    r¯  s       rR   rj  z#PydanticModelTransformer.get_strictä  s�   € ð �{‰{ˆÜ�dœHÔ%¬*°T·[±[Ä'Ô*JÈtÏ{É{×OcÑOcÔguÒOuÜ  §¡¨D¯N©NÖ;‘	��TØ˜8Ò#ØÜ˜c¤8Ô,Ø—|‘| Ò6Ù#ØŸ™Ð)9Ò9Ù$Ùð <ð rT   c                ót  — | j                   }t        |t        «      ryt        |t        «      r7t        |j                  t
        «      r|j                  j                  t        k(  syt        |j                  «      D ];  \  }}|dk7  rŒ|j                  |   }t        |t        «      r|j                  dfc S  y y)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=  rl   r'   r   r*  r#   rd   r®  r-  r#  râ   r%   r$  ©rH  rF  r%  rJ  ræ   s        rR   rn  z'PydanticModelTransformer.get_alias_infoô  s�   € ð �{‰{ˆÜ�dœHÔ%àô �tœXÔ&¬:°d·k±kÄ7Ô+KÐPT×P[ÑP[×PdÑPdÔhvÒPvð ä$ T§^¡^Ö4‰KˆAˆxØ˜7Ò"ØØ—)‘)˜A‘,ˆCÜ˜#œwÔ'Ø—y‘y %Ð'Ò'á!ð 5ð rT   c                óv  — | j                   }t        |t        «      ryt        |t        «      r7t        |j                  t
        «      r|j                  j                  t        k(  syt        |j                  «      D ]<  \  }}|dk(  sŒ|j                  |   }t        |t        «      xr |j                  dk(  c S  y)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=  rl   r'   r   r*  r#   rd   r®  r-  r#  râ   r    r²  s        rR   ro  z(PydanticModelTransformer.is_field_frozen  s™   € ð �{‰{ˆÜ�dœHÔ%àô �tœXÔ&¬:°d·k±kÄ7Ô+KÐPT×P[ÑP[×PdÑPdÔhvÒPvð ä$ T§^¡^Ö4‰KˆAˆxØ˜8Ó#Ø—i‘i ‘l�Ü! #¤xÓ0ÒT°S·\±\À_Ñ5TÒTð 5ð rT   c	                óâ   — | j                   j                  }	|D �
cg c]H  }
|r|
j                  s8|
j                  |	|||xs ||| j                  ||xr |
j
                  dk(  ¬«      ‘ŒJ }}
|S c c}
w )zÈHelper function used during the construction of the `__init__` and `model_construct` method signatures.

        Returns a list of mypy Argument instances for use in the generated signatures.
        rO  )rÕ   rÖ   r×   rØ   rƒ   rÙ   rÚ   )r	  r‰   rÈ   rÛ   r  r¾   )r^   r  rÕ   rÖ   rØ   r�  r  r  rÙ   r‰   r  Ú	argumentss               rR   r‡  z,PydanticModelTransformer.get_field_arguments)  sŽ   € ð �y‰y�~‰~ˆñ  ó
ñ  �Ù %×"9Ò"9ð ×ÑØØØ)Ø7ÒF¸;Ø#Ø—I‘IØ)AØ#0Ò#I°U·Z±ZÀ6Ñ5Ið õ 	ð  ð 	ð 
ð Ðùò
s   ›AA,c                ó¬   — |j                   s&| j                  |t        |j                  «      «      ry|j                  ry| 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œ   r@  r§  rY   r™   )r^   r  rª   s      rR   r‹  z1PydanticModelTransformer.should_init_forbid_extraI  sI   € ð ×&Ò&Ø×,Ñ,¨V´T¸&×:TÑ:TÓ5UÔVØØ×ÒØØ×!Ñ!×3Ñ3Ð3rT   c                ó\   — | D ]  }|j                   sŒ y |r| D ]  }|j                  �Œ y y)z‘Returns whether any fields on the model have a "dynamic alias", i.e., an alias that cannot be
        determined during static analysis.
        TF)rÈ   rÆ   )r  r@  r  s      rR   r·  z1PydanticModelTransformer.is_dynamic_alias_presentV  s;   € ó
 ˆEØ×&Ó&Ùð ñ Û�Ø—;‘;Ñ&Ùð  ð rT   N)
r�   r   r‚   zExpression | Statementrƒ   r1   rY   rX   r�   r�   )r�   rœ   )r�   r�   )r�   r5  )r1  r5  r  rœ   r�   zJtuple[list[PydanticModelField] | None, list[PydanticModelClassVar] | None])rH  r   r�   úIterator[AssignmentStmt])rb  r   r�   r¹  )rH  r   r1  r5  r  z dict[str, PydanticModelClassVar]r�   z1PydanticModelField | PydanticModelClassVar | None)rq   r&   r¾   r‘   r¹   r   r�   rø   )
r  úlist[PydanticModelField]rª   r5  r  rœ   r  rœ   r�   r�   )r  rº  rƒ   r1   r  rœ   r�   r�   rù   )r¾   r‘   ræ   r   r2  rœ   r�   úModelConfigData | None)rH  r   r�   rœ   )rH  r   r�   rö   )rH  r   r�   ztuple[str | None, bool])r  rº  rÕ   rœ   rÖ   rœ   rØ   rœ   r�  rœ   r  rœ   r  rœ   rÙ   rœ   r�   úlist[Argument])r  rº  rª   r5  r�   rœ   )r  rº  r@  rœ   r�   rœ   )r“   r”   r•   r–   r  r¯   r]   r„   r  r  r  r`  rR  rS  rp  r  r  r  r8  Ústaticmethodri  rj  rn  ro  r‡  r‹  r·  r°   rT   rR   r€   r€   ”  s  … ñò'Ð˜8ó ð+àð+ð 'ð+ð -ð	+ð
 ,ð+ð 
ó+ó"óH2ó6JðXBLØ+ðBLØ<@ðBLà	SóBLóHRóSð
Ø"ð
Ø2Að
ØOoð
à	:ó
óB$ðL-XØ.ð-XØ8Gð-XØVZð-XØkoð-Xà	ó-Xð^&
à(ð&
ð  ð&
ð ð	&
ð
 ð&
ð 
ó&
óPBô>!ðF ò2ó ð2ð* òó ðð òó ðð6 òó ððB */ðà(ðð ðð ð	ð
 ðð #'ðð ðð ðð #'ðð 
óó@4ð òó ñrT   r€   c                  óT   — e Zd ZdZ	 	 	 	 	 	 d	 	 	 	 	 	 	 	 	 	 	 dd„Zd	d„Zd
d„Zdd„Zy)r5  z(Pydantic mypy plugin model config class.Nc                óX   — || _         || _        || _        || _        || _        || _        y rW   )r§  r  rµ   r  r@  rÊ   )r^   r§  r  rµ   r  r@  rÊ   s          rR   r]   zModelConfigData.__init__h  s2   € ð )ˆÔØˆŒØ.ˆÔØ 0ˆÔØ#6ˆÔ Øˆ�rT   c                óp   — | j                   j                  «       D ��ci c]  \  }}|€Œ	||“Œ c}}S c c}}w )z†Returns a dict of Pydantic model config names to their values.

        It includes the config if config value is not `None`.
        )Ú__dict__r7  )r^   ÚkÚvs      rR   r  zModelConfigData.get_values_dictx  s7   € ð
 "&§¡×!4Ñ!4Ô!6ÔHÑ!6™˜˜A¸!¹-��1‘Ð!6ÒHÐHùÓHs   ž
2©2c                óp   — |€y|j                  «       j                  «       D ]  \  }}t        | ||«       Œ y)z$Update Pydantic model config values.N)r  r7  r¥   )r^   rª   rÂ  rÃ  s       rR   r9  zModelConfigData.update  s6   € àˆ>ØØ×*Ñ*Ó,×2Ñ2Ö4‰DˆAˆqÜ�D˜!˜QÕñ 5rT   c                ó8   — t        | |«      €t        | ||«       yy)zFSet default value for Pydantic model config if config value is `None`.N)r‹   r¥   )r^   r«   r$  s      rR   rC  zModelConfigData.setdefault†  s    € ä�4˜ÓÐ%Ü�D˜#˜uÕ%ð &rT   )NNNNNN)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  r9  rC  r°   rT   rR   r5  r5  e  sh   „ Ù2ð %)Ø"Ø'+Ø(,Ø+/Ø"ðà!ðð ðð %ð	ð
 &ðð )ðð óó Ió ô&rT   r5  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 subclassc                ó<   — |j                  d| › d�|t        ¬«       y)zCEmits an error when the model does not have `from_attributes=True`.ru  z$" does not have from_attributes=True©ÚcodeN)r?  Ú	ERROR_ORM)Ú
model_namerƒ   r¹   s      rR   r½   r½   •  s   € à‡H�Hˆq��Ð@ÐAÀ7ÔQZ€HÕ[rT   c                ó<   — |j                  d| › d�|t        ¬«       y)z0Emits an error when the config value is invalid.zInvalid value for "Config.ru  rÈ  N)r?  ÚERROR_CONFIG)r¾   rƒ   r¹   s      rR   r«  r«  š  s   € à‡H�HÐ)¨$¨¨qÐ1°7Ä€HÕNrT   c                ó4   — | j                  d|t        ¬«       y)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¹   s     rR   rA  rA  Ÿ  s   € ð
 ‡H�HÐ2°GÄ+€HÕNrT   c                óV   — d}d| › d�}|d|› d�z  }|j                  ||t        ¬«       y)z Emits unexpected behavior error.z6https://github.com/pydantic/pydantic/issues/new/choosez7The pydantic mypy plugin ran into unexpected behavior: Ú
z&Please consider reporting this bug at z so we can try to fix it!rÈ  N)r?  ÚERROR_UNEXPECTED)rÁ   rƒ   r¹   ÚlinkÚfull_messages        rR   r¸   r¸   §  sA   € ð
 D€DØLÈVÈHÐTVÐW€LØÐ<¸T¸FÐB[Ð\Ñ\€LØ‡H�Hˆ\˜7Ô)9€HÕ:rT   c                ó4   — | j                  d|t        ¬«       y)z;Emits an error when there is an untyped field in the model.zUntyped fields disallowedrÈ  N)r?  ÚERROR_UNTYPEDrÐ  s     rR   rg  rg  ²  s   € à‡H�HÐ(¨'¼€HÕFrT   c                ó4   — | j                  d|t        ¬«       y)z]Emits an error when there is more than just a root field defined for a subclass of RootModel.z2Only `root` is allowed as a field of a `RootModel`rÈ  N)r?  ÚERROR_EXTRA_FIELD_ROOT_MODELrÐ  s     rR   rT  rT  ·  s   € à‡H�HÐAÀ7ÔQm€HÕnrT   c                óD  — |j                   }||j                  v rd|j                  |   }	|	j                  rIt        |	j                  t
        «      r/|j                  j                  j                  |	j                  «       t        | t        «      r| j                  d«      }
n| j                  dg «      }
|r6|xs t        t        |«      «      }t        t        d«      |dt         d«      g}n+|xs t        |«      }t        t        d«      |dt         «      g}||z   }g g g }}}|D ]p  }|j"                  sJ d«       ‚|j%                  |j"                  «       |j%                  |j&                  j(                  «       |j%                  |j*                  «       Œr t-        |||||
«      }|r|g|_        t        ||t1        t3        «       g«      «      }||_         t5        ||«      |_        ||_        |j:                  dz   |z   |_        |j>                  |_        ||j                  v r2tA        ||j                  «      }|j                  |   |j                  |<   |rud|_!        t        ||j6                  «      }||_         |j<                  |_        d|_"        tG        |tI        d«      g|«      }|j>                  |_        tK        tL        |«      }	ntK        tL        |«      }	d|	_        |	|j                  |<   |jN                  j                  j                  j%                  |«       y)	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‰   r'  r†  rl   rm   r   r:  r;  Úremover1   r—  Únamed_generic_typer=   rA   r   r*   r   rÏ   rŠ  rÎ   r¾   rÑ   r8   Ú	variablesr   r!   r3   rŒ   r/  rd   r£  rË   rB   Úis_decoratedr–  r   r    r&   r   Údefn)rƒ   r�   r¾   râ   r…  rß   Útvar_defr–  r‰   rq   Úfunction_typeÚfirstrz  r#  ry  ræ   Ú	signaturer.  Úr_namerÃ  Údecs                        rR   rŒ  rŒ  ¼  sž  € ð �8‰8€Dð ˆt�z‰zÑØ�j‰j˜ÑˆØ×Ò¤J¨s¯x©x¼Ô$AØ�H‰H�M‰M× Ñ  §¡Ô*ä�#Ô6Ô7ØŸ™Ð':Ó;‰à×.Ñ.Ð/BÀBÓGˆáØÒ>¤¬-¸Ó*=Ó!>ˆ	Üœ#˜f›+ y°$¼ÀÓFÐG‰àÒ4¤¨tÓ!4ˆ	ô œ#Ð1Ó2°I¸tÄWÓMÐNˆØ�4‰<€Dà&(¨"¨b˜)ˆy€IÛˆØ×"Ò"ÐHÐ$HÓHÐ"Ø×Ñ˜×,Ñ,Ô-Ø×Ñ˜Ÿ™×*Ñ*Ô+Ø×Ñ˜Ÿ™Õ"ð	 ô ˜Y¨	°9¸kÈ=ÓY€IÙØ'˜jˆ	Ôä�4˜œu¤h£j \Ó2Ó3€DØ€D„IÜ! )¨TÓ2€D„IØ"€D„MØ—]‘] SÑ(¨4Ñ/€D„NØ—	‘	€D„Ið ˆt�z‰zÑä-¨d°D·J±JÓ?ˆØ!ŸZ™Z¨Ñ-ˆ�
‰
�6Ññ
 Ø ˆÔÜ��d—i‘iÓ ˆØˆŒØ—n‘nˆŒØˆÔÜ˜œx¨Ó6Ð7¸Ó;ˆØ—9‘9ˆŒÜœd CÓ(‰äœd DÓ)ˆØ€CÔØ€D‡J�JˆtÑà‡I�I‡N�N×Ñ×Ñ˜tÕ$rT   c                ó  — | j                  d«      syt        j                  dk\  rddl}n	 ddl}t        | d«      5 }|j                  |«      cddd«       S # t
        $ r ddl}|j                  d«       Y yw xY w# 1 sw Y   yxY w)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`.Úrb)
ry   ÚsysÚversion_infoÚtomllibÚtomliÚImportErrorÚwarningsÚwarnÚopenÚload)r    Útoml_rð  Úrfs       rR   r¡   r¡     s|   € ð
 ×Ñ Ô(Øä
×Ñ˜7Ò"Üð	Û!ô 
ˆk˜4Ô	  BØ�z‰z˜"‹~÷ 
!Ñ	 øô ò 	Ûà�M‰MÐfÔgÙð		ú÷ 
!Ð	 ús   ¬A ¼A;ÁA8Á7A8Á;B)rQ   r‘   r�   ztype[Plugin])r}   r.   r�   r;   )rË  r‘   rƒ   r,   r¹   r   r�   r�   )r¾   r‘   rƒ   r1   r¹   r   r�   r�   )rƒ   r1   r¹   r   r�   r�   )rÁ   r‘   rƒ   z8CheckerPluginInterface | SemanticAnalyzerPluginInterfacer¹   r   r�   r�   )rƒ   r,   r¹   r   r�   r�   )NNF)rƒ   z8SemanticAnalyzerPluginInterface | CheckerPluginInterfacer�   r   r¾   r‘   râ   r¼  r…  r;   rß   rø   rá  zTypeVarType | Noner–  rœ   r�   r�   )r    r‘   r�   zdict[str, Any] | None)|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   Úmypy.plugins.commonr2   Úmypy.semanalr3   Úmypy.server.triggerr4   Ú
mypy.stater5   Úmypy.typeopsr6   Ú
mypy.typesr7   r8   r9   r:   r;   r<   r=   r>   r?   r@   Úmypy.typevarsrA   Ú	mypy.utilrB   Úmypy.versionrC   Úmypy_versionÚpydantic._internalrD   Úpydantic.versionrE   r¨   r¼   re   r  r  rt   r®  ÚDATACLASS_FULLNAMEr,  r+  ÚMYPY_VERSION_TUPLEr˜  rS   rP   rX   rz   rÄ   rý   r€   r5  rÊ  rÍ  rÏ  rÓ  r×  ÚERROR_FIELD_DEFAULTSrÙ  r½   r«  rA  r¸   rg  rT  rŒ  r¡   r°   rT   rR   Ú<module>r     sf  ðÙ då "ã 
Ý %ß *Ñ *å %ß @÷!÷ !÷ !÷ !÷ !÷ !÷ !÷ !ó !õD !÷÷ õõ +Ý 5Ý Ý 0÷÷ ÷ õ (Ý 2Ý 4å &Ý /à €Ø'€Ø.Ð Ø=Ð Ø5Ð ØRÐ Ø(€Ø5Ð ØKÐ òÐ ñ (¨Ó5Ð Ø€ð €óô3@�Vô 3@÷l+Cñ +Có\#÷4ATñ AT÷H
ñ 
÷2Nñ N÷b$&ñ $&ñN �nÐ&DÀjÓQ€	ÙÐ*Ð,BÀJÓO€ÙÐ(Ð*DÀjÓQ€ÙÐ2Ð4IÈ:ÓVÐ ÙÐ*Ð,FÈ
ÓS€Ù Ð!1Ð3KÈZÓXÐ Ù(Ð)9Ð;^Ð`jÓkÐ ó\ó
Oó
Oð;Øð;ØNð;ØY`ð;à	ó;óGó
oð "Ø#'Ø ðU%Ø	AðU%à	ðU%ð ðU%ð ð	U%ð
 ðU%ð ðU%ð !ðU%ð ðU%ð 
óU%ôprT   