
     h                       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
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/m0Z0m1Z1 dd
l2m3Z3 ddl4m5Z5m6Z6m7Z7m8Z8m9Z9m: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 Zeh d!Zfefd"hz
  Zg e\eX      Zhd#Zid$ZWdKd%Zj G d& d'e8      Zk G d( d)      ZldLd*Zm G d+ d,      Zn G d- d.      Zo G d/ d0      Zp G d1 d2eD      Zq G d3 d4      ZrdMd5Zs ed6d7d8      Zt ed9d:d8      Zu ed;d<d8      Zv ed=d>d8      Zw ed?d@d8      Zx ed?dAd8      Zy ed?dBd8      ZzdNdCZ{dOdDZ|dPdEZ}	 	 	 	 	 	 	 	 dQdFZ~dPdGZdRdHZ	 	 	 dS	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 dTdIZdUdJZy)Vz^This module includes classes and functions designed specifically for use with the mypy plugin.    )annotationsN)Iterator)ConfigParser)AnyCallablecast)	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)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_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_validator3pydantic.deprecated.class_validators.root_validatorrI   0pydantic.functional_serializers.model_serializerrN   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    [/var/www/dev.core.comfenalco.cic-ware.com/crm/lib/python3.12/site-packages/pydantic/mypy.pypluginrU   m   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 )rR   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     rT   r_   zPydanticPlugin.__init__   s4    1': ..668!rV   c                    | j                  |      }|rEt        |j                  t              r+|j                  j	                  t
              r| j                  S y)zUpdate Pydantic model class.N)lookup_fully_qualified
isinstancenoder*   has_baseBASEMODEL_FULLNAME$_pydantic_model_class_maker_callback)r`   fullnamesyms      rT   get_base_class_hookz"PydanticPlugin.get_base_class_hook   sD    ))(3:chh1xx  !34@@@rV   c                .    |t         k(  r| j                  S y)z,Update Pydantic `ModelMetaclass` definition.N)MODEL_METACLASS_FULLNAME)_pydantic_model_metaclass_marker_callbackr`   rj   s     rT   get_metaclass_hookz!PydanticPlugin.get_metaclass_hook   s    //AAArV   c                2    |j                  d      rt        S y)z-Adjust return type of `from_orm` method call.z	.from_ormN)endswithfrom_attributes_callbackrp   s     rT   get_method_hookzPydanticPlugin.get_method_hook   s    [)++rV   c                    | j                   S )zjReturn all plugin config data.

        Used by mypy to determine if cache needs to be discarded.
        )r]   )r`   ctxs     rT   report_config_dataz!PydanticPlugin.report_config_data   s    
    rV   c                    t        |j                  |j                  |j                  | j                        }|j                          y rY   )PydanticModelTransformerclsreasonapir[   	transform)r`   rw   transformers      rT   ri   z3PydanticPlugin._pydantic_model_class_maker_callback   s0    .sww

CGGTM_M_`rV   c                    | j                   j                  ry|j                  j                  j                  }|sJ d       t        |j                  dd      rd|j                  _        yy)zReset dataclass_transform_spec attribute of ModelMetaclass.

        Let the plugin handle it. This behavior can be disabled
        if 'debug_dataclass_transform' is set to True', for testing purposes.
        Nz-callback not passed from 'get_metaclass_hook'dataclass_transform_spec)r[   debug_dataclass_transformr{   infodeclared_metaclassgetattrtyper   )r`   rw   info_metaclasss      rT   ro   z8PydanticPlugin._pydantic_model_metaclass_marker_callback   s^     7788NNN~>&&(BDI;?N8 JrV   ra   r,   returnNone)rj   strr   z(Callable[[ClassDefContext], None] | None)rj   r   r   z&Callable[[MethodContext], Type] | None)rw   r1   r   dict[str, Any])rw   r.   r   r   )__name__
