3
tûœ]Fj  ã            	   @   s  d Z ddlmZ ddlmZ ddlZddlmZmZm	Z	m
Z
mZmZmZmZ ddlmZ ddlmZ ddlmZ dd	lmZ dd
lmZ ddlmZ ddlmZ dZdd„ Zdd„ Zeeedd�eedd�dœƒ dd„ Zdd„ Zdd„ Zdd„ ZdYdd„Zeeejej ej!ej"ej#ej$ej%fe&d �Z'eeej ejej!ej"ej#ej$ej%fe(d �Z)eeej!ej ejej"ej$fe*d �Z+eeej"ej ejej!ej"ej$fe,d �Z-d!d"„ Z.dZd#d$„Z/d[d%d&„Z0d'd(„ Z1d\d)d*„Z2d]d+d,„Z3d^d-d.„Z4d_d/d0„Z5d`d1d2„Z6dad3d4„Z7dbd5d6„Z8d7d8„ Z9dcd9d:„Z:ddd;d<„Z;ded=d>„Z<dfd?d@„Z=dgdAdB„Z>dhdCdD„Z?didEdF„Z@ee5dGƒ ee0dHƒ ee4dIƒ ee2dJƒ ee3dKƒ ee'dLƒ ee+dMƒ ee)dNƒ ee/dOƒ ee-dPƒ ee6dQƒ ee7dRƒ ee;dSƒ ee:dTƒ ee=dUƒ ee>dVƒ ee?dWƒ ee@dXƒ ejAejBe
e8ƒe9ƒ dS )jz#Astroid hooks for various builtins.é    )Úpartial)ÚdedentN)ÚMANAGERÚUseInferenceDefaultÚAttributeInferenceErrorÚinference_tipÚInferenceErrorÚNameInferenceErrorÚAstroidTypeErrorÚMroError)Ú	arguments)ÚAstroidBuilder)Úhelpers)Únodes)Úobjects)Úscoped_nodes)Úutilzobject.__new__c             C   sx   t dƒ}|j|d�}ttƒj|ƒd }xL|jƒ D ]@}| |_d|_d|_d|j	kr\| g|j	d< |g| j	|j
< | |_q0W dS )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}
    )ÚrvalueZwhateverNÚ	__class__)r   Úformatr   r   Zstring_buildZ	mymethodsÚparentÚlinenoÚ
col_offsetÚlocalsÚname)Z
class_noder   ÚcodeZfakeÚmethod© r   úH/tmp/pip-build-fn42xldr/astroid/astroid/brain/brain_builtin_inference.pyÚ_extend_str&   s    )
r   c             C   s,   t j}x | jƒ D ]\}}||| ƒ qW d S )N)r   Zbuiltins_moduleÚitems)Zclass_transformsZbuiltin_astÚ
class_nameÚ	transformr   r   r   Ú_extend_builtins_   s    r#   zb'')r   z'')ÚbytesÚstrc             C   sZ   t | jtjƒr| jj|krdS t | jtjƒrV| jjdkoTt | jjtjƒoT| jjjdkS dS )NTÚfromkeysÚdictF)Ú
isinstanceÚfuncr   ÚNamer   Ú	AttributeÚattrnameÚexpr)ÚnodeÚbuiltin_namer   r   r   Ú_builtin_filter_predicatem   s    r0   c                s.   d‡ fdd„	}t jtjt|ƒtt|d�ƒ dS )z Register a new transform function for the given *builtin_name*.

    The transform function must accept two parameters, a node and
    an optional context.
    Nc                sJ   ˆ | |d�}|r@|j s| |_ |jd kr.| j|_|jd kr@| j|_t|gƒS )N)Úcontext)r   r   r   Úiter)r.   r1   Úresult)r"   r   r   Ú_transform_wrapper€   s    

z6register_builtin_transform.<locals>._transform_wrapper)r/   )N)r   Úregister_transformr   ÚCallr   r   r0   )r"   r/   r4   r   )r"   r   Úregister_builtin_transformy   s
    r7   c             C   sœ   | j }|s|ƒ S t| j ƒdkr$tƒ ‚|\}||ƒ}|s‚yt|j|d�ƒ}W n ttfk
