U EZh. @sddZddlmZddlZddlmZddlmZmZm Z ddl m Z ddl m Z mZddlmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZm 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/dd l0m1Z1dd l2m3Z3m4Z4m5Z5m6Z6m7Z7m8Z8dd l9m:Z:dd l;mZ>ddl?m@Z@ddlAmBZBddlCmDZDmEZEmFZFmGZGmHZHmIZImJZJmKZKmLZLmMZMddlNmOZOddlPmQZQddlRmSZTddlUmVZVddlWmXZXdZYdZZdZ[dZ\dZ]dZ^dZ_dZ`dZaddd d!d"d#hZbeXeTZcd$Zdd%ZSd&d'd(d)d*ZeGd+d,d,e6ZfGd-d.d.Zgd/d0d1d2d3ZhGd4d5d5ZiGd6d7d7ZjGd8d9d9ZkGd:d;d;Zle dZme d?d@d>Zne dAdBd>Zoe dCdDd>Zpe dEdFd>Zqe dEdGd>Zre dEdHd>Zsd&dIdJdKdLdMdNZtd&dOdJdKdPdQdRZudOdJdKdSdTdUZvd&dVdJdKdWdXdYZwdOdJdKdSdZd[ZxdIdJdKdSd\d]Zydld_d`d&dad0dbdcdddKde dfdgZzd&dhdidjdkZ{dS)mz^This module includes classes and functions designed specifically for use with the mypy plugin.) annotationsN) ConfigParser)AnyCallableIterator) ErrorCode) expand_typeexpand_type_by_instance) ARG_NAMED ARG_NAMED_OPTARG_OPTARG_POS ARG_STAR2 INVARIANTMDEFArgumentAssignmentStmtBlockCallExprClassDefContext DecoratorDictExpr EllipsisExpr ExpressionFuncDefIfStmtJsonDict MemberExprNameExprPassStmtPlaceholderNodeRefExpr StatementStrExprSymbolTableNodeTempNode TypeAliasTypeInfoVar)Options)CheckerPluginInterfaceClassDefContext MethodContextPluginReportConfigContextSemanticAnalyzerPluginInterface)deserialize_and_fixup_type)set_callable_name)make_wildcard_trigger)state)map_type_from_supertype) AnyType CallableTypeInstanceNoneTypeType TypeOfAnyTypeType TypeVarType UnionTypeget_proper_type) fill_typevars)get_unique_redefinition_name) __version__)_fields)parse_mypy_version pydantic-mypyzpydantic-mypy-metadatazpydantic.main.BaseModelz#pydantic_settings.main.BaseSettingszpydantic.root_model.RootModelz5pydantic._internal._model_construction.ModelMetaclasszpydantic.fields.Fieldzpydantic.dataclasses.dataclassz.pydantic.functional_validators.model_validatorz.pydantic.functional_validators.field_validatorz*pydantic.functional_serializers.serializerz0pydantic.functional_serializers.model_serializerz.pydantic.deprecated.class_validators.validatorz3pydantic.deprecated.class_validators.root_validatorbuiltinsstrz type[Plugin])versionreturncCstS)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)rIrLT/home/aprabhat/apps/x.techxrdev.in/venv/lib/python3.8/site-packages/pydantic/mypy.pypluginjs rNcseZdZdZdddfdd Zddd d d Zddd d d Zddd ddZdddddZdddddZ dddddZ Z S)rKzThe Pydantic mypy plugin.r*NoneoptionsrJcs&t||_|j|_t|dSN)PydanticPluginConfig plugin_configto_data _plugin_datasuper__init__)selfrQ __class__rLrMrX|s  zPydanticPlugin.__init__rHz(Callable[[ClassDefContext], None] | None)fullnamerJcCs:||}|r6t|jtr6tdd|jjDr6|jSdS)zUpdate Pydantic model class.css|]}|jtkVqdSrRr\BASEMODEL_FULLNAME.0baserLrLrM sz5PydanticPlugin.get_base_class_hook..N)lookup_fully_qualified isinstancenoder(anymro$_pydantic_model_class_maker_callback)rYr\symrLrLrMget_base_class_hooks  z"PydanticPlugin.get_base_class_hookcCs|tkr|jSdS)z,Update Pydantic `ModelMetaclass` definition.N)MODEL_METACLASS_FULLNAME)_pydantic_model_metaclass_marker_callbackrYr\rLrLrMget_metaclass_hooksz!PydanticPlugin.get_metaclass_hookz&Callable[[MethodContext], Type] | NonecCs|drtSdS)z-Adjust return type of `from_orm` method call.z .from_ormN)endswithfrom_attributes_callbackrmrLrLrMget_method_hooks zPydanticPlugin.get_method_hookr/dict[str, Any]ctxrJcCs|jS)zjReturn all plugin config data. Used by mypy to determine if cache needs to be discarded. )rV)rYrtrLrLrMreport_config_datasz!PydanticPlugin.report_config_datar,cCs"t|j|j|j|j}|dSrR)PydanticModelTransformerclsreasonapirT transform)rYrtZ transformerrLrLrMrhsz3PydanticPlugin._pydantic_model_class_maker_callbackcCs<|jjr dS|jjj}|s"tdt|jddr8d|j_dS)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) rTdebug_dataclass_transformrwinfoZdeclared_metaclassAssertionErrorgetattrtyper{)rYrtZinfo_metaclassrLrLrMrls   z8PydanticPlugin._pydantic_model_metaclass_marker_callback) __name__ __module__ __qualname____doc__rXrjrnrqrurhrl __classcell__rLrLrZrMrKys rKc@sTeZdZUdZdZded<ded<ded<ded<dd d d d Zd dddZdS)rSaA 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_typedwarn_required_dynamic_aliasesr|boolrrrr|r*rOrPcCs|jdkrdSt|j}|dk rr|didi}|jD]4}||d}t|tsbtd|t|||q:n:t}| |j|jD] }|j t |dd}t|||qdS)NZtoolrEFz/Configuration value must be a boolean for key: )fallback) config_file parse_tomlget __slots__rdr ValueErrorsetattrrread getbooleanCONFIGFILE_KEY)rYrQZ toml_configconfigkeyZsettingrTrLrLrMrXs       zPydanticPluginConfig.__init__rrrJcsfddjDS)z/Returns a dict of config names to their values.csi|]}|t|qSrL)r)r`rrYrLrM sz0PydanticPluginConfig.to_data..)rrrLrrMrUszPydanticPluginConfig.to_dataN)rrrrr__annotations__rXrUrLrLrLrMrSs  rSr-r:rscCs|j}t|tr|j}t|tr4t|jtr4|j}n.rfrom_attributesT)rrdr<itemr7Zret_typer8r[rerror_unexpected_behaviorrycontextZdefault_return_typemetadatar METADATA_KEYrfrgerror_from_attributesname)rtZctx_typeZ model_typedetailZpydantic_metadatarrLrLrMrps&  rpc @seZdZdZddddddddddd d d Zdddddd ddd d ddZd%dd dddddZd&dd ddddddZddddZe ddd ddddZ dd d d!d"d#Z d$S)'PydanticModelFieldz5Based on mypy.plugins.dataclasses.DataclassAttribute.rHz str | Noner bool | Noneint Type | Noner( ralias is_frozenhas_dynamic_alias has_defaultstrictlinecolumnrr}c Cs@||_||_||_||_||_||_||_||_| |_| |_ dSrRr) rYrrrrrrrrrr}rLrLrMrXs zPydanticModelField.__init__r0r) current_infotyped model_strictforce_optional use_aliasryforce_typevars_invariantis_root_model_rootrJc Csj|||||} |jdkr|n|j} |s,| r:|||} n ttj} t| | d|rTtn|s^|jrbt nt dS)zABased on mypy.plugins.dataclasses.DataclassAttribute.to_argument.N)variabletype_annotationZ initializerkind) to_varrrr6r;explicitrr rr r ) rYrrrrrryrrrrrrLrLrM to_arguments  zPydanticModelField.to_argumentF)rryrrJc Cs|r&t|jtr&|j}t|_||_|jdk r|jjdk rt |j j Zt |}t|t sbt|r|jD]}t|trlt|_qlt|j|jjj|iW5QRSQRX|jS)zABased on mypy.plugins.dataclasses.DataclassAttribute.expand_type.N)rdrr=Z copy_modifiedrZvariancer} self_typer4strict_optional_setrQstrict_optionalr@r8r~argsrid)rYrryrZ modified_typeZfilled_with_typevarsargrLrLrMr/s    (zPydanticModelField.expand_typer))rryrrrJcCs0|r|jdk r|j}n|j}t|||||S)z.NFcss|]}|jtkVqdSrR)r\BASESETTINGS_FULLNAMEr_rLrLrMrbsT)rcSsi|]}|j|qSrLrrr`fieldrLrLrMrsz6PydanticModelTransformer.transform..cSsi|]}|j|qSrLr)r`Z class_varrLrLrMrs)fields class_varsr)rr}rfrgcollect_configcollect_fields_and_class_varsradd_initializeradd_model_construct_method set_frozenrradjust_decorator_signaturesget_values_dictrr)rYr} is_root_modelrrrr is_settingsrLrLrMrzs&     z"PydanticModelTransformer.transformcs|jjjD]p}t|jtr|jjdttrtj t rj j t krj j t krttfddtjDsd|jj_qdS)aWhen 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`. rc3s4|],\}}j|dko*t|to*|jdkVqdS)modeafterN) arg_namesrdr$value)r`irZ first_decrLrMrbszGPydanticModelTransformer.adjust_decorator_signatures..TN)rr}namesvaluesrdrerZoriginal_decoratorsrcalleerr\DECORATOR_FULLNAMESMODEL_VALIDATOR_FULLNAMErf enumeraterfuncis_class)rYrirLrrMrs       z4PydanticModelTransformer.adjust_decorator_signaturesModelConfigDatac CsL|j}t}d}d}|jD]&\}}|||}|rd}||qd}|jjD]V}t|t t fshqRt|t r"|j d} t| t rR| j dkrqRt|jtrt|jj|jjD](\} } | dkrq||j| | ddqnBt|jtr|jjD]*\} } t| ts q||| j| qnjt|t r|j dkrPydanticModelTransformer._get_assignment_statements_from_blockrz dict[str, PydanticModelClassVar]z1PydanticModelField | PydanticModelClassVar | None)r rrrJc CsD|j}|jd}t|tr0t|jr0|jdkr4dS|jst|jt rxt|jj t rxt|jj j trx|jj j j t krxdS|j|krdSt |j|dS|jd}t|tsdSt|jr|jdkrdS|jj|j}|dkrdS|j}t|trdSt|tr|jd|dSt|ts&dS|jr8t|jSt|j}t|trj|jj dkrj|jd|||} ||} |jdkr|jr|jr|jj |jdd} | r| |_n|jd |t!t"j#|_|$|\} } | r|j%s|j&j'rt(|j||)|}|*||j|}t+|j| | | | ||j,|j-||jd 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`. rrNzFType aliases inside BaseModel definitions are not supported at runtimezdataclasses.InitVarz%InitVar is not supported in BaseModelT)is_finalzGNeed type argument for Final[...] with non-literal default in BaseModel) rrrrrrrrrr}).rrrdrrCZis_valid_field_namerZ new_syntaxrrrr\rerror_untyped_fieldsrr}rrrer!r'rr)Z is_classvarrr?rr8get_has_default get_strictrZ is_inferredZanalyze_simple_literal_typer6r;Z from_errorget_alias_inforrTrris_field_frozen_infer_dataclass_attr_init_typerrr)rYr rrrwr rireZ node_typerrrrrrZ init_typerLrLrMrs                    z=PydanticModelTransformer.collect_field_or_class_var_from_stmtr%rHrr)rirrrJc Cs|j}|jr|St|j}t|ts(|S|jd}|rt|jtr|jd}|sXt |jrttt |j|j|}n t t j St|tr|jtttgkrt|jd|S|jd|jjd|n|jd|jjd||S)zvInfer __init__ argument type for an attribute. In particular, possibly use the signature of __set__. __set__rGz(Unsupported signature for "__set__" in ""zUnsupported "__set__" in ")rZimplicitr?rdr8rrerZget_containing_type_infor~r5r6r;Z unannotatedr7 arg_kindsr r arg_typesrrr) rYrirrdefaulttsetterZ super_infoZ setter_typerLrLrMrs.      z8PydanticModelTransformer._infer_dataclass_attr_init_typezlist[PydanticModelField])rrrrrJc Csd|jjjkr"|jjjdjs"dS|jj}t|j}|jdk }t|j oL|j }|j |||||||dd} |r@|j t j} t| tstd| jkr@| jdj} t| tst| dk r@| jdk r@| j} t| tstt| jD]X\} }|dks|ds|dsq|j | j| }t||}| t||dtq|||sptd}| t|tt j!dt"t#|j |jd| t$ddS) 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. rXNT)rrrequires_dynamic_aliasesrrrr___kwargs)r return_type)%rr}rplugin_generatedrTrrrrrget_field_argumentsrrcrrerdr(r~rrr7rr startswithZ anal_typer"r)appendrr should_init_forbid_extrar6r;rr add_methodr9)rYrrrrrrrr&rZbase_settings_nodeZbase_settings_init_nodeZ func_typeZarg_idxr Zanalyzed_variable_typervarrLrLrMr5sF      z(PydanticModelTransformer.add_initializerc Cs|jtd|jtdg}t|tg}ttd||dt}t |jj j $|j |dt |jdd||d}W5QRX|||std} |t| ttjdt|r||gn|g|}t|j|jd |t|jjdd dS) 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.strZ _fields_setNTF)rrr&rrrr)Zmodel_construct)rr*is_classmethod)r named_type BUILTINS_NAMEr>r9rr)r r4rrQrr,rrr/r.r6r;rrr0rr@r}) rYrrrrZset_strZoptional_set_strZfields_set_argumentrr1rLrLrMrds2 $  z3PydanticModelTransformer.add_model_construct_method)rryrrJc Cs|jj}|D]}|j|j}|dk r|j}t|trD|p>|j|_ qt|t rb|j j sb|j qz t|}Wntk rt|}YnXd|d|jd} t| |j |jq |j||dd}||_||_ |jd|j|_tt||j|j<q dS)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. Nzsym_node.node: rrF)r.)rr}rrrrerdr)rZ is_propertyr!rZfinal_iterationZdeferrH TypeErrorreprr[rrr\ _fullnamer%r) rYrryrr}rrr1Zvar_strrrLrLrMrs(   z#PydanticModelTransformer.set_frozenFrModelConfigData | None)rrrrJcCs||jkrdS|dkrbt|tr,|jdk}n,t|trB|jdk}n|sTt||j|dSt|dS|dkrd}t|t r|j dkrd}t|d St|t r|j d krtf||j d kiSt||j|dS) 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) NrZforbid) forbid_extrarT builtins.NoneF)r) builtins.Truebuiltins.Falser<) rrdr$rrrerror_invalid_config_valuerrrr\)rYrrrr:rrLrLrMrs(        z*PydanticModelTransformer.get_config_updatecCs|j}t|trdSt|trt|jtr|jjtkrt|j |j D]H\}}|dks\|dkrj|j t k S|dkrDt|t o|jdk SqDdSt|t  S)zUReturns a boolean indicating whether the field defined in `stmt` is a required field.FNr#default_factoryr;)rrdr&rrr"r\FIELD_FULLNAMErrrr[rrr r rrrLrLrMrs "z(PydanticModelTransformer.get_has_defaultrcCs||j}t|trxt|jtrx|jjtkrxt|j|j D]@\}}|dkrHq6t|t rr|jdkrbdS|jdkrrdSdSdS)zEReturns a the `strict` value of a field if defined, otherwise `None`.rr<Tr=FN) rrdrrr"r\r@rrrrrArLrLrMrs"   z#PydanticModelTransformer.get_strictztuple[str | None, bool]cCs|j}t|trdSt|tr6t|jtr6|jjtks:dSt|j D]:\}}|dkrVqD|j |}t|t rx|j dfSdSqDdS)aReturns 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. )NFrF)NT) rrdr&rrr"r\r@rrrr$rr r rr rrLrLrMrs$     z'PydanticModelTransformer.get_alias_infocCs||j}t|trdSt|tr6t|jtr6|jjtks:dSt|j D]2\}}|dkrD|j |}t|t op|jdkSqDdS)alReturns 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(frozen=True)` sense; this does not determine whether the field is frozen because the entire model is frozen; that is handled separately. Frr<) rrdr&rrr"r\r@rrrrrBrLrLrMrs    z(PydanticModelTransformer.is_field_frozenlist[Argument]) rrrrr&rrrrJc s.jjf dd|D} | S)zHelper function used during the construction of the `__init__` and `model_construct` method signatures. Returns a list of mypy Argument instances for use in the generated signatures. c s@g|]8}r|js|jp"jo6|jdkdqS)r )rrrrryrr)rrrrr rr}rrrr&rYrrrLrM 9s  z@PydanticModelTransformer.get_field_arguments..)rr}) rYrrrrr&rrr argumentsrLrDrMr,)s  z,PydanticModelTransformer.get_field_arguments)rrrJcCs.|js||t|jrdS|jr&dS|jjS)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)ris_dynamic_alias_presentrrr:rTr)rYrrrLrLrMr/Is z1PydanticModelTransformer.should_init_forbid_extra)rrrJcCs8|D]}|jrdSq|r4|D]}|jdkrdSqdS)zReturns whether any fields on the model have a "dynamic alias", i.e., an alias that cannot be determined during static analysis. TNF)rr)rrrrLrLrMrGVs z1PydanticModelTransformer.is_dynamic_alias_presentN)F)F)rrrrrrrXrzrrrrrrrrrrr staticmethodrrrrr,r/rGrLrLrLrMrvsF   $LD&/(#!  rvc@sZeZdZdZddddddddddZddd d Zd d d ddZddd dddZdS)rz(Pydantic mypy plugin model config class.Nrr:rrrrrcCs(||_||_||_||_||_||_dSrRrI)rYr:rrrrrrLrLrMrXhs zModelConfigData.__init__rrrcCsdd|jDS)zReturns a dict of Pydantic model config names to their values. It includes the config if config value is not `None`. cSsi|]\}}|dk r||qSrRrL)r`kvrLrLrMr}sz3ModelConfigData.get_values_dict..)__dict__rrrLrLrMrxszModelConfigData.get_values_dictr9rO)rrJcCs2|dkr dS|D]\}}t|||qdS)z$Update Pydantic model config values.N)rrr)rYrrJrKrLrLrMrszModelConfigData.updaterHr)rrrJcCst||dkrt|||dS)zFSet default value for Pydantic model config if config value is `None`.N)rr)rYrrrLrLrMrszModelConfigData.setdefault)NNNNNN)rrrrrXrrrrLrLrLrMresrz pydantic-ormzInvalid from_attributes callZPydanticzpydantic-configzInvalid config valuezpydantic-aliaszDynamic alias disallowedzpydantic-unexpectedzUnexpected behaviorzpydantic-fieldzUntyped field disallowedzInvalid Field defaultsz!Extra field on RootModel subclassr+rrO) model_nameryrrJcCs|jd|d|tddS)zCEmits an error when the model does not have `from_attributes=True`.r z$" does not have from_attributes=TruecodeN)r ERROR_ORM)rMryrrLrLrMrsrr0)rryrrJcCs|jd|d|tddS)z0Emits an error when the config value is invalid.zInvalid value for "Config.r rNN)r ERROR_CONFIG)rryrrLrLrMr>sr>)ryrrJcCs|jd|tddS)znEmits required dynamic aliases error. This will be called when `warn_required_dynamic_aliases=True`. z#Required dynamic aliases disallowedrNN)r ERROR_ALIASryrrLrLrMrsrz8CheckerPluginInterface | SemanticAnalyzerPluginInterface)rryrrJcCs4d}d|d}|d|d7}|j||tddS)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!rNN)rERROR_UNEXPECTED)rryrlinkZ full_messagerLrLrMrs rcCs|jd|tddS)z;Emits an error when there is an untyped field in the model.zUntyped fields disallowedrNN)r ERROR_UNTYPEDrSrLrLrMrsrcCs|jd|tddS)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`rNN)rERROR_EXTRA_FIELD_ROOT_MODELrSrLrLrMrsrFz8SemanticAnalyzerPluginInterface | CheckerPluginInterfacerrCrzTypeVarType | Noner) ryrwrrr*rtvar_defr2rJcCs |j}||jkr<|j|} | jrr?Z mypy.typevarsr@Z mypy.utilrAZ mypy.versionrBZ mypy_versionZpydantic._internalrCZpydantic.versionrDrrr^rrrkr@ZDATACLASS_FULLNAMErrZMYPY_VERSION_TUPLEr4rNrKrSrprrrvrrPrQrRrUrWZERROR_FIELD_DEFAULTSrXrr>rrrrr0rrLrLrLrMs   "       0      6.V'          X