__module____qualname____doc__r_   rl   rq   ru   rx   ri   ro   __classcell__rb   s   @rT   rR   rR   |   s*    #"
! @rV   rR   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
)rZ   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toolrH   Fz/Configuration value must be a boolean for key: )fallback)config_file
parse_tomlget	__slots__re   r   
ValueErrorsetattrr   read
getbooleanCONFIGFILE_KEY)r`   ra   toml_configconfigkeysettingr[   s          rT   r_   zPydanticPluginConfig.__init__   s    & !4!45" __VR044_bIF~~ , **S%0!'40$'VWZV[%\]]c7+	, )NMw223~~ ,'22>3QV2Wc7+,rV   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     rT   r\   zPydanticPluginConfig.to_data   s&    37>>BCWT3''BBBs   &Nr   r   r   )r   r   r   r   r   __annotations__r_   r\    rV   rT   rZ   rZ      s3    I #''##,&CrV   rZ   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 |j                   j!                  t"              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 )r   from_attributesT)r   re   r?   itemr:   ret_typer;   rb   r   error_unexpected_behaviorr}   contextdefault_return_typemetadatar   METADATA_KEYrg   rh   error_from_attributesname)rw   ctx_type
model_typedetailpydantic_metadatar   s         rT   rt   rt      s0    xxH(H%==(L)j9J9JH.U&&
	Hh	'
hZz(2D2D2M2M1NaP!&#''3;;?&&&"0044\B &&&??##$67&&&'++Hb9==>OPOd"joo22CGGS[[I"""rV   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 rY   )
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              rT   r_   zPydanticModelField.__init__   sL     	
"!2&			rV   c	                4   | j                  ||||      }	| j                  |n| j                  }
|s|
r| j                  ||d      }nt        t        j
                        }t        |	|d|rt              S |s| j                  rt              S t              S )zABased on mypy.plugins.dataclasses.DataclassAttribute.to_argument.NT)include_root_type)variabletype_annotationinitializerkind)to_varr   r
   r9   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               rT   to_argumentzPydanticModelField.to_argument  s     ;;|S)=UV!%!4$++F"..|STX.YO%i&8&89O+! 	
 	
 $2T5E5E-
 	
 LU
 	
rV   c                \   |rFt        | j                  t              r,| j                  j                         }t        |_        || _        | j                  5| 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      }|ret        |t              rUt#        |j                        r@t%        t&        |j                  d   j                        }	t)        |	|      }
t+        ||
g      }|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root)re   r   r@   copy_modifiedr   variancer   	self_typer6   strict_optional_setra   strict_optionalrC   r;   argsr
   idis_root_modelr   r=   r   rA   )r`   r   r}   r   r   modified_typefilled_with_typevarsargexpanded_type	root_typeexpanded_root_types              rT   r
   zPydanticModelField.expand_type2  s_    $
 $))[1 $		 7 7 9)2&)	99 TYY%8%8%D
 **3;;+F+FG %'4\'B$!"6AAA+388 5%c;7+4CL5 !,DII		8K8K8N8NPd7e f$M8)LQ^_l_q_qQr !%T=+=+=f+E+J+J KI)@M)Z&$-}>P.Q$RM$!% %" yy#%" yys   ?FB+FF+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         rT   r   zPydanticModelField.to_var\  s?     /::D99D4)),=UVWWrV   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    rT   r   zPydanticModelField.serializek  sd    yyyIIZZ!%!7!7++kkIIkkII'')

 
	
rV   c                n    |j                         }t        |j                  d      |      } | d||d|S )ABased on mypy.plugins.dataclasses.DataclassAttribute.deserialize.r   )r   r   r   )copyr3   pop)r{   r   datar}   typs        rT   deserializezPydanticModelField.deserializez  s9     yy{(&)93?/$/$//rV   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   r6   r   ra   r   r8   r   )r`   sub_typer}   s      rT   expand_typevar_from_subtypez.PydanticModelField.expand_typevar_from_subtype  sb     99 **3;;+F+FG T3DIIxS	T T !T T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}   r2   r   r   r   r   r   r   )FF)
r   r*   r}   r2   r   r   r   r   r   r   F)
r   r*   r}   r2   r   r   r   r   r   r+   r   r   )r   r*   r   r   r}   r2   r   r   )r   r*   r}   r2   r   r   )r   r   r   r   r_   r   r
   r   r   classmethodr   r   r   rV   rT   r   r      sg   ?  	
        0

 
 	

 
 
 -
 #'
 !
 