rh   tƒ ‚Y nX |tjkrztƒ ‚||ƒ}| s’|tjkr˜tƒ ‚|S )Né   )r1   )	ÚargsÚlenr   ÚnextÚinferr   ÚStopIterationr   ÚUninferable)r.   r1   Z	node_typer"   r9   ÚargZtransformedÚinferredr   r   r   Ú_container_generic_inference–   s$    
rA   c             C   sÈ   t | |ƒr| S t | |ƒrTtdd„ | jD ƒƒr>dd„ | jD ƒ}q¸td ttj| jƒƒ}ndt | tjƒrŒtdd„ | j	D ƒƒszt
ƒ ‚dd„ | j	D ƒ}n,t | tjƒr´t | jtjtjfƒr´| j}nd S |j||ƒd�S )Nc             s   s   | ]}t |tjƒV  qd S )N)r(   r   ÚConst)Ú.0Úeltr   r   r   ú	<genexpr>°   s    z/_container_generic_transform.<locals>.<genexpr>c             S   s   g | ]
}|j ‘qS r   )Úvalue)rC   rD   r   r   r   ú
<listcomp>±   s    z0_container_generic_transform.<locals>.<listcomp>c             s   s   | ]}t |d  tjƒV  qdS )r   N)r(   r   rB   )rC   rD   r   r   r   rE   ·   s    c             S   s   g | ]}|d  j ‘qS )r   )rF   )rC   Úitemr   r   r   rG   ¹   s    )Úelts)r(   ÚallrI   ÚfilterÚmapr   Ú
safe_inferr   ÚDictr    r   rB   rF   ÚsixÚstring_typesÚbinary_typeZfrom_elements)r?   ÚklassÚ	iterablesÚ
build_eltsrI   r   r   r   Ú_container_generic_transform¬   s    

rU   c             C   s   t t|||d�}t| |||ƒS )N)rR   rS   rT   )r   rU   rA   )r.   r1   rR   rS   rT   Ztransform_funcr   r   r   Ú_infer_builtin_containerÃ   s    rV   )rR   rS   rT   c             C   sÊ   dd„ }yt | j|ƒƒ}W n ttfk
r8   tƒ ‚Y nX t|tjƒrN|j}nx||ƒrÀg }xj|j	D ]X}||ƒsttƒ ‚t
|j	ƒdkrˆtƒ ‚t|j	d tjtjtjfƒsªtƒ ‚|jt|j	ƒƒ qbW ntƒ ‚|S )Nc             S   s   t | tjtjtjfƒS )N)r(   r   ÚListÚTupleÚSet)Únr   r   r   Ú<lambda>ý   s    z_get_elts.<locals>.<lambda>é   r   )r;   r<   r   r	   r   r(   r   rN   r    rI   r:   rX   rB   r*   ÚappendÚtuple)r?   r1   Zis_iterabler@   r    rD   r   r   r   Ú	_get_eltsü   s&    r_   c       	      C   sÞ   t jj| ƒ}|jƒ s|jƒ r t‚|j}t|jj	ƒ ƒ}| rH| rHt
jƒ S |rb| rbdd„ |D ƒ}nXt|ƒdkr˜|r˜t|d |ƒ}dd„ |D ƒ}|| }n"t|ƒdkr´t|d |ƒ}ntƒ ‚t
j| j| j| jd�}|j|ƒ |S )aC  Try 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.
    c             S   s   g | ]\}}t j|ƒ|f‘qS r   )r   rB   )rC   ÚkeyrF   r   r   r   rG   1  s    zinfer_dict.<locals>.<listcomp>r8   r   c             S   s   g | ]\}}t j|ƒ|f‘qS r   )r   rB   )rC   r`   rF   r   r   r   rG   5  s    )r   r   r   )r   ÚCallSiteÚ	from_callZhas_invalid_argumentsZhas_invalid_keywordsr   Úpositional_argumentsÚlistÚkeyword_argumentsr    r   rN   r:   r_   r   r   r   Úpostinit)	r.   r1   Úcallr9   Úkwargsr    rI   ÚkeysrF   r   r   r   Ú
infer_dict  s(    


rj   c             C   s  t | jƒdkrt‚| jƒ }t|tjƒs*t‚|jdkr8t‚tj	|ƒ}t | jƒsj|}|jdkr`|}qÒ|j
ƒ }nhyt| jd j|d�ƒ}W n tk
rœ   t‚Y nX yt| jd j|d�ƒ}W n tk
rÐ   t‚Y nX |tjksæ|tjkrêt‚tj||||d�}| |_|S )a€  Understand 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.
    r8   Úclassmethodr   r   )r1   )Úmro_pointerÚmro_typeZ
