a
    lc`&                     @   s   d Z ddlZddlZddlmZmZ ddlmZ ddlm	Z	 ddl
mZmZmZ ddlmZ g dZed	ejed
ejgZedZdadd Zdd Zdd Zdd Zdd Zdd Zdd Zdd Zdd Ze	 dd Ze	 ed d! Z dS )"a  
Docstrings are another source of information for functions and classes.
:mod:`jedi.inference.dynamic_params` tries to find all executions of functions,
while the docstring parsing is much easier. There are three different types of
docstrings that |jedi| understands:

- `Sphinx <http://sphinx-doc.org/markup/desc.html#info-field-lists>`_
- `Epydoc <http://epydoc.sourceforge.net/manual-fields.html>`_
- `Numpydoc <https://github.com/numpy/numpy/blob/master/doc/HOWTO_DOCUMENT.rst.txt>`_

For example, the sphinx annotation ``:type foo: str`` clearly states that the
type of ``foo`` is ``str``.

As an addition to parameter searching, this module also provides return
annotations.
    N)parseParserSyntaxError)debug)inference_state_method_cache)iterator_to_value_setValueSet	NO_VALUES)LazyKnownValues)z\s*:type\s+%s:\s*([^\n]+)z\s*:param\s+(\w+)\s+%s:[^\n]*z\s*@type\s+%s:\s*([^\n]+)z\s*:rtype:\s*([^\n]+)z\s*@rtype:\s*([^\n]+)z:[^`]+:`([^`]+)`c                  C   s&   t tttfrtddlm}  | atS )Nr   NumpyDocString)
isinstance_numpy_doc_string_cacheImportErrorSyntaxErrorZnumpydoc.docscraper   r
    r   U/var/www/html/django/DPS/env/lib/python3.9/site-packages/jedi/inference/docstrings.py_get_numpy_doc_string_cls/   s
    r   c              	   C   s   t  T t d zt | jd }W n$ tyL   g  Y W  d   S 0 W d   n1 sb0    Y  |D ]<\}}}||krptd|}|r|d}t	t
|  S qpg S )zASearch `docstr` (in numpydoc format) for type(-s) of `param_str`.ignoreZ
ParametersNz"([^,]+(,[^,]+)*?)(,[ ]*optional)?$   )warningscatch_warningssimplefilterr   _parsed_data	Exceptionrematchgrouplist_expand_typestr)docstr	param_strparamsZp_namep_typeZp_descrmr   r   r   _search_param_in_numpydocstr8   s    

6
r$   c              	   c   s   t  J t d zt | }W n  tyB   Y W d   dS 0 W d   n1 sX0    Y  z|jd }||jd 7 }W n ty   Y dS 0 |D ] \}}}|s|}t|E dH  qdS )zP
    Search `docstr` (in numpydoc format) for type(-s) of function returns.
    r   NZReturnsZYields)r   r   r   r   r   r   r   )r   docreturnsZr_nameZr_typeZr_descrr   r   r   _search_return_in_numpydocstrK   s    

2
r'   c                 c   s   t d| r2| dD ]}|dd  V  qnt d| rP| dd V  n| drt| ddjd }|jd	krt|jd
 dg D ]N}|jdkrd|j	v rdV  qdV  q|jdkrd|j
 v rdV  qdV  qn| V  dS )z@
    Attempts to interpret the possible types in `type_str`
    z\bor\borZofr   z\bof\b{z3.7)versionatomr   childrennumber.floatintstringbbytesstrN)r   searchsplitstrip
startswithr   r,   typegetattrvalueZstring_prefixlower)type_strtnodeleafr   r   r   r   c   s$    





r   c                    sH    fddt D }|D ]&}|| }|rt|dg  S qt|  S )a  
    Search `docstr` for type(-s) of `param_str`.

    >>> _search_param_in_docstr(':type param: int', 'param')
    ['int']
    >>> _search_param_in_docstr('@type param: int', 'param')
    ['int']
    >>> _search_param_in_docstr(
    ...   ':type param: :class:`threading.Thread`', 'param')
    ['threading.Thread']
    >>> bool(_search_param_in_docstr('no document', 'param'))
    False
    >>> _search_param_in_docstr(':param int param: some description', 'param')
    ['int']

    c                    s    g | ]}t |t   qS r   )r   compileescape.0pr    r   r   
<listcomp>   s   z+_search_param_in_docstr.<locals>.<listcomp>r   )DOCSTRING_PARAM_PATTERNSr5   _strip_rst_roler   r$   )r   r    patternspatternr   r   rF   r   _search_param_in_docstr   s    