B */"'(( -( #'	(
  ( 
(^ */XX -X 	X
 #'X 
X
 0 0TrV   r   c                  0    e Zd ZdZd Zedd       ZddZy)PydanticModelClassVarzBased on mypy.plugins.dataclasses.DataclassAttribute.

    ClassVars are ignored by subclasses.

    Attributes:
        name: the ClassVar name
    c                    || _         y rY   r   )r`   r   s     rT   r_   zPydanticModelClassVar.__init__  s	    	rV   c                2    |j                         } | di |S )r   r   )r   )r{   r   s     rT   r   z!PydanticModelClassVar.deserialize  s     yy{{T{rV   c                    d| j                   iS )r   r   r   r   s    rT   r   zPydanticModelClassVar.serialize  s     DII
 	
rV   N)r   r   r   r   r   )r   r   r   r   r_   r   r   r   r   rV   rT   r   r     s%      

rV   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)-rz   zTransform the BaseModel subclass according to the plugin settings.

    Attributes:
        tracked_config_fields: A set of field configs that the plugin has to track their value.
    >   extrafrozenr   alias_generatorr   populate_by_namevalidate_by_namevalidate_by_aliaszset[str]tracked_config_fieldsc                <    || _         || _        || _        || _        y rY   )_cls_reason_apir[   )r`   r{   r|   r}   r[   s        rT   r_   z!PydanticModelTransformer.__init__  s!     		*rV   c                   | j                   j                  }t        |      }| j                         }| j	                  ||      \  }}||y|D ]  }|j
                   y |j                  t              }| 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
        FT)r  )fields