self_classÚscope)rk   r   )r:   r9   r   rn   r(   r   ÚFunctionDefÚtyper   Zget_wrapping_classÚinstantiate_classr;   r<   r   r   r>   r   ZSuperr   )r.   r1   rn   Úclsrl   rm   Z	super_objr   r   r   Úinfer_superC  s6    






rs   c             C   s¨   t | jƒdkrt‚y0t| jd j|d�ƒ}t| jd j|d�ƒ}W n tk
rZ   t‚Y nX |tjksp|tjkr|tjtjfS t|t	j
ƒo”t|jtjƒ}|sžt‚||jfS )Nr\   é   r   )r1   r8   )r\   rt   )r:   r9   r   r;   r<   r   r   r>   r(   r   rB   rF   rO   rP   )r.   r1   ÚobjÚattrÚ	is_stringr   r   r   Ú_infer_getattr_argsz  s    
rx   c             C   s¨   t | |ƒ\}}|tjks.|tjks.t|dƒ r4tjS yt|j||d�ƒS  tttfk
rž   t	| j
ƒdkršyt| j
d j|d�ƒS  tk
r˜   t‚Y nX Y nX t‚dS )zÀUnderstand 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.
    Úigetattr)r1   rt   r\   N)rx   r   r>   Úhasattrr;   ry   r=   r   r   r:   r9   r<   r   )r.   r1   ru   rv   r   r   r   Úinfer_getattr”  s    

r{   c             C   s€   yFt | |ƒ\}}|tjks0|tjks0t|dƒ r6tjS |j||d� W n. tk
r\   tjS  tk
rt   tjdƒS X tjdƒS )aL  Understand 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.
    Úgetattr)r1   FT)	rx   r   r>   rz   r|   r   r   r   rB   )r.   r1   ru   rv   r   r   r   Úinfer_hasattr°  s    	

r}   c             C   sf   t | jƒdkrt‚| jd }yt|j|d�ƒ}W n tk
rF   tjS X |tjkrXtjS tj	|j
ƒ ƒS )zÑUnderstand 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.
    r8   r   )r1   )r:   r9   r   r;   r<   r   r   r>   r   rB   Úcallable)r.   r1   Úargumentr@   r   r   r   Úinfer_callableË  s    

r€   c             C   sŠ   t | jƒdkrt‚| js"tjdƒS | jd }yt|j|d�ƒ}W n tk
rV   tj	S X |tj	krhtj	S |j
ƒ }|tj	kr€tj	S tj|ƒS )zUnderstand bool calls.r8   Fr   )r1   )r:   r9   r   r   rB   r;   r<   r   r   r>   Ú
bool_value)r.   r1   r   r@   r�   r   r   r   Ú
infer_boolá  s    



