o b.i @s dZddlmZddlmZddlZddlmZmZm Z m Z m Z m Z m Z mZmZddlmZddlmZddlmZdd lmZdd lmZdd lmZdd lmZd ZddZddZeeeddeedddddZddZddZddZdYddZeeej ej!ej"ej#ej$ej%ej&fe'd Z(eeej!ej ej"ej#ej$ej%ej&fe)d Z*eeej"ej!ej ej#ej%fe+d Z,eeej#ej!ej ej"ej#ej%fe-d Z.d!d"Z/dZd#d$Z0dZd%d&Z1d'd(Z2dZd)d*Z3dZd+d,Z4dZd-d.Z5dZd/d0Z6dZd1d2Z7dZd3d4Z8dZd5d6Z9d7d8Z:dZd9d:Z;dZd;d<ZZ=dZd?d@Z>dZdAdBZ?dZdCdDZ@dZdEdFZAee6dGee1dHee5dIee3dJee4dKee(dLee,dMee*dNee0dOee.dPee7dQee8dReedUee?dVee@dWeeAdXeBejCe e9e:dS)[z#Astroid hooks for various builtins.)partial)dedentN) MANAGERInstanceUseInferenceDefaultAttributeInferenceError inference_tipInferenceErrorNameInferenceErrorAstroidTypeErrorMroError) arguments)AstroidBuilder)helpers)nodes)objects) scoped_nodes)utilzobject.__new__cCsttd}|j|d}tt|d}|D] }||_d|_d|_d|j vr-|g|j d<|g|j |j <||_qdS)z,function to extend builtin str/unicode classa$ class whatever(object): def join(self, iterable): return {rvalue} def replace(self, old, new, count=None): return {rvalue} def format(self, *args, **kwargs): return {rvalue} def encode(self, encoding='ascii', errors=None): return '' def decode(self, encoding='ascii', errors=None): return u'' def capitalize(self): return {rvalue} def title(self): return {rvalue} def lower(self): return {rvalue} def upper(self): return {rvalue} def swapcase(self): return {rvalue} def index(self, sub, start=None, end=None): return 0 def find(self, sub, start=None, end=None): return 0 def count(self, sub, start=None, end=None): return 0 def strip(self, chars=None): return {rvalue} def lstrip(self, chars=None): return {rvalue} def rstrip(self, chars=None): return {rvalue} def rjust(self, width, fillchar=None): return {rvalue} def center(self, width, fillchar=None): return {rvalue} def ljust(self, width, fillchar=None): return {rvalue} rvalueZwhateverN __class__) rformatrrZ string_buildZ mymethodsparentlineno col_offsetlocalsname)Z class_nodercodeZfakemethodrd/var/www/secure340b-portal/env/lib/python3.10/site-packages/astroid/brain/brain_builtin_inference.py _extend_str's +   r!cCs(tj}|D] \}}|||qdSN)rZbuiltins_moduleitems)Zclass_transformsZ builtin_ast class_name transformrrr _extend_builtins`sr&zb''rz'')bytesstrcCsZt|jtjr|jj|krdSt|jtjr+|jjdko*t|jjtjo*|jjjdkSdS)NTfromkeysdictF) isinstancefuncrNamer Attributeattrnameexpr)node builtin_namerrr _builtin_filter_predicatens  r3cs.dfdd }ttjt|tt|ddS)zRegister a new transform function for the given *builtin_name*. The transform function must accept two parameters, a node and an optional context. NcsJ||d}|r |js||_|jdur|j|_|jdur |j|_t|gS)Ncontext)rrriter)r1r5resultr%rr _transform_wrappers    z6register_builtin_transform.._transform_wrapper)r2r")rregister_transformrCallrrr3)r%r2r9rr8r register_builtin_transformzs  r<c Cs|j}|s|St|jdkrt|\}||}|s>z t|j|d}Wn ttfy1tw|tjur:t||}|rE|tjurHt|S)Nr4) argslenrnextinferr StopIterationr Uninferable)r1r5Z node_typer%r>argZ transformedinferredrrr _generic_inferences& rFcCst||r|St||r"tdd|jDstdd|jD}n2t|tjr>tdd|jDs5tdd|jD}nt|tjrRt|jt j t j frR|j}ndS|j ||dS)Ncss|] }t|tjVqdSr"r+rConst.0eltrrr sz%_generic_transform..cSsg|]}|jqSrvaluerIrrr sz&_generic_transform..css |] }t|dtjVqdS)rNrGrIrrr rLscSsg|]}|djqS)rrM)rJitemrrr rO)elts) r+allrRrrDictr#rHrNsix string_types binary_typeZfrom_constants)rDklass iterables build_eltsrRrrr _generic_transforms   r[cCstt|||d}t||||S)NrXrYrZ)rr[rF)r1r5rXrYrZZtransform_funcrrr _infer_builtinsr]r\c Csdd}z t||}Wn ttfytwt|tjr%|j}|S||r]g}|j D],}||s7tt |j dkrAtt|j dtj tj tj fsRt|t|j q.|St)NcSst|tjtjtjfSr")r+rListTupleSet)nrrr rQz_get_elts..r)r@rAr r rr+rrTr#rRr?r_rHr-appendtuple)rDr5 is_iterablerEr#rKrrr _get_eltss*  rgc Cstj|}|s|rt|j}t|j }|s"|s"t S|r.|s.dd|D}n,t |dkrI|rIt |d|}dd|D}||}nt |dkrWt |d|}ntt j |j|j|jd}|||S)aCTry to infer a dict call to a Dict node. The function treats the following cases: * dict() * dict(mapping) * dict(iterable) * dict(iterable, **kwargs) * dict(mapping, **kwargs) * dict(**kwargs) If a case can't be inferred, we'll fallback to default inference. cSg|] \}}t||fqSrrrHrJkeyrNrrr rO*zinfer_dict..r=rcSrhrrirjrrr rO.rlrrr)r CallSite from_callZhas_invalid_argumentsZhas_invalid_keywordsrpositional_argumentslistkeyword_argumentsr#rrTr?rgrrrpostinit) r1r5callr>kwargsr#rRkeysrNrrr infer_dicts*     rwcCst|jdkr t|}t|tjst|jdvrtt |}t|js5|}|jdkr0|}n3| }n.z t |jdj |d}Wn t yKtwz t |jdj |d}Wn t ybtw|tjusm|tjurottj||||d}||_|S)aUnderstand super calls. There are some restrictions for what can be understood: * unbounded super (one argument form) is not understood. * if the super call is not inside a function (classmethod or method), then the default inference will be used. * if the super arguments can't be inferred, the default inference will be used. r=) classmethodrrxrr4) mro_pointermro_typeZ self_classscope)r?r>rr{r+r FunctionDeftyperZget_wrapping_classinstantiate_classr@rAr rrCrZSuperr)r1r5r{clsryrzZ super_objrrr infer_super<s<         rcCst|jdvr tzt|jdj|d}t|jdj|d}Wn ty*tw|tjus5|tjur;tjtjfSt|t j oGt|j t j }|sLt||j fS)N)rcrr4r=)r?r>rr@rAr rrCr+rrHrNrUrV)r1r5objattr is_stringrrr _infer_getattr_argsss    rc Cst||\}}|tjus|tjust|dstjSz t|j||dWStttfyOt |j dkrLzt|j dj |dWYStyKt wYt w)zUnderstand getattr calls If one of the arguments is an Uninferable object, then the result will be an Uninferable object. Otherwise, the normal attribute lookup will be done. igetattrr4rrc) rrrChasattrr@rrBr rr?r>rArr1r5rrrrr infer_getattrs( rcCsz#t||\}}|tjus|tjust|dstjWS|j||dWnty/tjYSty<tdYSwtdS)aLUnderstand hasattr calls This always guarantees three possible outcomes for calling hasattr: Const(False) when we are sure that the object doesn't have the intended attribute, Const(True) when we know that the object has the attribute and Uninferable when we are unsure of the outcome of the function call. getattrr4FT) rrrCrrrrrrHrrrr infer_hasattrs      rcCsht|jdkr t|jd}z t|j|d}Wn ty$tjYSw|tjur-tjSt | S)zUnderstand callable calls This follows Python's semantics, where an object is callable if it provides an attribute __call__, even though that attribute is something which can't be called. r=rr4) r?r>rr@rAr rrCrrHcallable)r1r5argumentrErrr infer_callables    rcCst|jdkr t|jstdS|jd}z t|j|d}Wn ty,tj YSw|tj ur5tj S| }|tj urAtj St|S)zUnderstand bool calls.r=Frr4) r?r>rrrHr@rAr rrC bool_value)r1r5rrErrrr infer_bools        rcCs$t|jdkr tt|jd|S)z+Understand the one-argument form of *type*.r=r)r?r>rrZ object_typer1r5rrr infer_typesrcs|j}dt|krdksttttj|dfdd|D}|D]}|r.|tjur0tt|t j s8tt|j t dt fsDtq%t|dkrW|dgdt|t j|j|j|jd}|j||S)zUnderstand `slice` calls.rrr4csg|]}|qSrr)rJrDZ infer_funcrr rOzinfer_slice..N)rrr)r>r?rrrZ safe_inferrrCr+rrHrNr}intextendSlicerrrrs)r1r5r>rDZ slice_noderrr infer_slices,    rcCst|fSr")r6r~rrrr _infer_object__new__decoratorsrcCs:|jsdS|jjD]}t|tjr|tkrdSq dS)zePredicate before inference_tip Check if the given ClassDef has an @object.__new__ decorator FT)Z decoratorsrr+r. as_stringOBJECT_DUNDER_NEW)r1 decoratorrrr #_infer_object__new__decorator_checks   rc Cs$tj|}|jr tdt|jdkrtdjt|jd|j\}}z t|j |d}Wnt y=}zt|d}~wwt |t j sHtdzt||d}Wnt y_}zt|d}~wwz t|||}Wn#ty~}z tdt||d}~wty}zt|d}~wwt |S) aInfer issubclass() calls :param nodes.Call callnode: an `issubclass` call :param InferenceContext: the context for the inference :rtype nodes.Const: Boolean Const value of the `issubclass` call :raises UseInferenceDefault: If the node cannot be inferred z2TypeError: issubclass() takes no keyword argumentsrc#Expected two arguments, got {count}countr4NzTypeError: arg 1 must be class TypeError: )r rnrorrrr?rprr@rAr r+rClassDef_class_or_tuple_to_containerrZobject_issubclassr r(r rH) callnoder5rtobj_nodeclass_or_tuple_nodeobj_typeexcclass_containerZissubclass_boolrrr infer_issubclass)sH     rc Cstj|}|jr tdt|jdkrtdjt|jd|j\}}zt||d}Wn t y5twz t |||}Wn"t yS}ztdt |d}~wtya}zt|d}~ww|tjuritt|S)a@Infer isinstance calls :param nodes.Call callnode: an isinstance call :param InferenceContext: context for call (currently unused but is a common interface for inference) :rtype nodes.Const: Boolean Const value of isinstance call :raises UseInferenceDefault: If the node cannot be inferred z2TypeError: isinstance() takes no keyword argumentsrcrrr4rN)r rnrorrrr?rprrr rZobject_isinstancer r(r rrCrrH)rr5rtrrrZisinstance_boolrrrr infer_isinstanceVs:     rcsLt|jd}t|tjr!fdd|jD}dd|D}|S|g}|S)Nr4csg|] }t|jdqS)r4)r@rA)rJr1r4rr rOsz0_class_or_tuple_to_container..cSsg|]}|dur|qSr"r)rJZ klass_noderrr rOs )r@rAr+rr_rR)r1r5Z node_inferrrr4r rs  rc Cstj|}|jr tdt|jdkrtdjt|jd|j\}z t t |WSt t fyA}ztt||d}~ww)zInfer length calls :param nodes.Call node: len call to infer :param context.InferenceContext: node context :rtype nodes.Const: a Const node with the inferred length, if possible z/TypeError: len() must take no keyword argumentsr=z=TypeError: len() must take exactly one argument ({len}) given)r?N)r rnrorrrr?rprrrHrZ object_lenr r r()r1r5rtZ argument_noderrrr infer_lens  rc CsRtj|}|jr tdztdWSttfy(}ztt ||d}~ww)zInfer str() calls :param nodes.Call node: str() call to infer :param context.InferenceContext: node context :rtype nodes.Const: a Const containing an empty string z/TypeError: str() must take no keyword argumentsN) r rnrorrrrrHr r r()r1r5rtrrrr infer_strs  rc Cstj|}|jr td|jraz t|jdj|d}Wnty0}ztt ||d}~ww|t j ur8tt |t jrat |jtt frazt|j}Wnty[t dYSwt |St dS)zInfer int() calls :param nodes.Call node: int() call to infer :param context.InferenceContext: node context :rtype nodes.Const: a Const containing the integer value of the int() call /TypeError: int() must take no keyword argumentsrr4N)r rnrorrrrpr@rAr r(rrCr+rrHrNr ValueError)r1r5rtZ first_valuerZ actual_valuerrr infer_ints,      rc s~fdd}tj}|jrtdt|jdvrtdtd|jd}z t |j |d}Wn t y?|gYSw|t j urI|gStjf}t|tjtjtjfrx|j}|D] }t||sj|gSq]fd d |D} || St|tjrt|jttfrfd d |jD}||St|tjr|} | D] } t| |s|gSqfd d | D} || S|gS) aRInfer dict.fromkeys :param nodes.Call node: dict.fromkeys() call to infer :param context.InferenceContext: node context :rtype nodes.Dict: a Dictionary containing the values that astroid was able to infer. In case the inference failed for any reason, an empty dictionary will be inferred instead. cs$tjjjjd}|||S)Nrm)rrTrrrrs)elementsnew_node)r1rr _build_dict_with_elementss   z6infer_dict_fromkeys.._build_dict_with_elementsr>r=rcz5TypeError: Needs between 1 and 2 positional argumentsNrr4cg|]}|fqSrrrJelementdefaultrr rOrz'infer_dict_fromkeys..csg|] }t|fqSrrirrrr rO scrrrrrrr rOr)r rnrorrrr?rprrHr@rAr rrCr+r^r`r_rRrNr(r'rTZitered) r1r5rrtvaluesZinferred_valuesZaccepted_iterable_elementsrrZelements_with_valuervrkr)rr1r infer_dict_fromkeyssT             rboolsuperrrrresetrqr* frozensetr}slicer+ issubclassr?r(rz dict.fromkeys)NNNr")D__doc__ functoolsrtextwraprrUZastroidrrrrrr r r r r Zastroid.builderrrrrrrrr!r&r3r<rFr[r]r_r^r` FrozenSetZ DictItemsZDictKeysZ DictValuesreZ infer_tuplerqZ infer_listrZ infer_setrZinfer_frozensetrgrwrrrrrrrrrrrrrrrrrr:rrrrr s  ,      9       ,7         - )    E