class_varsr   )r  r   r   collect_configcollect_fields_and_class_varsr   rg   BASESETTINGS_FULLNAMEadd_initializeradd_model_construct_method
set_frozenr  r  adjust_decorator_signaturesr   r   get_values_dictr   r   )	r`   r   is_a_root_modelr   r  r  fieldis_settings	class_vars	            rT   r~   z"PydanticModelTransformer.transform  s9    yy~~'-$$&!??X
>Z/ 	Ezz!	 mm$9:VV[/J''_U		&--42GH((* CIIuzz5??#44IR\]Y9>>9+>+>+@@],,.'
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_namesre   r&   value).0ir   	first_decs      rT   	<genexpr>zGPydanticModelTransformer.adjust_decorator_signatures.<locals>.<genexpr>  sO        &3 &//2f<rCQXAYr^a^g^gkr^rr s   AATN)r  r   namesvaluesre   rf   r   original_decoratorsr   calleer!   rj   (IMPLICIT_CLASSMETHOD_DECORATOR_FULLNAMESMODEL_VALIDATOR_FULLNAMEany	enumerater   funcis_class)r`   rk   r%  s     @rT   r  z4PydanticModelTransformer.adjust_decorator_signatures  s     99>>''..0 	2C#((I.HH88;	y(3"9#3#3X>!((115]] "((115MM  *3INN*C   .2CHHMM*#	2rV   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 nt        |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|rR|rP|j0                  rD|j2                  s8|j4                  s,| j6                  j8                  rt;        | j,                  |       |j<                  j>                  d	d D ]  }t@        |jB                  vr| j,                  jE                  tG        |jH                               |jB                  t@           d
   j                         D ]  \  }}|jK                  ||         |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bodyre   r   r   lvaluesr!   r   rvaluer   zipr!  r   r   r&   r"  r  failhas_alias_generatorr  r  r[   r   error_required_dynamic_aliasesr   mror   r   add_plugin_dependencyr5   rj   
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                    rT   r  z'PydanticModelTransformer.collect_config  s   ii "!$)! ,,,,. 	+JD$00t<K$(!k*		+ "&HHMM &	-Dd^X$>?$/ll1o!#x0CHH4Ndkk84),T[[-B-BDKKDTDT)U ]##+$d&<&<XsVZ&<&[\]  X6040A0A Z,*)(G<$d&<&<X^^Z&XYZ
 D(+99(#yy~~ TG%g~> !//!,C%c84 MM$"8"87>>"RST !		o (,%M&	-P  9..00F4K4K&&DD.tyy$?HHLL$ 	/D4==0 II++,A$--,PQ#}}\:8DJJL /e!!$./	/ rV   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.r5  r  z7BaseModel field may only be overridden by another fieldr  r   r   ) r  reversedr   rC  r   r   r  rD  r5   rj   r8  r   r   r   r'  r   rf   re   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`   r2  r   r{   found_fieldsfound_class_varsr   r   r   r  sym_nodecurrent_field_namescurrent_class_vars_namesrJ  maybe_fieldrK  s                   rT   r  z6PydanticModelTransformer.collect_fields_and_class_varsM  si    ii 79=?SXX\\!B/0 	QD 4==0 II++,A$--,PQ"mmL9(CIIK 
d*66tT499M
 11#((DIIF%*T"88>>--d3jPS6TIINNQ   #mmL9,GMMO Q
d)>)J)J4)P &Q5	Q< ),-0U >>sxxH 	9DCCD,XhiK",,q/Cc8,,,+'9: SXX%74TYYE'++CHH5-8L*K)>?(,,SXX6-8 *	9" L'')*D1A1H1H1J,KKKrV   c              #    K   |j                   D ](  }|j                  r| j                  |      E d {    * |j                  ;|j                  j                  s$| j                  |j                        E d {    y y y 7 N7 	wrY   )r<  is_unreachablerT  	else_body)r`   rJ  r<  s      rT   ,_get_assignment_statements_from_if_statementzEPydanticModelTransformer._get_assignment_statements_from_if_statement  s{     II 	LD&&EEdKKK	L >>%dnn.K.KAA$..QQQ /L% LQs'   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rY   )r<  re   r   r   rb  )r`   blockrJ  s      rT   rT  z>PydanticModelTransformer._get_assignment_statements_from_block  sN     JJ 	SD$/
D&)LLTRRR		S Ss   5AAAAc                4   | j                   }|j                  d   }t        |t              r.t	        j
                  |j                        r|j                  dk(  ry|j                  st        |j                  t              rt        |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                        |_        |j<                  r|	rt1        |j                        S | jI                  |      \  }}|rD|jJ                  s8|jL                  s,| jN                  jP                  rtS        | j                  |       | jU                  |      }| jW                  ||j                  |      }tY        |j                  ||	|
|||jZ                  |j\                  ||j                  

      S )a^  Get pydantic model field from statement.

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

        Returns:
            A pydantic model field if it could find the field in statement. Otherwise, `None`.
        r   r2  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=  re   r!   rF   is_valid_field_namer   