rL   c                 C   s    t | }|r|dS | S dS )a  
    Strip off the part looks like a ReST role in `type_str`.

    >>> _strip_rst_role(':class:`ClassName`')  # strip off :class:
    'ClassName'
    >>> _strip_rst_role(':py:obj:`module.Object`')  # works with domain
    'module.Object'
    >>> _strip_rst_role('ClassName')  # do nothing when not ReST role
    'ClassName'

    See also:
    http://sphinx-doc.org/domains.html#cross-referencing-python-objects

    r   N)REST_ROLE_PATTERNr   r   )r=   r   r   r   r   rI      s    

rI   c           	   	   C   s   |d u rg S t d|}ddd |D }| d| }tjd|dd | jj}z|j|dd	}W n tyz   g  Y S 0 z|j	d
 }W n t
tfy   g  Y S 0 |jdvrg S ddlm} || | j|g d}tt| |S )Nz((?:\w+\.)*\w+)\.
c                 s   s   | ]}d | V  qdS )zimport Nr   rC   r   r   r   	<genexpr>       z._infer_for_statement_string.<locals>.<genexpr>zParse docstring code %sBLUEcolorF)Zerror_recovery)namer+   Z	atom_exprr   )DocstringModule)Zin_module_contextinference_stateZmodule_nodeZ
code_lines)r   findalljoinr   dbgrW   grammarr   r   r,   AttributeError
IndexErrorr9   Zjedi.inference.docstring_utilsrV   r   _execute_types_in_stmtZ
as_context)	module_contextr1   Zpotential_importsZimportsr[   modulestmtrV   r#   r   r   r   _infer_for_statement_string   s2    


rb   c                    s"     |}t fdd|D S )z
    Executing all types or general elements that we find in a statement. This
    doesn't include tuple, list and dict literals, because the stuff they
    contain is executed. (Used as type information).
    c                 3   s   | ]}t  j|V  qd S N)_execute_array_valuesrW   )rD   dr_   r   r   rO      s   z)_execute_types_in_stmt.<locals>.<genexpr>)Z
infer_noder   	from_sets)r_   ra   Zdefinitionsr   rf   r   r^      s    
r^   c           	         s   ddl m}m}m} t||r|jdv rg }| D ].}t fdd|	 D }|
t| q4|jdkrr|n|}| |hS | S dS )z
    Tuples indicate that there's not just one return value, but the listed
    ones.  `(str, int)` means that it returns a tuple with both types.
    r   )SequenceLiteralValue	FakeTupleFakeList)tupler   c                 3   s   | ]}t  |V  qd S rc   )rd   )rD   typrW   r   r   rO      s   z(_execute_array_values.<locals>.<genexpr>rk   N)Zjedi.inference.value.iterablerh   ri   rj   r   Z
array_typeZ
py__iter__r   rg   Zinferappendr	   Zexecute_annotation)	rW   arrayrh   ri   rj   valuesZ
lazy_valueobjectsclsr   rm   r   rd      s    rd   c                    sr    fdd}|     }|jdkr,tS ||  }|  r^|  dkr^||| j O }tj	d|dd |S )Nc                    s    t  fddt| jjD S )Nc                 3   s"   | ]}t  |D ]
}|V  qqd S rc   )rb   )rD   r    rE   rf   r   r   rO      s   z7infer_param.<locals>.infer_docstring.<locals>.<genexpr>)r   rL   rU   r;   )	docstringr_   paramr   r   infer_docstring   s    z$infer_param.<locals>.infer_docstringZlambdef__init__z#Found param types for docstring: %srQ   rR   )
get_root_contextZget_parent_functionr9   r   	py__doc__Zis_bound_methodZ
py__name__Zclass_contextr   rZ   )function_valueru   rv   functypesr   rt   r   infer_param   s    

r}   c                 c   s2   dd }||   D ]}t|  |E d H  qd S )Nc                 s   s:   t D ]"}|| }|rt|dV  qt| E d H  d S )Nr   )DOCSTRING_RETURN_PATTERNSr5   rI   r   r'   )coderE   r   r   r   r   search_return_in_docstr  s
    
z3infer_return_types.<locals>.search_return_in_docstr)ry   rb   rx   )rz   r   r=   r   r   r   infer_return_types  s    r   )!__doc__r   r   Zparsor   r   Zjedir   Zjedi.inference.cacher   Zjedi.inference.base_valuer   r   r   Zjedi.inference.lazy_valuer	   rH   rA   Mr~   rM   r   r   r$   r'   r   rL   rI   rb   r^   rd   r}   r   r   r   r   r   <module>   s6   
	!%
