Format: application/x-python-code
1 o
2
3 �h�> � @ sf d Z ddlZddlmZ ddlmZmZ ddlmZ ddl m
4 Z
5 m Z ddl m
6 Z
7 mZ ddlmZ dd lmZ dd
8 lmZ dd lmZ dd lmZ dd
9 lmZ ddlmZ dd� Z d;dd�Z dd� Z dd� Z e� d<dd��Z dd� Z!d d � Z"d d � Z#e� d d!� �Z$d"d#� Z%d$d%� Z&d&d'� Z'd(d)� Z(d*d+� Z)d,d-� Z*d.d/� Z+d0d1� Z,d2d3� Z-d4d5� Z.d=d7d8�Z/d9d:� Z0dS )>a
10 PEP 0484 ( https://www.python.org/dev/peps/pep-0484/ ) describes type hints
11 through function annotations. There is a strong suggestion in this document
12 that only the type of type hinting defined in PEP0484 should be allowed
13 as annotations in future python versions.
14 � N)� Parameter)�ParserSyntaxError�parse)� inference_state_method_cache)�ValueSet� NO_VALUES)�DefineGenericBaseClass� GenericClass)�TupleGenericManager)�TypeVar)� is_string)�builtin_from_name)�get_executed_param_names)�debug)� parser_utilsc C sd | � |�}t|�dkrt�d||f � |S t|�d }t|�r0t| |�� �}|dur0| � |�S |S )z�
15 Inferes an annotation node. This means that it inferes the part of
16 `int` here:
17
18 foo: int = 3
19
20 Also checks for forward references (strings)
21 � z9Inferred typing index %s should lead to 1 object, not %sr N)�
22 infer_node�lenr �warning�listr �_get_forward_reference_nodeZget_safe_value)�context�
23 annotation� value_setZinferred_value�result� r �Wc:\Users\shubh\Videos\agent\nova\Lib\site-packages\jedi/inference/gradual/annotation.py�infer_annotation s
24 �
25 r c sD t | |�}|d u r tS | �|�}� d ur |�� fdd���� �}|S )Nc s | j dkott| �� ��� kS )N�tuple)�
26 array_typer r �
27 py__iter__)�value��indexr r �<lambda>8 s
28 z*_infer_annotation_string.<locals>.<lambda>)r r r �filterZpy__simple_getitem__)r �stringr# �noder r r" r �_infer_annotation_string0 s
29
30
31 ��r( c C sd z | j jj|ddd�}W n ty t�d| � Y d S w | j�� }t� ||j
32 d � | j|_ |S )NZ
33 eval_inputF)Z start_symbol�error_recoveryzAnnotation not parsed: %sr ) �inference_stateZgrammarr r r r � tree_nodeZ
34 get_root_noder �move�end_pos�parent)r r& �new_node�moduler r r r @ s
35 � �
36 r c C s� z t | dd�jd }W n ty t�d| � g Y S w |jdv r*|�� �� gS g }z|j}W n ty< g Y S w |D ]}|jdv rO|� |�� �� � q?|S )z�
37 Split decl_text on commas, but group generic expressions
38 together.
39
40 For example, given "foo, Bar[baz, biz]" we return
41 ['foo', 'Bar[baz, biz]'].
42
43 F)r) r z*Comment annotation is not valid Python: %s)�name� atom_expr�power)
44 r �childrenr r r �type�get_code�strip�AttributeError�append)Z decl_textr' �paramsr4 �childr r r � _split_comment_param_declarationQ s& �
45
46 �
47 �r< Fc C s� t | |�}|s |s |S | j}|jdkr#t|d�}tt|t|f��g�S |jdkrAt|d�}tt|d�g�|f}tt|t|��g�S |S )Nr r � �dict�str)� _infer_paramr* Z
48 star_countr
49 r r r
50 )�function_value�paramZ ignore_stars�valuesr* �tuple_�dctZgenericsr r r � infer_paramp s(
51
52
53 �
54
55 ��rF c C s� |j }|du redd� |jjD �}|jj}t�|�}|du r tS t�d|�}|s)tS t|� d��}|�
56 |�}t |�t |�krDt �
57 d||� | �� rR|dkrNtS |d8 }|t |�krZtS || } t| �� | �S | �� }
58 t|
59 |�S )zJ
60 Infers the type of a function parameter, using type annotations.
61 Nc S s g | ] }|j d kr|�qS )rB )r5 )�.0r; r r r �
62 <listcomp>� s
63 �z _infer_param.<locals>.<listcomp>z ^#\s*type:\s*\(([^#]*)\)\s*->r z&Comments length != Params length %s %sr )r r. r4 r � get_following_comment_same_liner �re�matchr< �groupr# r r r Zis_bound_methodr( �get_default_param_contextr ) rA rB r �
64 all_paramsr' �commentrK Zparams_commentsr# Z
65 param_commentr r r r r@ � s<
66
67 � �
68 r@ c C sB i }| � � D ]}|j}|d ur|||jj< q| j}|r ||d< |S )N�return)�
69 get_paramsr r1 r! )ZfuncdefrE Zfunction_paramZparam_annotation�return_annotationr r r �py__annotations__� s �rS c s" � fdd���fdd�|� � D �S )Nc sF | d u s | j dkr | S t� � jj�| j��} | d u r d S | jd } | S )Nr& r )r5 r r* Zcompiled_subprocessZsafe_literal_evalr! r4 )r' )r r r �resolve� s ��
70 z+resolve_forward_references.<locals>.resolvec s i | ] \}}|� |��qS r r )rG r1 r' )rT r r �
71 <dictcomp>� s z.resolve_forward_references.<locals>.<dictcomp>)�items)r �all_annotationsr )r rT r �resolve_forward_references� s rX c
72 s� | � � }t|t| j��}|�dd�}|du r:| j}t�|�}|du r$tS t� d|�}|s.tS t
73 ||� d�� � ��
74 � S t||�}t||�} |sJ| �
75 � S t| ||�� t�� fdd�| D ���
76 � S )zZ
77 Infers the type of a function's return value,
78 according to type annotations.
79 rP Nz%^#\s*type:\s*\([^#]*\)\s*->\s*([^#]*)r c 3 �2 � | ]}t |ttf�r|�� �nt|h�V qd S �N��
80 isinstancer r Zdefine_genericsr )rG �ann��
81 type_var_dictr r � <genexpr> s � � �
82 �z%infer_return_types.<locals>.<genexpr>)rM rX rS r+ �getr rI r rJ rK r( rL r7 �execute_annotation�find_unknown_type_varsr � infer_type_vars_for_executionr � from_sets)
83 �function� argumentsr rW r r' rO rK Zunknown_type_varsZannotation_valuesr r^ r �infer_return_types� s< �
84 ��
85
86 ��rh c C s� | � � }i }t| |�}|D ]C}z||j }W n ty Y q
87 w t||�}|rP|�|�} |�� }
88 |�� } |
89 tj u r>| �
90 � } n
91 |
92 tj u rH| � d�} t
93 || �| �� q
94 |S )aM
95 Some functions use type vars that are not defined by the class, but rather
96 only defined in the function. See for example `iter`. In those cases we
97 want to:
98
99 1. Search for undefined type vars.
100 2. Infer type vars with the execution state we have.
101 3. Return the union of all type vars that have been found.
102 Z _dict_values)rM r Z string_name�KeyErrorrc r Zget_kind�inferr �VAR_POSITIONALZmerge_types_of_iterate� VAR_KEYWORDZ try_merge�merge_type_var_dicts�infer_type_vars) rf rg Zannotation_dictr �annotation_variable_resultsZexecuted_param_namesZexecuted_param_nameZannotation_nodeZannotation_variablesZannotation_value_set�kind�actual_value_setr r r rd s0
103
104 �
105
106
107
108
109
110 ��rd c sL i � |D ]}|j dkrt| |�� �}� �|� qt�� fdd�|D ���� S )Nr c 3 rY rZ r[ )rG �v�Z
111 all_type_varsr r r` 9 s � � �
112 �z,infer_return_for_callable.<locals>.<genexpr>)r � _infer_type_vars_for_callabler �updater re rb )rg Z param_valuesZ
113 result_values�pvr_ r rs r �infer_return_for_callable2 s
114
115 ���rw c C sD i }t | �� |�D ]\\}}}|�� }|�� }t||�|�� q |S )zn
116 Infers type vars for the Calllable class:
117
118 def x() -> Callable[[Callable[..., _T]], _T]: ...
119 )�zip�unpackrj rm rn )rg Z lazy_paramsro �_Z
120 lazy_valueZlazy_callable_paramZcallable_param_valuesrq r r r rt A s �rt c C sJ |� � D ] \}}|r"z
121 | | |O < W q ty! || |< Y qw qd S rZ )rV ri )Z base_dictZnew_dictZ
122 type_var_namerC r r r rm S s ���rm c C sN i }t |t�s |S | �� }|�� }t||�D ]\}}t||�|�� �� q|S )aw
123 Match up the generic parameters from the given argument class to the
124 target annotation.
125
126 This walks the generic parameters immediately within the annotation and
127 argument's type, in order to determine the concrete values of the
128 annotation's parameters for the current case.
129
130 For example, given the following code:
131
132 def values(mapping: Mapping[K, V]) -> List[V]: ...
133
134 for val in values({1: 'a'}):
135 val
136
137 Then this function should be given representations of `Mapping[K, V]`
138 and `Mapping[int, str]`, so that it can determine that `K` is `int and
139 `V` is `str`.
140
141 Note that it is responsibility of the caller to traverse the MRO of the
142 argument type as needed in order to find the type matching the
143 annotation (in this case finding `Mapping[int, str]` as a parent of
144 `Dict[int, str]`).
145
146 Parameters
147 ----------
148
149 `annotation_value`: represents the annotation to infer the concrete
150 parameter types of.
151
152 `annotated_argument_class`: represents the annotated class of the
153 argument being passed to the object annotated by `annotation_value`.
154 )r\ r Z get_genericsrx rm rn rb )Zannotation_valueZannotated_argument_classr_ Zannotation_genericsZactual_genericsZannotation_generics_setZactual_generic_setr r r �merge_pairwise_generics\ s #
155 �r{ c C � t | ||jd |�S )Nr �� _find_type_from_comment_hintr4 �r r' r1 r r r � find_type_from_comment_hint_for� � r� c C sL t |j�dkr g S t |jd j�dksJ d��|jd jd }t| |||�S )N� r � z1Can only be here when children[1] is 'foo() as f'r= )r r4 r~ )r r' r1 �varlistr r r � find_type_from_comment_hint_with� s �r� c C r| )Nr r} r r r r �"find_type_from_comment_hint_assign� r� r� c C s� d }|j dv r!d}|jD ]}||kr n
156 |j dkrq |d7 }q g S t�|�}|d u r,g S t�d|�}|d u r8g S t| |�d��� |�� � S )N)Ztestlist_star_exprZexprlistZtestlistr �operatorr z^#\s*type:\s*([^#]*))
157 r5 r4 r rI rJ rK r( rL r7 rb )r r' r� r1 r# r; rO rK r r r r~ � s*
158
159
160
161
162 ��r~ c s � ��fdd�� g �� |� �S )Nc sp | j dv r*| jd }|j dkr$|jd dkr&t|jd �D ]
163 }� |� q d S d S d S t��| ����d d �< d S )N)r2 r3 ������trailerr �[r )r5 r4 �_unpack_subscriptlist�_filter_type_varsr )r' r� Zsubscript_node��
164 check_noder �foundr r r� � s
165
166
167 � z*find_unknown_type_vars.<locals>.check_noder )r r' r r� r rc � s rc r c C s2 t |�}| D ]}t|t�r||vr|�|� q|S rZ )r r\ r r9 )r r� Z new_foundZtype_varr r r r� � s
168 �r� c c sN � | j dkr| jd d d� D ]
169 }|j dkr|V qd S | j dkr%| V d S d S )N�
170 subscriptlistr= � subscript)r5 r4 )r� r� r r r r� � s �
171
172 ��
173
174 �r� rZ )F)r )1�__doc__rJ �inspectr Zparsor r Zjedi.inference.cacher Zjedi.inference.base_valuer r Zjedi.inference.gradual.baser r Z jedi.inference.gradual.genericsr
175 Z jedi.inference.gradual.type_varr Zjedi.inference.helpersr Zjedi.inference.compiledr
176 Zjedi.inference.paramr Zjedir r r r( r r< rF r@ rS rX rh rd rw rt rm r{ r� r� r� r~ rc r� r� r r r r �<module> sJ
177 1
178
179 *& 4
180