new_syntaxr>  r   r*  rj   DECORATOR_FULLNAMESerror_untyped_fieldsr  r   r'  r   rf   r#   r)   r@  r+   is_classvarr   rB   r   r;   get_has_default
get_strictrf  is_inferredanalyze_simple_literal_typer9   r>   
from_errorget_alias_infor  r  r[   r   rB  is_field_frozen_infer_dataclass_attr_init_typer   r   r   )r`   rJ  r2  r  r{   rK  rk   rf   	node_typer   r   r   r   r   r   	init_types                   rT   rU  z=PydanticModelTransformer.collect_field_or_class_var_from_stmt  s%    iill1o#x(0K0KCHH0UY\YaYaesYs4;;1t{{118<t{{1188(CKK&&--66:MM
 xx:% !D1ll1o#x(**3884N8Rhhnn  *; xxdO,
 dI&IINNX $$
  (22 $DII.	i*y~~/F/FJ_/_IINN7
 **40&88$2B2B ))77d7SC			] $I$8$89	==[(22#'#6#6t#<  !22l6S6S""@@*499d;((.	88chhM	!/#;;
 	
rV   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__rP   z(Unsupported signature for "__set__" in ""zUnsupported "__set__" in ")r   implicitrB   re   r;   r   rf   r   get_containing_type_infor8   r9   r>   unannotatedr:   	arg_kindsr   r   	arg_typesr  r@  r   )	r`   rk   r   r   defaulttsetter
super_infosetter_types	            rT   rs  z8PydanticModelTransformer._infer_dataclass_attr_init_type(  sG   
 ((<<NCHH% !X&NI&&++w/VV<<YG
!!z;;"12I&++WXW]W]_i2j"kK"9#8#899k<8[=R=RW >
 3;3H3H3KQOOIINN%Maffkk]Z[#\^ef  		!;AFFKK=JGTrV   c           
        d| j                   j                  j                  v r.| j                   j                  j                  d   j                  sy| j                  j
                  }t        |j                        }|j                  xs |j                   xr |j                  du}t        |j                  xr |j                         }| j                  |||||||d      }	|rg| 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 ]  \  }}|"|j1                  d      s|j1                  d      s+| j                  j3                  |j4                  |         }|-|dk(  r(|j7                  t9        t:        j<                              }t?        ||      }|	jA                  tC        ||dtD                      | jG                  ||      sCt?        d	      }|	jA                  tC        |tI        t:        jJ                        dtL                     tO        | j                  | j                   d|	tQ               
       y)zAdds a fields-aware `__init__` method to the class.

        The added `__init__` will be annotated with types vs. all `Any` depending on the plugin settings.
        r_   NFT)r   r   requires_dynamic_aliasesr   r  r   r   ____cli_settings_sourcekwargs)r   return_type))r  r   r'  plugin_generatedr[   r   r   r   r  r  r  rA  get_field_argumentsr  rd   r  rf   re   r*   r   r   r:   r.  r!  
startswith	anal_typer}  acceptChangeExplicitTypeOfAnyr>   from_omitted_genericsr+   appendr   r   should_init_forbid_extrar9   r   r   
add_methodr<   )r`   r  r   r  r   r   r   r   r  r   base_settings_nodebase_settings_init_node	func_typearg_idxrL  analyzed_variable_typer   vars                     rT   r  z(PydanticModelTransformer.add_initializerN  sz    ---diinn6J6J:6V6g6g""--FMM*00KF4K4KLvQWQiQiqvQv	#'(B(B(b6KbKbGb#c ''%%=#'%) ( 	
 !%!A!ABW!X!]!]0(;;;/555*<*B*B:*N*S*S'!"97CCC*6;R;W;W;c 7 < <I%i>>>-6y7J7J-K _)#+x/B/B4/HPXPcPcdgPh$151D1DYEXEXY`Ea1b.1=(NdBd 6L5R5R 7	8W8W X62 $'x1G#HHX7MtU\$]^_ ,,VV<h-CKKgi.@.@&A4ST499dii$HJWrV   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)zAdds a fully typed `model_construct` classmethod to the class.

        Similar to the fields-aware __init__ method, but always uses the field names (not aliases),
        and does not treat settings fields as optional.
        z.setz.str_fields_setNTF)r   r   r  r   r  r   r  model_construct)r   r  is_classmethod)r  
