U
    -e`&                     @   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 dd	d
g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)LazyKnownValuesz\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   Z/var/www/html/Darija-Ai-Train/env/lib/python3.8/site-packages/jedi/inference/docstrings.py_get_numpy_doc_string_cls/   s
    r   c              
   C   s   t  J t d zt | jd }W n$ tk
rL   g  Y W  5 Q R  S X W 5 Q R X |D ]<\}}}||kr\td|}|r|d}t	t
|  S q\g S )zASearch `docstr` (in numpydoc format) for type(-s) of `param_str`.ignoreZ
Parametersz"([^,]+(,[^,]+)*?)(,[ ]*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    

 
r$   c              	   c   s   t  @ t d zt | }W n  tk
rB   Y W 5 Q R  dS X W 5 Q R X z|jd }||jd 7 }W n tk
r   Y dS X |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   docZreturnsZr_nameZr_typeZr_descrr   r   r   _search_return_in_numpydocstrK   s    


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	krdV  qdV  q|jdkrd|j
 k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_PATTERNSr4   _strip_rst_roler   r$   )r   r    patternspatternr   r   rE   r   _search_param_in_docstr   s    

rK   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   rH      s    

rH   c           	   	   C   s   |d krg S t d|}ddd |D }| d| }tjd|dd | jj}z|j|dd	}W n tk
r|   g  Y S X z|j	d
 }W n t
tfk
r   g  Y S X |jdk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   rB   r   r   r   	<genexpr>   s     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   dbgrU   grammarr   r   r+   AttributeError
IndexErrorr8   Zjedi.inference.docstring_utilsrT   r   _execute_types_in_stmtZ
as_context)	module_contextr0   Zpotential_importsZimportsrY   modulestmtrT   r#   r   r   r   _infer_for_statement_string   s2    


r`   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_valuesrU   )rC   dr]   r   r   rN      s   z)_execute_types_in_stmt.<locals>.<genexpr>)Z
infer_noder   	from_sets)r]   r_   Zdefinitionsr   rd   r   r\      s    
r\   c           	         s   ddl m}m}m} t||r|jdk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 ra   )rb   )rC   typrU   r   r   rN      s   z(_execute_array_values.<locals>.<genexpr>ri   N)Zjedi.inference.value.iterablerf   rg   rh   r   Z
array_typeZ
py__iter__r   re   Zinferappendr	   Zexecute_annotation)	rU   arrayrf   rg   rh   valuesZ
lazy_valueobjectsclsr   rk   r   rb      s    rb   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 ra   )r`   )rC   r    rD   rd   r   r   rN      s    z7infer_param.<locals>.infer_docstring.<locals>.<genexpr>)r   rK   rS   r:   )Z	docstringr]   paramr   r   infer_docstring   s    z$infer_param.<locals>.infer_docstringZlambdef__init__z#Found param types for docstring: %srO   rP   )
get_root_contextZget_parent_functionr8   r   	py__doc__Zis_bound_methodZ
py__name__Zclass_contextr   rX   )function_valuerr   rs   functypesr   rq   r   infer_param   s    

rz   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_PATTERNSr4   rH   r   r&   )coderD   r   r   r   r   search_return_in_docstr  s
    
z3infer_return_types.<locals>.search_return_in_docstr)rv   r`   ru   )rw   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	   rG   r@   Mr{   rL   r   r   r$   r&   r   rK   rH   r`   r\   rb   rz   r~   r   r   r   r   <module>   s<   
	!%
