o gg @sdZddlZddlmZmZddlmZmZddlZddlm Z ddl m Z m Z ddl mZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZm Z m!Z!ddl"m#Z#dd l$m%Z%d Z&hd Z'd d hZ(e)ddZ*e)ddZ+ddZ,ddZ-ddZ.ddZ/ddZ0ddZ1ddZ2d ee j3d!ee j3d"ed#ee4fd$d%Z5d e j6d!e j6d"ed#ee4fd&d'Z7d(d)Z8d*d+Z9d,d-Z:d.d/Z;d0d1Zid6d7d8d9d:d;dd?d@dAdBdCdDdEdFdGdHdIdJdKdLdMdNdOdPdQdRdSdTdUdVdWidXdYdZd[d\d]d^d_d`dadbdcdddedfdgdhdidjdkdldmdndodpdqdrdsdtdudvdwdxdydzd{iZ?d|d}Z@Gd~ddZAGddde ZBGddde ZCdddZDddZEdS)z classes checker for Python code N)chain zip_longest)ListPattern)nodes) BaseCheckerutils) PYMETHODSSPECIAL_METHODS_PARAMScheck_messagesclass_is_abstractdecorated_withdecorated_with_propertyhas_known_basesis_attr_privateis_attr_protectedis_builtin_objectis_comprehension is_iterableis_overload_stubis_property_setteris_property_setter_or_deleteris_protocol_classnode_frame_classoverrides_a_method safe_inferunimplemented_abstract_methods)IAstroidCheckerget_global_option__next__>boolrangeslice memoryviewbuiltins.propertyzbuiltins.classmethod_CallSignaturez!args kws starred_args starred_kws_ParameterSignaturezargs kwonlyargs varargs kwargscCsi}g}g}g}|jp gD]*}|j|j}}|dur't|tjr'||jq t|tjr3|j||<q d||<q |jD])}t|tj rRt|jtjrR||jjq;t|tjr_||jq;|dq;t ||||SN) keywordsargvalue isinstancerNameappendnameargsStarredr&)callkwsr0 starred_kws starred_argskeywordr*r+r7U/home/ubuntu/cloudmapper/venv/lib/python3.10/site-packages/pylint/checkers/classes.py_signature_from_callcs$      r9cCsB|j}|j}ddt|j|jD}dd|jD}t||||S)NcSsg|] }|jdkr|jqSselfr/.0r*r7r7r8 s  z-_signature_from_arguments..cSg|]}|jqSr7r<r=r7r7r8r?)kwargvarargr posonlyargsr0 kwonlyargsr') argumentsrBrCr0rEr7r7r8_signature_from_argumentss rGc s|jr |jjv}nj }|jr|jjv}nj }tfdd|jD}|jjk}d}jrKjD]}|jv}||jv} |sJ| sJd}nq6t|||||fS)z8Check if a definition signature is equivalent to a call.c3s|]}|jvVqdSr()r3)r>kwr2r7r8 z1_definition_equivalent_to_call..TF)kwargsr4varargsr5allrEr0r3) definitionr2same_kw_variadicssame_args_variadicssame_kwonlyargs same_argsno_additional_kwarg_argumentsr6is_arg is_kwonlyr7rIr8_definition_equivalent_to_calls2    rWcCs"|jj}|jdvr|dd}|S)N) classmethodmethod)r0type)rY positionalr7r7r8_positional_parameterss  r]cCs |D] }t||r |SqdS)z Return the type of the node if it exists in potential_types. Args: node (astroid.node): node to get the type of. potential_types (tuple): potential types of the node. Returns: type: type of the node or None. N)r,)nodepotential_typespotential_typer7r7r8_get_node_types  racCst||t||kS)a} Check equality of nodes based on the comparison of their attributes named attr_name. Args: node_a (astroid.node): first node to compare. node_b (astroid.node): second node to compare. attr_name (str): name of the nodes attribute to use for comparison. Returns: bool: True if node_a.attr_name == node_b.attr_name, False otherwise. )getattr)node_anode_b attr_namer7r7r8_check_arg_equalitys rfc s0|jdus |jdur dSt|j|j}dd|D}t|D]v}z||}Wn tjjy5}Ynwz||}Wn tjjyJ}Ynwfdd||fD}t|rat |sadSt j dt j dt j d t jd t jd i}td d |D} t|| } | rt|| sdSt|||| sdSqdS) a0 Check if original and overridden methods arguments have different default values Return True if one of the overridden arguments has a default value different from the default value of the original argument If one of the method doesn't have argument (.args is None) return False NFcSr@r7r<r>paramr7r7r8r?rAz;_has_different_parameters_default_value..csg|]}|kqSr7r7r=default_missingr7r8r?sTr+r/eltsitemscss|]}|VqdSr(r7)r> astroid_typer7r7r8rJs z:_has_different_parameters_default_value..)r0rrEobject default_valueastroid exceptions NoDefaultanyrNrConstClassDefTuplerDicttuplerar,rf) original overriddenall_argsoriginal_param_names param_nameoriginal_defaultoverridden_default default_listastroid_type_compared_attr handled_types original_typer7rir8'_has_different_parameters_default_valuesT    rryrzdummy_parameter_regexreturnc sg}t||}|D]8\}}||f}t|sdgSdd|D}tfdd|Dr-q |j|jkrA|d|jd|jdq |S) NNumber of parameters cSr@r7r<rgr7r7r8r?"rAz-_has_different_parameters..c3s|]}|VqdSr()match)r>r/rr7r8rJ#rKz,_has_different_parameters..z Parameter 'z' has been renamed to 'z' in)rrNrsr/r.) ryrzrresultzippedoriginal_paramoverridden_paramparamsnamesr7rr8_has_different_parameterss"     rc sRg}t|}t|}|jj}|jjr"dd|Dfdd|D}|jjr:dd|jjDfdd|jjD}t|||}t||jj|}|rw|rwd|dvrnd|dvrn|d||d d 7}||d d 7}n||7}||7}n |r}||7}|r||7}|jtvr| |jjo|jj } |jjo|jj } | s| r|d g7}|S) aEDetermine if the two methods have different parameters They are considered to have different parameters if: * they have different positional parameters, including different names * one of the methods is having variadics, while the other is not * they have different keyword only parameters. cSr@r7r<r>vr7r7r8r?JrAz)_different_parameters..cg|] }|jvr|qSr7r<roveridden_namesr7r8r?KcSr@r7r<rr7r7r8r?PrAcrr7r<rrr7r8r?QrzNumber rrrZNzVariadics removed in) r]r0rErCrBrr.r/r clear) ryrzroutput_messagesoriginal_parametersoverridden_parametersoriginal_kwonlyargsdifferent_positionaldifferent_kwonly kwarg_lost vararg_lostr7rr8_different_parameters.sL       rcCs|jtvot|Sr()r/INVALID_BASE_CLASSESrclsr7r7r8_is_invalid_base_class|src Cs||}|D]9}z+|D]$}t|tjr2z |d|dWn tjy,YqwWdSqWqtjy@YdSwdS)N__get____set__TF)rbinferr,rpInstance NotFoundErrorInferenceError)rattr attributes attributeinferredr7r7r8_has_data_descriptors$      rc Cst|tjsdS|D]V}z||}Wn tjyYq w|D]?}|tjD]6}z t|j }Wn tj t fy?Yq(wt|tj sGq(|j}t|tjrS|j}|j|jkr^dSq(q q dS)zCheck if the func was called in any of the given methods, belonging to the *klass*. Returns True if so, False otherwise. FT)r,r FunctionDefrbrprnodes_of_classCallnextfuncrr StopIteration BoundMethod_proxied UnboundMethodr/) rklassmethodsrYr infer_methodr2boundfunc_objr7r7r8_called_in_methodss4      rc Csz||}Wn tjyYdSwd}|D]<}|tjurqzt|}Wn tjy1Yqwt|tj r?t |r?dS| |krFqt |}|| krQqdSdS)a/Check if the given attribute *name* is a property in the given *klass*. It will look for `property` calls or for functions with the given name, decorated by `property` or `property` subclasses. Returns ``True`` if the name is a property in the given klass, ``False`` otherwise. Fr%T)rbrpr Uninferablerrrr,rrrpytyperdeclared_metaclass)r/rr property_namerrrr7r7r8_is_attribute_propertys2    rcCs>|tjD]}|j}t|tjr|jdkr|jsdSqdS)NsuperTF)rrrrr,r-r/r0) fundef_noder2rr7r7r8_has_bare_super_calls rcCs~z |j||d}t|}WntjyYdSty!YdSwzt|WdStjy4YdSty>|YSw)z Safely infer the return value of a function. Returns None if inference failed or if there is some ambiguity (more than one node has been inferred). Otherwise returns inferred value. )contextN)infer_call_resultrrprr)r^callerrinferitr+r7r7r8_safe_infer_call_results    rcCs@t|}t|tjr|}tddt||DrdSdS)Ncss(|]\}}|o|o|j|jkVqdSr(r+)r> first_slot second_slotr7r7r8rJs  z)_has_same_layout_slots..TF)rrr,rruslotsrNr)rassigned_valuer other_slotsr7r7r8_has_same_layout_slotss  rF0202)z+Unable to check methods signature (%s / %s)method-check-failedzUsed when Pylint has been unable to check methods signature compatibility for an unexpected reason. Please report this kind if you don't make sense of it.E0202)z4An attribute defined in %s line %s hides this method method-hiddenz~Used when a class defines a method which is hidden by an instance attribute from an ancestor class or set by some client code.E0203)z1Access to member %r before its definition line %saccess-member-before-definitionzGUsed when an instance member is accessed before it's actually assigned.W0201)z%Attribute %r defined outside __init__attribute-defined-outside-initzGUsed when an instance attribute is defined outside the __init__ method.W0212)z1Access to a protected member %s of a client classprotected-accesszUsed when a protected member (i.e. class member with a name beginning with an underscore) is access outside the class or a descendant of the class where it's defined.E0211)zMethod has no argumentno-method-argumentzbUsed when a method which should have the bound instance as first argument has no argument defined.E0213)z+Method should have "self" as first argumentno-self-argumentzUsed when a method has an attribute different the "self" as first argument. This is considered as an error since this is a so common convention that you shouldn't break it!C0202)z0Class method %s should have %s as first argumentbad-classmethod-argumentzUsed when a class method has a first argument named differently than the value specified in valid-classmethod-first-arg option (default to "cls"), recommended to easily differentiate them from regular instance methods.C0203)z4Metaclass method %s should have %s as first argumentbad-mcs-method-argumentzUsed when a metaclass method has a first argument named differently than the value specified in valid-classmethod-first-arg option (default to "cls"), recommended to easily differentiate them from regular instance methods.C0204)z:Metaclass class method %s should have %s as first argumentbad-mcs-classmethod-argumentzUsed when a metaclass class method has a first argument named differently than the value specified in valid-metaclass-classmethod-first-arg option (default to "mcs"), recommended to easily differentiate them from regular instance methods.W0211)z'Static method with %r as first argumentbad-staticmethod-argumentzUsed when a static method has "self" or a value specified in valid-classmethod-first-arg option or valid-metaclass-classmethod-first-arg option as first argument.R0201)zMethod could be a function no-self-usezYUsed when a method doesn't use its bound instance, and so could be written as a function.W0221)%s %s %r methodarguments-differztUsed when a method has a different number of arguments than in the implemented interface or in an overridden method.W0222)z#Signature differs from %s %r methodsignature-differszgUsed when a method signature is different than in the implemented interface or in an overridden method.W0223)z7Method %r is abstract in class %r but is not overriddenabstract-methodzbUsed when an abstract method (i.e. raise NotImplementedError) is not overridden in concrete class.W0231)z0__init__ method from base class %r is not calledsuper-init-not-calledzaUsed when an ancestor class method has an __init__ method which is not called by a derived class.W0232)zClass has no __init__ methodno-initzEUsed when a class has no __init__ method, neither its parent classes.W0233)z9__init__ method from a non direct base class %r is callednon-parent-init-calledznUsed when an __init__ method is called on a class which is not in the direct ancestors for the analysed class.W0235)z%Useless super delegation in method %ruseless-super-delegationzUsed whenever we can detect that an overridden method is useless, relying on super() delegation to do the same thing as another method from the MRO.W0236)z7Method %r was expected to be %r, found it instead as %rinvalid-overridden-methodzUsed when we detect that a method was overridden in a way that does not match its base class which could result in potential bugs at runtime.W0237)rarguments-renamedzoUsed when a method parameter has a different name than in the implemented interface or in an overridden method.W0238)zUnused private member `%s.%s`unused-private-memberzAEmitted when a private member of a class is defined but not used.E0236)zCInvalid object %r in __slots__, must contain only non empty stringsinvalid-slots-objectz=Used when an invalid (non-string) object occurs in __slots__.E0237)z4Assigning to attribute %r not defined in class slotsassigning-non-slotzCUsed when assigning to an attribute not defined in the class slots.E0238)zInvalid __slots__ object invalid-slotszhUsed when an invalid __slots__ is found in class. Only a string, an iterable or a sequence is permitted.E0239)z$Inheriting %r, which is not a class.inherit-non-classz?Used when a class inherits from something which is not a class.E0240)z1Inconsistent method resolution order for class %rinconsistent-mroz>Used when a class has an inconsistent method resolution order.E0241)zDuplicate bases for class %rduplicate-basesz&Used when a class has duplicate bases.E0242)z/Value %r in slots conflicts with class variableclass-variable-slots-conflictzSUsed when a value in __slots__ conflicts with a class variable, property or method.E0243)zInvalid __class__ objectinvalid-class-objectz[Used when an invalid object is assigned to a __class__ property. Only a class is permitted.R0202)z9Consider using a decorator instead of calling classmethodno-classmethod-decoratorzGUsed when a class method is defined without using the decorator syntax.R0203)z:Consider using a decorator instead of calling staticmethodno-staticmethod-decoratorzHUsed when a static method is defined without using the decorator syntax.C0205)z/Class __slots__ should be a non-string iterablesingle-string-used-for-slotszHUsed when a class __slots__ is a simple string, rather than an iterable.R0205)zJClass %r inherits from object, can be safely removed from bases in python3useless-object-inheritancezoUsed when a class inherit from object, which under python3 is implicit, hence can be safely removed from bases.R0206)z-Cannot have defined parameters for propertiesproperty-with-parameterszUsed when we detect that a property also has parameters, which are useless, given that properties cannot be called with additional arguments.cCs ttSr() collections defaultdictlistr7r7r7r8_scope_defaults rc@s(eZdZdZddZddZddZdS) ScopeAccessMapz'Store the accessed variables per scope.cCstt|_dSr()rrr_scopesr:r7r7r8__init__szScopeAccessMap.__init__cCs.t|}|dur dS|j||j|dS)zSet the given node as accessed.N)rrattrnamer.)r;r^framer7r7r8 set_accessedszScopeAccessMap.set_accessedcCs|j|iS)z/Get the accessed variables for the given scope.)rget)r;scoper7r7r8accessedzScopeAccessMap.accessedN)__name__ __module__ __qualname____doc__r r#r&r7r7r7r8rs  rc @seZdZdZefZdZeZdZ dddddd fd d dd d d fdd dd dd fdddddd fdddddd ffZ d~ddZ e j jddZe j jddZed d!d"d#d$d%d&d'd(d) d*ejd+dfd,d-Zd.d/Zd0d1Zed2d3d*ejd+dfd4d5Zd*ejd+dfd6d7Zd*ejd+dfd8d9Zd*ejd+dfd:d;ZdZd*ejd+dfd?d@ZeZdAdBZdCdDZ dEdFZ!dGdHZ"dIdJZ#d*ejd+dfdKdLZ$e$Z%d*ej&d+dfdMdNZ'edOdPd*ej(d+dfdQdRZ)d*ej(d+dfdSdTZ*dUdVZ+edWdXdYdZej,d+dfd[d\Z-d]d^Z.d*ej&fd_d`Z/e0d*ej1d+e2fdadbZ3dcddZ4e0dedfZ5e0dgdhZ6e0didjZ7d*ej8d+dfdkdlZ9dmdnZ:ddpdqZ;drdsZdxdyZ?dzd{Z@d|d}ZAdS) ClassCheckerzchecks for : * methods without self as first argument * overridden methods signature * access only to existent members via self * attributes not defined in the __init__ method * unreachable code classeszdefining-attr-methods)r __new__setUp __post_init__csvzzGList of method names used to declare (i.e. assign) instance attributes.)defaultr[metavarhelpzvalid-classmethod-first-argrzz=List of valid names for the first argument in a class method.z%valid-metaclass-classmethod-first-argzGList of valid names for the first argument in a metaclass class method.zexclude-protected)_asdict_fields_replace_source_makezzQList of member names, which should be excluded from the protected access warning.z)check-protected-access-in-special-methodsFynzznr7r7r8rJs z?ClassChecker._check_unused_private_functions..r;r.()rr^r0)rrrrr/parentr%r,r- Attributer!exprrrrur.joinreversedr0rTrHlstrip) r;r^ function_def parent_scoperr name_stackcurrouter_level_names function_reprr7r7r8rWsR            z,ClassChecker._check_unused_private_functionscCs|tjD]P}t|jtjrqt|jsq|tjtj fD](}t|tjr/|j|jkr/n't|tj rG|j |jkrG|j jdd|jfvrGnq|j|jf}|j d||dqdS)Nr;rrra) rr AssignNamer,rb Argumentsrr/r-rcr!rdrH)r;r^ assign_namechildr0r7r7r8rXs$    z,ClassChecker._check_unused_private_variablescCs|tjD]}t|jrt|jtjsqdg}|}t|tj r5|j dkr5| dd|tj D|tj D]?}|j|jkrDq;|jj d|j fvrY|jj dd|j fvrYn0|jj |vrg|jj dkrgn"|jj |jj krv|j krznq;nq;|j |jf}|jd||dqdS)Nr;r/cSs"g|] }t|jtjr|jjqSr7)r,r+rr-r/)r> return_noder7r7r8r?s  zAClassChecker._check_unused_private_attributes..rrra)rr AssignAttrrr!r,rdr-r%rr/extendReturnrcrH)r;r^ assign_attracceptable_obj_namesr%rr0r7r7r8rYsB     " z-ClassChecker._check_unused_private_attributescnodec s^|jr|jdddkrdS|j|}|jdkr!||||jds)dS|j j | |j D]v\}}|dkr?q6fdd|D}|sKq6dd |D}tfd d |Dr^q6||D]}d }|j |D] }|jvrwd }ql|r|n0qcz||Wq6tjy|D]}|jvrt||rq|jd||d qYq6wq6dS)Nmixin metaclassr__dict__cs2g|]}t|tjtjfs|ur|qSr7)r, statementrDelete AugAssignrootr\)current_moduler7r8r?s zFClassChecker._check_attribute_defined_outside_init..css|]}|VqdSr()r")r>r^r7r7r8rJ*zEClassChecker._check_attribute_defined_outside_init..c3s"|] }|jvp t|VqdSr()r/r)r>r")defining_methodsr7r8rJ+s  FTrE)rCr/lowerr<r&r[_check_accessed_membersr@is_message_enabledconfigdefining_attr_methodsrinstance_attrsrlrsinstance_attr_ancestorsr"rGrprrrH) r;rxr&r nodes_lstframesrb attr_definedr^r7)rrr8rZs`       z2ClassChecker._check_attribute_defined_outside_initc Cs|sdS|||||j}d|_|||jdk|jdkr-| |dS| |jD](}z||j}Wn t yEYq3wt |t jsMq3|||d|||||jr|jj D]f}t |t jrs|jdvrsdSt |t jr|jdkrdSt|}|sdSt |t jrz t||}Wn tjyYdSwzt |tjt jfr|dr|d rWdSWqctjyYqcwzo||jd }|}t |t jr|jd kr|j}t |t jr|| sWdS|!D]+}|j|j"vrt#|jrWdS|$|jd D]} t | t jr$WdSqq|%j|j&f} |j'd | |dWdStj(yEYdSw)z"check method arguments, overridingNTr{r rz)gettersetterdeleterpropertyrrrrYrZrrE)) is_method_check_useless_super_delegation_check_property_with_parametersrbr"r>_check_first_arg_for_typer[r/ _check_initlocal_attr_ancestorsKeyErrorr,rr_check_signature _check_invalid_overridden_method decoratorsrcr!r-rrrrprrrurbAttributeInferenceError instance_attrrSqname ancestorsrrlookupr fromlinenorHr) r;r^rrzparent_function decoratorroverridden_framerVobjr0r7r7r8visit_functiondefMs                   zClassChecker.visit_functiondefc Cs|r|jr dS|j}t|dkrdS|d}t|tjtjfs#dS|j}t|tj r3t|j tj s5dSz t |j j }Wn tjyJYdSwt|tjjsTdS|j j|jkr]dS|j}|j|ksut|jtjru|jj|jkrwdS|j}d}||jD]#} z| |j}Wn tyYqwt|tjrt|j|jrdSt |j} t!|} |durdd} | |j} | |j}| r|r| |krdSt"| | r|j#d||jfddSdS)aQCheck if the given function node is an useless method override We consider it *useless* if it uses the super() builtin, but having nothing additional whatsoever than not implementing the method at all. If the method uses super() to delegate an operation to the rest of the MRO, and if the method called is the same as the current one, the arguments passed to super() are the same as the parameters that were passed to this method, then the method could be removed altogether, by letting other implementation to take precedence. NrZrcSs t|jpg|j}dd|DS)NcSsg|] }|dur|qSr()rT)r>annr7r7r8r? szZClassChecker._check_useless_super_delegation..form_annotations..)rposonlyargs_annotations annotations)rFrr7r7r8form_annotationss zFClassChecker._check_useless_super_delegation..form_annotationsrra)$rrbodylenr,rExprrur+rrrcrrdrrprobjectsSuperr!r/rbr% mro_pointerr[rr"rrrrr0rGr9rWrH)r;functionrr}r2 super_call current_scoper meth_noderzrr0rcalled_annotationsoverridden_annotationsr7r7r8rs|                z,ClassChecker._check_useless_super_delegationcCsJ|jjrt|jjdkrt|r!t|s#|jd|ddSdSdSdSdS)NrZrr^)r0rrrrHrLr7r7r8rs z,ClassChecker._check_property_with_parameterscCst|pt|}t|pt|}|r"|s"|jd|jd|jf|dn|s2|r2|jd|jddf|dt|tj}t|tj}|rP|sP|jd|jddf|ddS|sb|rd|jd|jddf|ddSdSdS)NrrrErYasyncz non-async)rrrHr/r[r,rAsyncFunctionDef)r; function_nodeparent_function_nodeparent_is_propertycurrent_is_propertyparent_is_asynccurrent_is_asyncr7r7r8r!sJ        z-ClassChecker._check_invalid_overridden_methodc Csd|jvrdS|dD]^}|tjurq t|s$t|s$|jd|dq t|tj r2|jd|dq t |ds8q t|tj rGdd|j D}n| }|tjurSdS|D]}z|||WqUtjyiYqUwq dS)N __slots__rrriteredcSsg|]}|dqSrr7)r>itemr7r7r8r?Zsz-ClassChecker._check_slots..)localsigetattrrprrrrHr,rrthasattrrwrlr_check_slots_eltr)r;r^rvalueseltr7r7r8rIFs4      zClassChecker._check_slotscCs|D]X}|tjur qt|tjrt|jts#|jd| |dq|js0|jd| |d|j |j}|r\t |dkrR|dj }t|tjrR|jdurRdS|jd|jf|dqdS)NrrErZrr )rrprr,rrtr+strrHrTrr$rrb AnnAssign)r;rr^rclass_variablerbr7r7r8res2       zClassChecker._check_slots_eltcCs|rL|jjdur|j|jdsdS|j}|jrN|j dkrP|j t vrR| sTt ||j sVt|sXt|sZt|s\t|s^|jd|ddSdSdSdSdSdSdSdSdSdSdS)zon method node, check if this method couldn't be a function ignore class, static and abstract methods, initializer, methods overridden from a parent class. NrrYr)rr0r=popr@rrbr"r>r[r/r is_abstractrrrrrrH)r;r^ class_noder7r7r8leave_functiondefs6        zClassChecker.leave_functiondefcCs8||r |j|dS|jdsdS||dS)zcheck if the getattr is an access to a class member if so, register it. Also check for access to protected class member from outside its class (but ignore __special__ methods) Nr)_uses_mandatory_method_paramr<r#r@r!_check_protected_attribute_accessrLr7r7r8visit_attributes   zClassChecker.visit_attributerrcCs>t|tjr||r|j|||||dSr() r, assign_typerrrr<r#_check_in_slots_check_invalid_class_objectrLr7r7r8visit_assignattrs   zClassChecker.visit_assignattrcCsF|jdksdSt|jj}t|tjs|tjurdS|j d|ddS)N __class__rr) r!rrbr+r,rrurprrHr;r^rr7r7r8rs  z(ClassChecker._check_invalid_class_objectcs<tj}t|tjs dS|j}t|sdSd|jvs|js dSt dd| Dr?t |dd}|r?| |j dur?||j =| }|durIdSt dd|DrVdSt fdd|Dst dd|Dstj|rrdSj|jvrt|jrdSjd krt|jjrdS|jd jfd dSdSdS) zTCheck that the given AssignAttr node is defined in the class slots. Nrcss|] }|dkVqdS)ztyping.GenericN)r)r>rUr7r7r8rJz/ClassChecker._check_in_slots..__cachecss$|] }d|jvo |jdkVqdS)rrnN)rr/)r>rVr7r7r8rJs  c3s|] }|jjkVqdSr()r+r!r>slotrr7r8rJrcss|]}|jdkVqdS)r|Nrrr7r7r8rJrKrrrE)rrdr,rprrrrnewstylersrNrbr$rrrr!rrrbr+rH)r;r^rrcacherr7rr8rsD     zClassChecker._check_in_slotsrrr assign_nodecCs@|||jd}t|tjsdS||rdS||dSNr)_check_classmethod_declarationtargetsr,rrsrr)r;rr^r7r7r8 visit_assigns    zClassChecker.visit_assigncst|jtjs dS|jj}t|tjr|jdvrdS|jdkr!dnd}|}t|tjs/dS|jj d}t|tjs=dS|jt fdd| DrY|j ||j dd dSdS) a[Checks for uses of classmethod() or staticmethod() When a @classmethod or @staticmethod decorator should be used instead. A message will be emitted only if the assignment is at a class scope and only if the classmethod's argument belongs to the class where it is defined. `node` is an assign node. N)rX staticmethodrXrrrc3s|]}|jkVqdSr(r<)r>member method_namer7r8rJ#rKz>ClassChecker._check_classmethod_declaration..r)r,r+rrrr-r/r%rur0rs mymethodsrHr)r;r^rmsg parent_class classmeth_argr7rr8rs&     z+ClassChecker._check_classmethod_declarationcCsp|j}t|r||jjvrt|}|j}t|rdS|dur+|j d||ddSt |jt j rCt |jj t jrC|jj jdkrCdS||jrKdS||jks||jvs|j}t |t jr}t|jdkr}t |jdt jr}|jdj}t||r}dS||r||j|r|||rdS|d }|jjs|r||rdS|j d||ddSdSdSdSdS)aGiven an attribute access node (set or get), check if attribute access is legitimate. Call _check_first_attr with node before calling this method. Valid cases are: * self._attr in a method or cls._attr in a classmethod. Checked by _check_first_attr. * Klass._attr inside "Klass" class. * Klass2._attr inside "Klass" class when Klass2 is a base class of Klass. NrrarrZr__) r!rrexclude_protectedrrdrTr"is_node_in_type_annotation_contextrHr,rrrr-r/_is_type_self_call basenamesrbr}Assignrrrnr_is_classmethodr"_is_inferred_instance_is_class_attribute startswith)check_protected_access_in_special_methods _is_called_inside_special_method)r;r^r!rcalleestmtr/licit_protected_memberr7r7r8r&s`               z.ClassChecker._check_protected_attribute_accesscCs0z|j}Wn tyYdSw|o|tvS)zZ Returns true if the node is located inside a special (aka dunder) method F)r"r/AttributeErrorr )r^ frame_namer7r7r8rvs   z-ClassChecker._is_called_inside_special_methodcCsDt|tjo!t|jtjo!|jjdko!t|jdko!||jdS)Nr[rZr) r,rrrr-r/rr0_is_mandatory_method_param)r;rdr7r7r8rs    zClassChecker._is_type_self_callcCs t|tjo|jdkp|jdkS)z1Check if the given *func* node is a class method.rX__class_getitem__)r,rrr[r/)rr7r7r8rs zClassChecker._is_classmethodcCs"t|}t|tjs dS|j|uS)zJCheck if the inferred value of the given *expr* is an instance of *klass*.F)rr,rprr)rdrrr7r7r8rs  z"ClassChecker._is_inferred_instancecCsNz||WdStjyYnwz||WdStjy&YdSw)zCheck if the given attribute *name* is a class or instance member of the given *klass*. Returns ``True`` if the name is a property in the given klass, ``False`` otherwise. TF)rbrprr)r/rr7r7r8rs  z ClassChecker._is_class_attributecCs2|jr|j|jdks|jdsd|_dSdSdS)zXcheck if the name handle an access to a class member if so, register it FN)r=r/r>rLr7r7r8 visit_names  zClassChecker.visit_namec s*d}|D]\}z||WqtjyYnwz t||Wqty.Ynwz||}Wn tjy@Yqwfdd|D}|sMq|dfddt |D}t |dkr|d}| }|j }D] } | |ur| j |krt | ||s|jd| ||fdqqqd S) z'check that accessed members are defined)r Exception BaseExceptioncsg|]}|vr|qSr7r7)r>r)rr7r8r?sz8ClassChecker._check_accessed_members..rcs(g|]\}}|dks|ur|qSrr%)r>irrr7r8r?s rZrraN)rlrGrprrrrrr% enumeraterr"r are_exclusiver}rH) r;r^r&excsrdefstmtsdefstmtr"lno_noder7)rr%r8rsX        z$ClassChecker._check_accessed_membersrcCsZ|jjdurdS|jjr|jjdj}n |jjr|d}nd}|j||jd}|jdkrR|dksA||jjvsA||jj vrK|j d||ddSd|jd<dS|jjsc|jjsc|j d|d dS|r|jd krx| ||jj |d |jdS| ||jj|d |jdS|jd ks|jd kr| ||jj|d|jdS|dkr|j d|d dSdS)alcheck the name of first argument, expect: * 'self' for a regular method * 'cls' for a class method or a metaclass regular method (actually valid-classmethod-first-arg value) * 'mcs' for a metaclass class method (actually valid-metaclass-classmethod-first-arg) * not one of the above for a static method Nrrrr;rrErrrXrrrrr) r0rDr/argnamesr=r.r[rvalid_classmethod_first_arg%valid_metaclass_classmethod_first_argrH_check_first_arg_config)r;r^r{ first_argfirstr7r7r8rsZ         z&ClassChecker._check_first_arg_for_typecCsl||vr4t|dkrt|d}nddd|ddD}|d|d}|j|||f|ddSdS) NrZrz, css|]}t|VqdSr()reprrr7r7r8rJ?rz7ClassChecker._check_first_arg_config..rz or rE)rrrerH)r;rrr^messagervalidr7r7r8r:s z$ClassChecker._check_first_arg_configcCsvdd}t|r dStt||ddd}|D]\}}|j}||ur'q||jvr-q|jd|||jfdqdS) z^check that the given class node implements abstract methods from base classes cSs |jddS)NF)pass_is_abstract)r)rYr7r7r8rHs z6ClassChecker._check_bases_classes..is_abstractNcSs|dSrr7)rr7r7r8Qsz3ClassChecker._check_bases_classes..)keyrra) r sortedrrlrbr"rrHr/)r;r^rrr/rYownerr7r7r8rFCs    z!ClassChecker._check_bases_classesc Cs|jds|jdsdS|j}t|}t|}|tjD]}|j }t |tj r1|j dkr2q!t |j tjrKt |j j tjrK|j j jdkrKdSzT|j D]L}|tjurYqQt |tjrvt |jtjrvt|jrv|jjdkrvWdSt |tjjrWdSz||=WqQty||vr|jd||jdYqQwWq!tjyYq!w|D]%\}}t|dgrqt|} |jdks| r| jdkrq|jd|j|d qdS) zcheck that the __init__ method call super or ancestors'__init__ method (unless it is used for type hinting with `typing.overload`) rrNr rraztyping.overloadrnrE)r@rrbr"_ancestors_to_calldictrrrrr,rcr!rdr-r/rrprrrrurrrrrHrrlr r) r;r^ klass_nodeto_callnot_called_yetrrdrrYrr7r7r8r^sl            zClassChecker._check_initc Cs$t|tjr t|tjs|jd||f|ddS|}tj||}tj||}|jjdus6|jjdur8dSt |j r?dSt |rEdSt |||j d}t|dkr|D]}d|vrt|jj}|jjri|d7}|jjrq|d7}|jjr}|t|jj7}t|jj} |jjr| d7} |jjr| d7} |jjr| t|jj7} d} |d | d |jj d |j d |d ||jj d |j f} n#d|vrd} |||jj d |j f} nd} |||jj d |j f} |j| | |dqUdSt|jjt|jjkr|jjs|jd||j f|ddSdSdS)z7check that the signature of the two given methods matchrrENrrNumberrZrzwas z in 'r^z ' and is now z inrenamedrr)r,rrrHinstantiate_classrp scoped_nodesfunction_to_methodr0rr/rrrBrrCrBrErbdefaults) r;method1 refmethod class_typerinstancearg_differ_outputrtotal_args_method1total_args_refmethod error_typemsg_argsr7r7r8rs       (  zClassChecker._check_signaturecCs ||jS)zCheck that attribute lookup name use first attribute variable name Name is `self` for method, `cls` for classmethod and `mcs` for metaclass. )rrdrLr7r7r8rs z)ClassChecker._uses_mandatory_method_paramcCs"|jot|tjo|j|jdkS)zCheck if nodes.Name corresponds to first attribute variable name Name is `self` for method, `cls` for classmethod and `mcs` for metaclass. r)r=r,rr-r/rLr7r7r8rs  z'ClassChecker._is_mandatory_method_paramr(r)Br(r)r*r+r__implements__r/MSGSmsgspriorityoptionsr rprcachedpropertyrBrCr rrurMrKrJr[rWrXrYrZrrvisit_asyncfunctiondefrrrrIrrleave_asyncfunctiondefrcrrsrrrrrrrrNodeNGr!rrrrrr-rrrrrFrrrrr7r7r7r8r,s    =      24E^k % 3 'P     <E ;N r,c@sneZdZdZefZdZdddedddd gifd d d dd gifdddddddddddd ZdZ dWddZ e d dddd d!d"d#d$d%d&d'd( d)e j d*dfd+d,ZeZd-d.Zed/d0Zed1d2Zed3d4Zed5d6Zed7d8Zed9d:Zed;d<Zed=d>Zd?d@ZdAdBZdCdDZdEdFZdGdHZdIdJZdKdLZ dMdNZ!dOdPZ"dQdRZ#dSdTZ$dUdVZ%dS)XSpecialMethodsCheckerzOChecker which verifies that special methods are implemented correctly. r-z__iter__ returns non-iteratornon-iterator-returnedzVUsed when an __iter__ method returns something which is not an iterable (i.e. has no `z ` method) old_names)W0234zold-non-iterator-returned-1)E0234zold-non-iterator-returned-2z6The special method %r expects %s param(s), %d %s given#unexpected-special-method-signaturezEmitted when a special method was defined with an invalid number of parameters. If it has too few or too many, it might not work at all.)E0235zbad-context-manager)z,__len__ does not return non-negative integerinvalid-length-returnedzPUsed when a __len__ method returns something which is not a non-negative integer)z__bool__ does not return boolinvalid-bool-returnedzAUsed when a __bool__ method returns something which is not a bool)z__index__ does not return intinvalid-index-returnedzGUsed when an __index__ method returns something which is not an integer)z__repr__ does not return strinvalid-repr-returnedzCUsed when a __repr__ method returns something which is not a string)z__str__ does not return strinvalid-str-returnedzBUsed when a __str__ method returns something which is not a string)z__bytes__ does not return bytesinvalid-bytes-returnedzAUsed when a __bytes__ method returns something which is not bytes)z__hash__ does not return intinvalid-hash-returnedzEUsed when a __hash__ method returns something which is not an integer)z4__length_hint__ does not return non-negative integerinvalid-length-hint-returnedzXUsed when a __length_hint__ method returns something which is not a non-negative integer)z__format__ does not return strinvalid-format-returnedzEUsed when a __format__ method returns something which is not a string)z&__getnewargs__ does not return a tupleinvalid-getnewargs-returnedzHUsed when a __getnewargs__ method returns something which is not a tuple)zB__getnewargs_ex__ does not return a tuple containing (tuple, dict)invalid-getnewargs-ex-returnedzbUsed when a __getnewargs_ex__ method returns something which is not of the form tuple(tuple, dict)) E0301E0302E0303E0304E0305E0306E0307E0308E0309E0310E0311E0312E0313r.Nc CsHt|||j|j|j|j|j|j|j|j |j |j |j |j d |_dS)N) __iter____len____bool__ __index____repr____str__ __bytes____hash____length_hint__ __format____getnewargs____getnewargs_ex__)rr  _check_iter _check_len _check_bool _check_index _check_repr _check_str _check_bytes _check_hash_check_length_hint _check_format_check_getnewargs_check_getnewargs_ex _protocol_mapr?r7r7r8r Us  zSpecialMethodsChecker.__init__r?r@rArBrCrDrErFrGrHrIr^rcCsT|sdSt||}|r|j|jvr|j|j|||jtvr(||dSdSr()rrr/ror "_check_unexpected_method_signaturerr7r7r8rfs  z'SpecialMethodsChecker.visit_functiondefc Cs t|j}|dur dS|jjs|jjsdSt|dgr |jj}n|jjdd}t|t|jj}t|jj}||}t|trJ||v}d|}n!||}|dkrUd}n|dkr\d}n|dkrk||dkpi|jj }|r|dkrsdnd} |j d |j||| f|d dSdS) Nzbuiltins.staticmethodrZzbetween %d or %drFTwaswerer=rE) r r/r0rCr rr%r,rxrH) r;r^expected_paramsr{ mandatoryoptionalcurrent_paramsemitrestverbr7r7r8rps:        z8SpecialMethodsChecker._check_unexpected_method_signaturecCs$t|tjo|j|kot|tj Sr()r,rprr/rrt)r^type_r7r7r8_is_wrapped_types  z&SpecialMethodsChecker._is_wrapped_typecC(t|drdSt|tjot|jtS)NintT)r8r{r,rrtr+r}rr7r7r8_is_int zSpecialMethodsChecker._is_intcCr|)NrT)r8r{r,rrtr+rrr7r7r8_is_strrzSpecialMethodsChecker._is_strcCr|)Nr!T)r8r{r,rrtr+r!rr7r7r8_is_boolrzSpecialMethodsChecker._is_boolcCr|)NbytesT)r8r{r,rrtr+rrr7r7r8 _is_bytesrzSpecialMethodsChecker._is_bytescCr|)NrxT)r8r{r,rrtr+rxrr7r7r8 _is_tuplerzSpecialMethodsChecker._is_tuplecCr|)NrT)r8r{r,rrtr+rrr7r7r8_is_dictrzSpecialMethodsChecker._is_dictcCs|tjurdSt|tjjrdSt|tjr*z|tWdStjy)YdSwt|t j rP| }|rPt|t j rPz|tWdStjyOYdSwdS)NTF) rprr,rR GeneratorrrG NEXT_METHODrrrur{)r^r{r7r7r8 _is_iterators.      z"SpecialMethodsChecker._is_iteratorcC ||s|jd|ddSdS)Nr9r)rrHrr7r7r8rc z!SpecialMethodsChecker._check_itercCL||s|jd|ddSt|tjr"|jdkr$|jd|ddSdSdS)Nr?rrr~rHr,rrtr+rr7r7r8rd z SpecialMethodsChecker._check_lencCr)Nr@r)rrHrr7r7r8re rz!SpecialMethodsChecker._check_boolcCr)NrArr~rHrr7r7r8rf rz"SpecialMethodsChecker._check_indexcCr)NrBrrrHrr7r7r8rg rz!SpecialMethodsChecker._check_reprcCr)NrCrrrr7r7r8rh rz SpecialMethodsChecker._check_strcCr)NrDr)rrHrr7r7r8ri rz"SpecialMethodsChecker._check_bytescCr)NrErrrr7r7r8rj rz!SpecialMethodsChecker._check_hashcCr)NrFrrrrr7r7r8rk rz(SpecialMethodsChecker._check_length_hintcCr)NrGrrrr7r7r8rl& rz#SpecialMethodsChecker._check_formatcCr)NrHr)rrHrr7r7r8rm* rz'SpecialMethodsChecker._check_getnewargscCs||s|jd|ddSt|tjsdSd}t|jdkr"d}n.|jd|jf|jd|jffD]\}}t|tjr@t |}|rO|t j urO||sOd}nq2|r[|jd|ddSdS)NrIrFTrrZ) rrHr,rrvrrkrrrrpr)r;r^r found_errorr*checkr7r7r8rn. s*   z*SpecialMethodsChecker._check_getnewargs_exr()&r(r)r*r+rr/r/rr1r2r r rrrr5rprr{r~rrrrrrrcrdrerfrgrhrirjrkrlrmrnr7r7r7r8r8s R  0         r8r c CsDi}|jddD]}z t||||<WqtjyYqw|S)zreturn a dictionary where keys are the list of base classes providing the queried method, and so that should/may be called from the method node F)recurs)rrrrpr)rrYr base_noder7r7r8rM srcCs |t||t|dS)z-required method to auto register this checkerN)register_checkerr,r8)r@r7r7r8registerZ srr()r )Fr+r itertoolsrrtypingrrrprpylint.checkersrrpylint.checkers.utilsr r r r r rrrrrrrrrrrrrrrpylint.interfacesr pylint.utilsrrrBUILTIN_DECORATORS namedtupler&r'r9rGrWr]rarfrrnrrrrrrrrrrrr0rrr,r8rrr7r7r7r8sV0 X   (:  N$   &-5=ELRX^djou| $).39>CHNW U