named_typeBUILTINS_NAMErA   r<   r   r+   r   r6   r   ra   r   r  r   r   r  r  r9   r>   r   r   r  r  rC   r   )
r`   r  r   r  r   set_stroptional_set_strfields_set_argumentr   r  s
             rT   r  z3PydanticModelTransformer.add_model_construct_method  sY    ))&&-'=		@T@TXeWffjUk@l?mn$gxz%:;&s=:J'KM]_celm&&tyy'8'8'H'HI 		++!&--0).'+ , D		 ,,VV<h-CKKgi.@.@&A4ST/<t*++CVBWZ^B^IIII%diinn5	
!		 		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)zMarks all fields as properties so that attempts to set them trigger mypy errors.

        This is the same approach used by the attrs and dataclasses plugins.
        Nzsym_node.node: r   r   F)r   .)r  r   r'  r   r   rf   re   r+   r   is_propertyr#   r  final_iterationdeferr   	TypeErrorreprrb   r   r   rj   	_fullnamer'   r   )
r`   r  r}   r  r   r  r[  r  var_strr   s
             rT   r  z#PydanticModelTransformer.set_frozen  s0   
 yy~~ 	BEzz~~ejj1H#mmc3'&,&?CO_5dii>W>WIIOO%,"%c(  /wiz#--PQRF-fdiiKll4l>"( $ 3chh >'6tS'A

388$/	B % ,"&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)zDetermines the config update due to a single kwarg in the ConfigDict definition.

        Warns if a tracked config attribute is set to a value the plugin doesn't know how to interpret (e.g., an int)
        Nr  forbid)forbid_extrar  Tbuiltins.NoneF)rA  )builtins.Truebuiltins.Falser  r   )r	  re   r&   r"  r    r   error_invalid_config_valuer  r6  r!   rj   )r`   r   r   r3  r  rA  s         rT   r9  z*PydanticModelTransformer.get_config_update  s    
 t1117?#w'"yyH4C,"xx83  /tTYYD"==$$"&#x(S\\_-L&+#"7JKKc8$9\)\"MdCLLO,K%LMM"4C8rV   c                   | j                   }t        |t              ryt        |t              rt        |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>  re   r(   r   r*  r$   rj   FIELD_FULLNAMEr?  r   r!  rb   r   r!   rJ  rH  r   r   s       rT   rl  z(PydanticModelTransformer.get_has_default  s     {{dH%dH%*T[['*Jt{{OcOcguOu
 !DNN; _	T<49#4==<<,, *3 9 ]cllo>]^^_ dL111rV   c                l   | j                   }t        |t              rt        |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>  re   r   r*  r$   rj   r  r?  r   r!  r!   r  s       rT   rm  z#PydanticModelTransformer.get_strict  s     {{dH%*T[['*Jt{{OcOcguOu DNN; 	T8#c8,||6#)99$ rV   c                   | j                   }t        |t              ryt        |t              r7t        |j                  t
              r|j                  j                  t        k(  syd|j                  v r)|j                  |j                  j                  d         }n8d|j                  v r)|j                  |j                  j                  d         }nyt        |t              r|j                  dfS 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.
        )NFvalidation_aliasr   F)NT)r>  re   r(   r   r*  r$   rj   r  r!  r   indexr&   r"  )rJ  rH  r   s      rT   rq  z'PydanticModelTransformer.get_alias_info  s     {{dH% tX&:dkk7+KPTP[P[PdPdhvPv /))DNN001CDEC&))DNN009:Cc7#99e##rV   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>  re   r(   r   r*  r$   rj   r  r.  r!  r   r!   )rJ  rH  r$  rL  r   s        rT   rr  z(PydanticModelTransformer.is_field_frozen2  s     {{dH% tX&:dkk7+KPTP[P[PdPdhvPv $T^^4 	UKAx8#iil!#x0TS\\_5TT	U rV   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 )zHelper function used during the construction of the `__init__` and `model_construct` method signatures.

        Returns a list of mypy Argument instances for use in the generated signatures.
        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  	argumentss               rT   r  z,PydanticModelTransformer.get_field_argumentsK  s     yy~~  
 %"9"9 )7F;#II)A#0#IUZZ65I  	
	 
 
