a _g. @s\dZddlmZddlZddlmZddlmZmZm 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`dZahdZbeXeTZcd Zdd!ZSd"d#d$d%d&ZeGd'd(d(e6ZfGd)d*d*Zgd+d,d-d.d/ZhGd0d1d1ZiGd2d3d3ZjGd4d5d5ZkGd6d7d7Zle d8d9d:Zme d;dd:Zoe d?d@d:Zpe dAdBd:Zqe dAdCd:Zre dAdDd:Zsd"dEdFdGdHdIdJZtd"dKdFdGdLdMdNZudKdFdGdOdPdQZvd"dRdFdGdSdTdUZwdKdFdGdOdVdWZxdEdFdGdOdXdYZydhd[d\d"d]d,d^d_d`dGda dbdcZzd"dddedfdgZ{dS)iz^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.dataclass.pydantic.functional_validators.model_validator>z0pydantic.functional_serializers.model_serializerz.pydantic.functional_validators.field_validatorrFz.pydantic.deprecated.class_validators.validatorz3pydantic.deprecated.class_validators.root_validatorz*pydantic.functional_serializers.serializerbuiltinsstrz 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)rJrM[/var/www/html/cobodadashboardai.evdpl.com/venv/lib/python3.9/site-packages/pydantic/mypy.pypluginjs rOcseZdZdZdddfdd Zddd d d Zddd d d Zddd ddZdddddZdddddZ dddddZ Z S)rLzThe Pydantic mypy plugin.r*NoneoptionsrKcs&t||_|j|_t|dSN)PydanticPluginConfig plugin_configto_data _plugin_datasuper__init__)selfrR __class__rMrNrY|s  zPydanticPlugin.__init__rIz(Callable[[ClassDefContext], None] | None)fullnamerKcCs:||}|r6t|jtr6tdd|jjDr6|jSdS)zUpdate Pydantic model class.css|]}|jtkVqdSrSr]BASEMODEL_FULLNAME.0baserMrMrN z5PydanticPlugin.get_base_class_hook..N)lookup_fully_qualified isinstancenoder(anymro$_pydantic_model_class_maker_callback)rZr]symrMrMrNget_base_class_hooks  z"PydanticPlugin.get_base_class_hookcCs|tkr|jSdS)z,Update Pydantic `ModelMetaclass` definition.N)MODEL_METACLASS_FULLNAME)_pydantic_model_metaclass_marker_callbackrZr]rMrMrNget_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_callbackrorMrMrNget_method_hooks zPydanticPlugin.get_method_hookr/dict[str, Any]ctxrKcCs|jS)zjReturn all plugin config data. Used by mypy to determine if cache needs to be discarded. )rW)rZrvrMrMrNreport_config_datasz!PydanticPlugin.report_config_datar,cCs"t|j|j|j|j}|dSrS)PydanticModelTransformerclsreasonapirU transform)rZrvZ transformerrMrMrNrjsz3PydanticPlugin._pydantic_model_class_maker_callbackcCs<|jjr dS|jjj}|s"Jdt|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)rUdebug_dataclass_transformryinfoZdeclared_metaclassgetattrtyper})rZrvZinfo_metaclassrMrMrNrns   z8PydanticPlugin._pydantic_model_metaclass_marker_callback) __name__ __module__ __qualname____doc__rYrlrprsrwrjrn __classcell__rMrMr[rNrLys rLc@sTeZdZUdZdZded<ded<ded<ded<dd d d d Zd dddZdS)rTaA 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*rPrQcCs|jdurdSt|j}|durr|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__rfr ValueErrorsetattrrread getbooleanCONFIGFILE_KEY)rZrRZ toml_configconfigkeyZsettingrUrMrMrNrYs       zPydanticPluginConfig.__init__rtrKcsfddjDS)z/Returns a dict of config names to their values.csi|]}|t|qSrM)r)rarrZrMrN rdz0PydanticPluginConfig.to_data..)rrrMrrNrVszPydanticPluginConfig.to_dataN)rrrrr__annotations__rYrVrMrMrMrNrTs  rTr-r:rucCs|j}t|tr|j}t|tr4t|jtr4|j}n.rfrom_attributesT)rrfr<itemr7Zret_typer8r\rerror_unexpected_behaviorr{contextZdefault_return_typemetadatar METADATA_KEYrhrierror_from_attributesname)rvZctx_typeZ model_typedetailZpydantic_metadatarrMrMrNrrs&  rrc @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.rIz str | Noner bool | Noneint Type | Noner( ralias is_frozenhas_dynamic_alias has_defaultstrictlinecolumnrrc Cs@||_||_||_||_||_||_||_||_| |_| |_ dSrSr) rZrrrrrrrrrrrMrMrNrYs zPydanticModelField.__init__r0r) current_infotyped model_strictforce_optional use_aliasr{force_typevars_invariantis_root_model_rootrKc Csj|||||} |jdur|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 ) rZrrrrrr{rrrrrrMrMrN to_arguments  zPydanticModelField.to_argumentF)rr{rrKcCs|r&t|jtr&|j}t|_||_|jdur|jjdurt |j j \t |}t|t sbJ|r|jD]}t|trlt|_qlt|j|jjj|iWdS1s0Y|jS)zABased on mypy.plugins.dataclasses.DataclassAttribute.expand_type.N)rfrr=Z copy_modifiedrZvariancer self_typer4strict_optional_setrRstrict_optionalr@r8argsrid)rZrr{rZ modified_typeZfilled_with_typevarsargrMrMrNr/s    4zPydanticModelField.expand_typer))rr{rrrKcCs0|r|jdur|j}n|j}t|||||S)zZed#d dd?d@Zed#dAddBdCZed#dDddEdFZed#d ddGdHZdUd0d d d d d d d dIdJ dKdLZd0dd dMdNdOZed0d d dPdQdRZdSS)VrxzTransform 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. >populate_by_nameextrarrfrozenalias_generatorzset[str]tracked_config_fieldsrzExpression | Statementr0rTrP)ryrzr{rUrKcCs||_||_||_||_dSrS)_cls_reason_apirU)rZryrzr{rUrMrMrNrYsz!PydanticModelTransformer.__init__rrcCs|jj}tdd|jddD}|}|||\}}|dusL|durPdS|D]}|jdurTdSqTtdd|jddD}|||||||||||j ||j |j dud| d d |Dd d |D| d |jt<dS) aConfigures 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 css|]}t|jvVqdSrS)ROOT_MODEL_FULLNAMEr]r`rMrMrNrcrdz5PydanticModelTransformer.transform..NFcss|]}|jtkVqdSrS)r]BASESETTINGS_FULLNAMEr`rMrMrNrcrdT)rcSsi|]}|j|qSrMrrrafieldrMrMrNrrdz6PydanticModelTransformer.transform..cSsi|]}|j|qSrMr)raZ class_varrMrMrNrrd)fields class_varsr)rrrhricollect_configcollect_fields_and_class_varsradd_initializeradd_model_construct_method set_frozenrradjust_decorator_signaturesget_values_dictrr)rZr is_root_modelrrrr is_settingsrMrMrNr|s&     z"PydanticModelTransformer.transformcs|jjjD]p}t|jtr|jjdttrtj t rj j t vrj 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_namesrfr$value)rairZ first_decrMrNrcszGPydanticModelTransformer.adjust_decorator_signatures..TN)rrnamesvaluesrfrgrZoriginal_decoratorsrcalleerr]DECORATOR_FULLNAMESMODEL_VALIDATOR_FULLNAMErh enumeraterfuncis_class)rZrkrMrrNrs       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](\} } | durq||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 rrrKc CsD|j}|jd}t|tr0t|jr0|jdkr4dS|jst|jt rxt|jj t rxt|jj j trx|jj j j t vrxdS|j|vrdSt |j|dS|jd}t|tsdSt|jr|jdkrdS|jj|j}|durdS|j}t|trdSt|tr|jd|dSt|ts&dS|jr8t|jSt|j}t|trj|jj dkrj|jd|||} ||} |jdur|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).rrrfrrCZis_valid_field_namerZ new_syntaxrrrr]rerror_untyped_fieldsrrrrrgr!r'rr)Z is_classvarrr?rr8get_has_default get_strictrZ is_inferredZanalyze_simple_literal_typer6r;Z from_errorget_alias_inforrUrris_field_frozen_infer_dataclass_attr_init_typerrr)rZr rrryr rkrgZ node_typerrrrrrZ init_typerMrMrNrs                    z=PydanticModelTransformer.collect_field_or_class_var_from_stmtr%rIrr)rkrrrKc Cs|j}|jr|St|j}t|ts(|S|jd}|rt|jtr|jd}|sXJ|jrttt |j|j|}n t t j St|t r|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__rHz(Unsupported signature for "__set__" in ""zUnsupported "__set__" in ")rZimplicitr?rfr8rrgrZget_containing_type_infor5r6r;Z unannotatedr7 arg_kindsr r arg_typesrrr) rZrkrrdefaulttsetterZ super_infoZ setter_typerMrMrNr s.      z8PydanticModelTransformer._infer_dataclass_attr_init_typezlist[PydanticModelField])rrrrrKc Csd|jjjvr"|jjjdjs"dS|jj}t|j}|jdu}t|j oL|j }|j |||||||dd} |r@|j t j} t| tsJd| jvr@| jdj} t| tsJ| dur@| jdur@| j} t| tsJt| jD]X\} }|dus|ds|dsq|j | j| }t||}| t||dtq|||sptd}| t|ttj 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. rYNT)rrrequires_dynamic_aliasesrrrr___kwargs)r return_type)$rrrplugin_generatedrUrrrrrget_field_argumentsrrerrgrfr(rrr7rr startswithZ anal_typer$r)appendrr should_init_forbid_extrar6r;rr add_methodr9)rZrrrrrrrr(rZbase_settings_nodeZbase_settings_init_node func_typeZarg_idxrZanalyzed_variable_typervarrMrMrNr5sF      z(PydanticModelTransformer.add_initializerc Cs|jtd|jtdg}t|tg}ttd||dt}t |jj j .|j |dt |jdd||d}Wdn1s0Y|||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 r4rrRrr.rrr1r0r6r;rrr2rr@r) rZrrrrZset_strZoptional_set_strZfields_set_argumentrr4rMrMrNrds2 $$  z3PydanticModelTransformer.add_model_construct_method)rr{rrKc Cs|jj}|D]}|j|j}|dur|j}t|trD|p>|j|_ qt|t rb|j j sb|j qz t|}Wntyt|}Yn0d|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.)rrrrrrgrfr)rZ is_propertyr!rZfinal_iterationZdeferrI TypeErrorreprr\rrr] _fullnamer%r) rZrr{rrrrr4Zvar_strrrMrMrNrs(    z#PydanticModelTransformer.set_frozenFrModelConfigData | None)rrrrKcCs||jvrdS|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 vrtfi||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?) rrfr$rrrerror_invalid_config_valuerrrr])rZrrrr=rrMrMrNrs(        z*PydanticModelTransformer.get_config_updatecCs|j}t|trdSt|trt|jtr|jjtkrt|j |j D]H\}}|dus\|dkrj|j t uS|dkrDt|t o|jdk SqDdSt|t  S)zUReturns a boolean indicating whether the field defined in `stmt` is a required field.FNr%default_factoryr>)rrfr&rrr"r]FIELD_FULLNAMErrrr\rrr r rrrMrMrNrs "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) rrfrrr"r]rCrrrrrDrMrMrNrs"   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) rrfr&rrr"r]rCrrrr$rr r rrrrMrMrNrs$     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?) rrfr&rrr"r]rCrrrrrErMrMrNrs    z(PydanticModelTransformer.is_field_frozenlist[Argument]) rrrrr(rrrrKc 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)rrrrr{rr)rrrrr rrrrrr(rZrrrMrN 9s   z@PydanticModelTransformer.get_field_arguments..)rr) rZrrrrr(rrr argumentsrMrGrNr.)s  z,PydanticModelTransformer.get_field_arguments)rrrKcCs.|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=rUr)rZrrrMrMrNr1Is z1PydanticModelTransformer.should_init_forbid_extra)rrrKcCs8|D]}|jrdSq|r4|D]}|jdurdSqdS)zReturns whether any fields on the model have a "dynamic alias", i.e., an alias that cannot be determined during static analysis. TNF)rr)rrrrMrMrNrJVs z1PydanticModelTransformer.is_dynamic_alias_presentN)F)F)rrrrrrrYr|rrrrrrr rrrr staticmethodrrrrr.r1rJrMrMrMrNrxs:   $LD&/(#!  rxc@sZeZdZdZddddddddddZddd d Zd d d ddZddd dddZdS)rz(Pydantic mypy plugin model config class.Nrr=rrrrrcCs(||_||_||_||_||_||_dSrSrL)rZr=rrrrrrMrMrNrYhs zModelConfigData.__init__rtrcCsdd|jDS)zReturns a dict of Pydantic model config names to their values. It includes the config if config value is not `None`. cSsi|]\}}|dur||qSrSrM)rakvrMrMrNr}rdz3ModelConfigData.get_values_dict..)__dict__rrrMrMrNrxszModelConfigData.get_values_dictr<rP)rrKcCs2|dur dS|D]\}}t|||qdS)z$Update Pydantic model config values.N)rrr)rZrrMrNrMrMrNrszModelConfigData.updaterIr)rrrKcCst||durt|||dS)zFSet default value for Pydantic model config if config value is `None`.N)rr)rZrrrMrMrNr szModelConfigData.setdefault)NNNNNN)rrrrrYrrr rMrMrMrNresrz pydantic-ormzInvalid from_attributes callZPydanticzpydantic-configzInvalid config valuezpydantic-aliaszDynamic alias disallowedzpydantic-unexpectedzUnexpected behaviorzpydantic-fieldzUntyped field disallowedzInvalid Field defaultsz!Extra field on RootModel subclassr+rrP) model_namer{rrKcCs|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)rPr{rrMrMrNrsrr0)rr{rrKcCs|jd|d|tddS)z0Emits an error when the config value is invalid.zInvalid value for "Config.r"rQN)r ERROR_CONFIG)rr{rrMrMrNrAsrA)r{rrKcCs|jd|tddS)znEmits required dynamic aliases error. This will be called when `warn_required_dynamic_aliases=True`. z#Required dynamic aliases disallowedrQN)r ERROR_ALIASr{rrMrMrNrsrz8CheckerPluginInterface | SemanticAnalyzerPluginInterface)rr{rrKcCs4d}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!rQN)rERROR_UNEXPECTED)rr{rlinkZ full_messagerMrMrNrs rcCs|jd|tddS)z;Emits an error when there is an untyped field in the model.zUntyped fields disallowedrQN)r ERROR_UNTYPEDrVrMrMrNrsrcCs|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`rQN)rERROR_EXTRA_FIELD_ROOT_MODELrVrMrMrNrsrFz8SemanticAnalyzerPluginInterface | CheckerPluginInterfacerrFrzTypeVarType | Noner) r{ryrrr,rtvar_defr5rKcCs |j}||jvr<|j|} | jrr?Z mypy.typevarsr@Z mypy.utilrAZ mypy.versionrBZ mypy_versionZpydantic._internalrCZpydantic.versionrDrrr_rrrmrCZDATACLASS_FULLNAMErrZMYPY_VERSION_TUPLEr7rOrLrTrrrrrxrrSrTrUrXrZZERROR_FIELD_DEFAULTSr[rrArrrrr2rrMrMrMrNs   "       0      6.V'          X