r‚   c             C   s$   t | jƒdkrt‚tj| jd |ƒS )z+Understand the one-argument form of *type*.r8   r   )r:   r9   r   r   Zobject_type)r.   r1   r   r   r   Ú
infer_typeø  s    rƒ   c                sØ   | j }dt|ƒ  k odkn  s&t‚ttj|d�‰ ‡ fdd„|D ƒ}xH|D ]@}| s`|tjkrdt‚t|t	j
ƒstt‚t|jtdƒtfƒsLt‚qLW t|ƒdk r´|jdgdt|ƒ  ƒ t	j| j| j| jd�}|j|Ž  |S )zUnderstand `slice` calls.r   rt   )r1   c                s   g | ]}ˆ |ƒ‘qS r   r   )rC   r?   )Ú
infer_funcr   r   rG     s    zinfer_slice.<locals>.<listcomp>N)r   r   r   )r9   r:   r   r   r   rM   r   r>   r(   r   rB   rF   rp   ÚintÚextendÚSlicer   r   r   rf   )r.   r1   r9   r?   Z
slice_noder   )r„   r   Úinfer_slice   s$    

rˆ   c             C   s   t | jƒ fƒS )N)r2   rq   )r.   r1   r   r   r   Ú_infer_object__new__decorator  s    r‰   c             C   s<   | j s
dS x,| j jD ] }t|tjƒr|jƒ tkrdS qW dS )zePredicate before inference_tip

    Check if the given ClassDef has an @object.__new__ decorator
    FT)Z
decoratorsr   r(   r+   Ú	as_stringÚOBJECT_DUNDER_NEW)r.   Z	decoratorr   r   r   Ú#_infer_object__new__decorator_check!  s    rŒ   c       	   ,   C   sP  t jj| ƒ}|jrtdƒ‚t|jƒdkr>tdjt|jƒd�ƒ‚|j\}}yt|j	|d�ƒ}W n( t
k
r„ } zt|‚W Y dd}~X nX t|tjƒsštdƒ‚yt||d�}W n( t
k
rÒ } zt|‚W Y dd}~X nX ytj|||ƒ}W n^ tk
�r } ztdt|ƒ ƒ|‚W Y dd}~X n* tk
�rD } zt|‚W Y dd}~X nX tj|ƒS )	a  Infer 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 argumentsr\   z#Expected two arguments, got {count})Úcount)r1   NzTypeError: arg 1 must be classzTypeError: )r   ra   rb   re   r   r:   rc   r   r;   r<   r   r(   r   ÚClassDefÚ_class_or_tuple_to_containerr   Zobject_issubclassr
   r%   r   rB   )	Úcallnoder1   rg   Úobj_nodeÚclass_or_tuple_nodeZobj_typeÚexcÚclass_containerZissubclass_boolr   r   r   Úinfer_issubclass0  s4    
"r•   c             C   sö   t jj| ƒ}|jrtdƒ‚t|jƒdkr>tdjt|jƒd�ƒ‚|j\}}yt||d�}W n t	k
rp   t‚Y nX yt
j|||ƒ}W nX tk
r¶ } ztdt|ƒ ƒ‚W Y dd}~X n( tk
rÜ } zt|‚W Y dd}~X nX |tjkrìt‚tj|ƒ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 argumentsr\   z#Expected two arguments, got {count})r�   )r1   zTypeError: N)r   ra   rb   re   r   r:   rc   r   r�   r   r   Zobject_isinstancer
   r%   r   r   r>   r   rB   )r�   r1   rg   r‘   r’   r”   Zisinstance_boolr“   r   r   r   Úinfer_isinstance]  s,    


 
r–   c                sJ   t | jˆ d�ƒ}t|tjƒr@‡ fdd„|jD ƒ}dd„ |D ƒ}n|g}|S )N)r1   c                s   g | ]}t |jˆ d �ƒ‘qS ))r1   )r;   r<   )rC   r.   )r1   r   r   rG   �  s    z0_class_or_tuple_to_container.<locals>.<listcomp>c             S   s   g | ]}|d k	r|‘qS )Nr   )rC   Z
klass_noder   r   r   rG   ’  s    )r;   r<   r(   r   rX   rI   )r.   r1   Z
node_inferr”   r   )r1   r   r�   †  s    r�   c             C   s”   t jj| ƒ}|jrtdƒ‚t|jƒdkr>tdjt|jƒd�ƒ‚|j\}ytj	t
j||d�ƒS  ttfk
rŽ } ztt|ƒƒ|‚W Y dd}~X nX dS )zÃInfer 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 argumentsr8   z=TypeError: len() must take exactly one argument ({len}) given)r:   )r1   N)r   ra   rb   re   r   r:   rc   r   r   rB   r   Z
object_lenr
   r   r%   )r.   r1   rg   Zargument_noder“   r   r   r   Ú	infer_len™  s    r—   c             C   s^   t jj| ƒ}|jrtdƒ‚y
tjdƒS  ttfk
rX } ztt	|ƒƒ|‚W Y dd}~X nX dS )z´Infer 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 argumentsÚ N)
r   ra   rb   re   r   r   rB   r
   r   r%   )r.   r1   rg   r“   r   r   r   Ú	infer_str¯  s    
r™   c             C   sÔ   t jj| ƒ}|jrtdƒ‚|jrÊyt|jd j|d�ƒ}W n0 tk
rj } ztt	|ƒƒ|‚W Y dd}~X nX |t
jkrzt‚t|tjƒrÊt|jtt	fƒrÊyt|jƒ}W n tk
r¾   tjdƒS X tj|ƒS tjdƒS )zÈInfer 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
    z/TypeError: int() must take no keyword argumentsr   )r1   N)r   ra   rb   re   r   rc   r;   r<   r   r%   r   r>   r(   r   rB   rF   r…   Ú
ValueError)r.   r1   rg   Zfirst_valuer“   Zactual_valuer   r   r   Ú	infer_int¿  s$     

r›   c                s†  ‡fdd„}t jjˆƒ}|jr&tdƒ‚t|jƒdkr<tdƒ‚tjdƒ‰ |jd }yt	|j
|d	�ƒ}W n tk
r|   |g ƒS X |tjkr�|g ƒS tjf}t|tjtjtjfƒrî|j}x|D ]}t||ƒsº|g ƒS qºW ‡ fd
d„|D ƒ}	||	ƒS t|tjƒ�r*t|jttfƒ�r*‡ fdd„|jD ƒ}||ƒS t|tjƒ�r~|jƒ }
x"|
D ]}t||ƒ�sF|g ƒS �qFW ‡ fdd„|
D ƒ}	||	ƒS |g ƒS )aR  Infer 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.
    c                s$   t jˆ jˆ jˆ jd�}|j| ƒ |S )N)r   r   r   )r   rN   r   r   r   rf   )ÚelementsÚnew_node)r.   r   r   Ú_build_dict_with_elementsê  s    
z6infer_dict_fromkeys.<locals>._build_dict_with_elementsz/TypeError: int() must take no keyword argumentsr8   r\   z5TypeError: Needs between 1 and 2 positional argumentsNr   )r1   c                s   g | ]}|ˆ f‘qS r   r   )rC   Úelement)Údefaultr   r   rG     s    z'infer_dict_fromkeys.<locals>.<listcomp>c                s   g | ]}t j|ƒˆ f‘qS r   )r   rB   )rC   rŸ   )r    r   r   rG     s    c                s   g | ]}|ˆ f‘qS r   r   )rC   rŸ   )r    r   r   rG     s    >   r8   r\   )r   ra   rb   re   r   r:   rc   r   rB   r;   r<   r   r   r>   r(   rW   rY   rX   rI   rF   r%   r$   rN   Zitered)r.   r1   rž   rg   ÚvaluesZinferred_valuesZaccepted_iterable_elementsrœ   rŸ   Zelements_with_valueri   r`   r   )r    r.   r   Úinfer_dict_fromkeysß  sF    






r¢   ÚboolÚsuperr~   r|   rz   r^   Úsetrd   r'   Ú	frozensetrp   Úslicer(   Ú
issubclassr:   r%   r…   zdict.fromkeys)NNN)N)N)N)N)N)N)N)N)N)N)N)N)N)N)N)N)CÚ__doc__Ú	functoolsr   Útextwrapr   rO   Zastroidr   r   r   r   r   r	   r
   r   r   Zastroid.builderr   r   r   r   r   r   r‹   r   r#   r0   r7   rA   rU   rV   rX   rW   rY   Z	FrozenSetZ	DictItemsZDictKeysZ
DictValuesr^   Zinfer_tuplerd   Z
infer_listr¥   Z	infer_setr¦   Zinfer_frozensetr_   rj   rs   rx   r{   r}   r€   r‚   rƒ   rˆ   r‰   rŒ   r•   r–   r�   r—   r™   r›   r¢   r5   rŽ   r   r   r   r   Ú<module>
   sº   (
9


,
7







-
)



 
E

