s   AA,c                    |j                   s2|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  r  is_dynamic_alias_presentr   rA  r  r[   r   )r`   r  r   s      rT   r  z1PydanticModelTransformer.should_init_forbid_extrak  sQ     ''6+B+B,,VT&:T:T5UV!!333rV   c                \    | D ]  }|j                   s y |r| D ]  }|j                   y y)zReturns 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  rA  r  s      rT   r  z1PydanticModelTransformer.is_dynamic_alias_presentx  sE    
  	E&&	   ;;&  rV   N)
r{   r   r|   zExpression | Statementr}   r2   r[   rZ   r   r   )r   r   )r   r   )r   r6  )r2  r6  r   r   r   zJtuple[list[PydanticModelField] | None, list[PydanticModelClassVar] | None])rJ  r   r   Iterator[AssignmentStmt])rd  r   r   r  )rJ  r   r2  r6  r  z dict[str, PydanticModelClassVar]r   z1PydanticModelField | PydanticModelClassVar | None)rk   r'   r   r   r   r   r   r   )
r  list[PydanticModelField]r   r6  r  r   r   r   r   r   )r  r  r}   r2   r  r   r   r   r   )r   r   r   r   r3  r   r   ModelConfigData | None)rJ  r   r   r   )rJ  r   r   r   )rJ  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   r6  r   r   )r  r  rA  r   r   r   )r   r   r   r   r	  r   r_   r~   r  r  r  rb  rT  rU  rs  r  r  r  r9  staticmethodrl  rm  rq  rr  r  r  r  r   rV   rT   rz   rz     s   	'8 	++ '+ -	+
 ,+ 
+"H26JXBL+BL<@BL	SBLHRSG
"G
2AG
OoG
	:G
R$L4X.4X8G4XVZ4Xko4X	4Xl&
(&
  &
 	&

 &
 
&
PB>!F 2 2*    :  B */(  	
  #'   #' 
@4  rV   rz   c                  ,     e Zd ZdZd fdZddZ xZS )r  z<A type translator used to change type of Any's, if explicit.c                0    || _         t        | 	          y rY   )_type_of_anyr^   r_   )r`   type_of_anyrb   s     rT   r_   z ChangeExplicitTypeOfAny.__init__  s    'rV   c                x    |j                   t        j                  k(  r|j                  | j                        S |S )N)r  )r  r>   r   r   r  )r`   r  s     rT   	visit_anyz!ChangeExplicitTypeOfAny.visit_any  s0    ==I...??t/@/@?AAHrV   )r  r   r   r   )r  r9   r   r=   )r   r   r   r   r_   r  r   r   s   @rT   r  r    s    FrV   r  c                  `    e Zd ZdZ	 	 	 	 	 	 	 	 d	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 ddZd	dZd
dZddZy)r6  z(Pydantic mypy plugin model config class.Nc	                t    || _         || _        || _        || _        || _        || _        || _        || _        y rY   )r  r  r   r  r  r  rA  r   )	r`   r  r  r   r  r  r  rA  r   s	            rT   r_   zModelConfigData.__init__  sB     ). 0!2 0#6 rV   c                p    | j                   j                         D ci c]  \  }}|	|| c}}S c c}}w )zReturns a dict of Pydantic model config names to their values.

        It includes the config if config value is not `None`.
        )__dict__r8  )r`   kvs      rT   r  zModelConfigData.get_values_dict  s1    
 "&!4!4!6HA!-1HHHs   
22c                p    |y|j                         j                         D ]  \  }}t        | ||        y)z$Update Pydantic model config values.N)r  r8  r   )r`   r   r  r  s       rT   r:  zModelConfigData.update  s;    >**,224 	 DAqD!Q	 rV   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      rT   rE  zModelConfigData.setdefault  s     4%D#u% &rV   )NNNNNNNN)r  r   r  r   r   r   r  r   r  r   r  r   rA  r   r   r   r   )r   r  r   r   )r   r   r"  r   r   r   )r   r   r   r   r_   r  r:  rE  r   rV   rT   r6  r6    s    2 %)"'+(,)-(,+/"!  %	
 & ' & ) (I &rV   r6  c                ,    | j                  t              S )zXReturn whether the type info is a root model subclass (or the `RootModel` class itself).)rg   ROOT_MODEL_FULLNAME)r   s    rT   r   r     s    ==,--rV   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`.rx  z$" does not have from_attributes=TruecodeN)r@  	ERROR_ORM)
model_namer}   r   s      rT   r   r     s    HHq@A7QZH[rV   c                <    |j                  d|  d|t               y)z0Emits an error when the config value is invalid.zInvalid value for "Config.rx  r  N)r@  ERROR_CONFIG)r   r}   r   s      rT   r  r    s    HH)$q17HNrV   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     rT   rB  rB    s    
 HH2G+HNrV   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        rT   r   r     sA    
 DDLVHTVWL<TFB[\\LHH\7)9H:rV   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     rT   rj  rj    s    HH('HFrV   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     rT   rV  rV    s    HHA7QmHnrV   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  re   rf   r   r;  r<  remover2   r  named_generic_typer?   rC   r   r+   r   r   r  r   r   r   r:   	variablesr   r"   r4   r   r0  rj   r  r   rD   is_decoratedr  r   r!   r'   r   defn)r}   r{   r   r   r  r   tvar_defr  r   rk   function_typefirstr}  r!  r|  r   	signaturer/  r_namer  decs                        rT   r  r    s    88D tzzjjJsxx$AHHMM  *#67':;../BBG>-*=!>	#f+y$FG4t!4	 #12ItWMN4<D&("b)yI #""H$HH",,-**+"	# Y	9k=YI'j	4uhj\23DDI!)T2DI"DM]]S(4/DN		DI tzz-dDJJ?!ZZ-

6
  dii nnx67;99dC(dD)CDJJtIINNt$rV   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)zReturns a dict of config keys to values.

    It reads configs from toml file and returns `None` if the file is not a toml file.
    z.tomlN)      r   zJNo TOML parser installed, cannot read configuration from `pyproject.toml`.rb)
rs   sysversion_infotomllibtomliImportErrorwarningswarnopenload)r   toml_r   rfs       rT   r   r   M  s    
 (
7"	! 
k4	  Bzz"~   	MMfg		 s   A A;A87A8;B)rS   r   r   ztype[Plugin])rw   r/   r   r=   )r   r*   r   r   )r  r   r}   r-   r   r   r   r   )r   r   r}   r2   r   r   r   r   )r}   r2   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  collections.abcr   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/   r0   r1   r2   mypy.plugins.commonr3   mypy.semanalr4   mypy.server.triggerr5   
mypy.stater6   mypy.type_visitorr7   mypy.typeopsr8   
mypy.typesr9   r:   r;   r<   r=   r>   r?   r@   rA   rB   mypy.typevarsrC   	mypy.utilrD   mypy.versionrE   mypy_versionpydantic._internalrF   pydantic.versionrG   r   r   rh   r  r  rn   r  DATACLASS_FULLNAMEr,  ri  r+  MYPY_VERSION_TUPLEr  rU   rR   rZ   rt   r   r   rz   r  r6  r   r  r  r  r  r  ERROR_FIELD_DEFAULTSr  r   r  rB  r   rj  rV  r  r   r   rV   rT   <module>r     s   d " 
 $ % & & % @! ! ! ! ! ! ! ! !D !  + 5  , 0   ( 2 4 & / '. = 5 R (5 K   ,?BtAu+u ( (5  3@V 3@l+C +C\#4MT MT`
 
2a aHn (& (&V.
 n&DjQ	*,BJO(*DjQ24I:V *,F
S !13KZX ()9;^`jk \
O
O;;N;Y`;	;G
o "#' U%	AU%	U% U% 	U%
 U% U% !U% U% 
U%prV   