Файловый менеджер - Редактировать - /opt/imh-python/lib/python3.9/site-packages/parso/python/__pycache__/tree.cpython-39.pyc
Ðазад
a e�hj� � @ s� d Z ddlZzddlmZ W n ey: ddlmZ Y n0 ddlmZ ddlm Z m Z m Z m Z m Z mZ ddlmZ ddlmZ eg d��Zed d g�eB Zeg d ��eB Zeg d ��Zed dg�ZG dd� d�ZG dd� d�ZG dd� dee �ZG dd� de�Z G dd� dee �Z G dd� dee �Z G dd � d ee �Z G d d � d e e�Z G d d � d e �Z!G d!d"� d"e�Z"G d#d$� d$e �Z#G d%d&� d&e�Z$G d'd(� d(e$�Z%G d)d*� d*e$�Z&G d+d,� d,e�Z'G d-d.� d.e�Z(G d/d0� d0e�Z)G d1d2� d2�Z*G d3d4� d4e e*�Z+G d5d6� d6e e*�Z,G d7d8� d8e e�Z-G d9d:� d:e-�Z.G d;d<� d<e �Z/G d=d>� d>e-�Z0G d?d@� d@e0�Z1dAdB� Z2G dCdD� dDe0�Z3G dEdF� dFe3�Z4G dGdH� dHe �Z5G dIdJ� dJe5�Z6G dKdL� dLe5�Z7G dMdN� dNe5�Z8G dOdP� dPe5�Z9G dQdR� dRe5�Z:G dSdT� dTe �Z;G dUdV� dVe;�Z<G dWdX� dXe;�Z=G dYdZ� dZe �Z>G d[d\� d\e>�Z?G d]d^� d^e>�Z@G d_d`� d`e>�ZAG dadb� dbe �ZBdcdd� ZCG dedf� dfe e�ZDG dgdh� dhe �ZEG didj� dje �ZFG dkdl� dle �ZGeGZHG dmdn� dne�ZIdS )oa This is the syntax tree for Python 3 syntaxes. The classes represent syntax elements like functions and imports. All of the nodes can be traced back to the `Python grammar file <https://docs.python.org/3/reference/grammar.html>`_. If you want to know how a tree is structured, just analyse that file (for each Python version it's a bit different). There's a lot of logic here that makes it easier for Jedi (and other libraries) to deal with a Python syntax tree. By using :py:meth:`parso.tree.NodeOrLeaf.get_code` on a module, you can get back the 1-to-1 representation of the input given to the parser. This is important if you want to refactor a parser tree. >>> from parso import parse >>> parser = parse('import os') >>> module = parser.get_root_node() >>> module <Module: @1-1> Any subclasses of :class:`Scope`, including :class:`Module` has an attribute :attr:`iter_imports <Scope.iter_imports>`: >>> list(module.iter_imports()) [<ImportName: import os@1,0>] Changes to the Python Grammar ----------------------------- A few things have changed when looking at Python grammar files: - :class:`Param` does not exist in Python grammar files. It is essentially a part of a ``parameters`` node. |parso| splits it up to make it easier to analyse parameters. However this just makes it easier to deal with the syntax tree, it doesn't actually change the valid syntax. - A few nodes like `lambdef` and `lambdef_nocond` have been merged in the syntax tree to make it easier to do deal with them. Parser Tree Classes ------------------- � N)�Mapping)�Tuple)�Node�BaseNode�Leaf� ErrorNode� ErrorLeaf�search_ancestor)� split_prefix)� split_lines)�if_stmt� while_stmt�for_stmt�try_stmt� with_stmtZ async_stmt�suiter � simple_stmt)r r � decorated� async_funcdef) � expr_stmt� sync_comp_forr r � import_name� import_from�paramZdel_stmt�namedexpr_testr r c @ s e Zd ZdZdd� ZdS )�DocstringMixin� c C s� | j dkr| jd }nb| j dv rL| j| j�d�d }|j dkrx|jd }n,| j}|jj}|�|�}|sldS ||d }|j dkr�|jd }|j d kr�|S dS ) zN Returns the string leaf of a docstring. e.g. ``r'''foo'''``. � file_inputr ��funcdef�classdef�:� r Nr �string)�type�children�index�parent)�self�noder �cr& r r ��/root/rpmbuild/BUILDROOT/imh-python39-modules-3.9.7-92.el8.x86_64/opt/imh-python/lib/python3.9/site-packages/parso/python/tree.py� get_doc_nodeJ s" zDocstringMixin.get_doc_nodeN)�__name__� __module__� __qualname__� __slots__r, r r r r+ r G s r c @ s e Zd ZdZdZdd� ZdS )� PythonMixinz) Some Python specific utilities. r c C sd | j D ]X}t|t�rD|jdkr^|j| kr6|jkr^n q^| S q|�|�}|dur| S qdS )z� Given a (line, column) tuple, returns a :py:class:`Name` or ``None`` if there is no name at that position. �nameN)r% � isinstancer r$ � start_pos�end_pos�get_name_of_position)r( �positionr* �resultr r r+ r6 i s & z PythonMixin.get_name_of_positionN)r- r. r/ �__doc__r0 r6 r r r r+ r1 c s r1 c @ s e Zd ZdZdd� Zdd� ZdS )� PythonLeafr c C s t | | �� �S �N)r �get_start_pos_of_prefix�r( r r r+ � _split_prefix| s zPythonLeaf._split_prefixc C sZ | � � }|dur,|jdkr,|jdv r,|� � }|du rTt| j�}| jt|� d dfS |jS )z[ Basically calls :py:meth:`parso.tree.NodeOrLeaf.get_start_pos_of_prefix`. NZ error_leaf)�INDENT�DEDENTZ ERROR_DEDENTr" r )Zget_previous_leafr$ � token_typer �prefix�line�lenr5 )r( Z previous_leaf�linesr r r+ r< s � z"PythonLeaf.get_start_pos_of_prefixN)r- r. r/ r0 r> r< r r r r+ r: y s r: c @ s. e Zd ZdZdZeeeef d�dd��ZdS )�_LeafWithoutNewlinesz. Simply here to optimize performance. r )�returnc C s | j | jt| j� fS r; )rC �columnrD �valuer= r r r+ r5 � s z _LeafWithoutNewlines.end_posN) r- r. r/ r9 r0 �propertyr �intr5 r r r r+ rF � s rF c @ s e Zd ZdZdS )�PythonBaseNoder N�r- r. r/ r0 r r r r+ rL � s rL c @ s e Zd ZdZdS )� PythonNoder NrM r r r r+ rN � s rN c @ s e Zd ZdZdS )�PythonErrorNoder NrM r r r r+ rO � s rO c @ s e Zd ZdZdS )�PythonErrorLeafr NrM r r r r+ rP � s rP c @ s e Zd ZdZdZdd� ZdS )� EndMarkerr Z endmarkerc C s dt | �jt| j�| jf S )Nz<%s: prefix=%s end_pos=%s>)r$ r- �reprrB r5 r= r r r+ �__repr__� s �zEndMarker.__repr__N)r- r. r/ r0 r$ rS r r r r+ rQ � s rQ c @ s e Zd ZdZdZdZdd� ZdS )�Newlinez&Contains NEWLINE and ENDMARKER tokens.r �newlinec C s dt | �jt| j�f S )N�<%s: %s>)r$ r- rR rI r= r r r+ rS � s zNewline.__repr__N)r- r. r/ r9 r0 r$ rS r r r r+ rT � s rT c @ s4 e Zd ZdZdZdZdd� Zd dd�Zd d d �Zd S )�Nameza A string. Sometimes it is important to know if the string belongs to a name or not. r2 r c C s dt | �j| j| j| jf S )Nz<%s: %s@%s,%s>)r$ r- rI rC rH r= r r r+ rS � s �z Name.__repr__Fc C s | j |d�duS )z< Returns True if the name is being defined. )�include_setitemN)�get_definition�r( rX r r r+ � is_definition� s zName.is_definitionc C s� | j }|j}|dv r&| |jkr"|S dS |dkrD| �� dkr@|j S dS |dur�|jdkrZdS |jtv r�| |�|�v rv|S |r�|jtv r�|S dS |j }qDdS )z� Returns None if there's no definition for a name. :param import_name_always: Specifies if an import name is always a definition. Normally foo in `from foo import bar` is not a definition. r N� except_clause�asr )r' r$ r2 Zget_previous_sibling�_GET_DEFINITION_TYPES�get_defined_names�_IMPORTS)r( Zimport_name_alwaysrX r) �type_r r r+ rY � s* zName.get_definitionN)F)FF) r- r. r/ r9 r$ r0 rS r[ rY r r r r+ rW � s rW c @ s e Zd ZdZdS )�Literalr NrM r r r r+ rb � s rb c @ s e Zd ZdZdZdS )�Number�numberr N�r- r. r/ r$ r0 r r r r+ rc � s rc c @ s( e Zd ZdZdZedd� �Zdd� ZdS )�Stringr# r c C s t �d| j��d�S )Nz \w*(?=[\'"])r )�re�matchrI �groupr= r r r+ � string_prefix s zString.string_prefixc C s2 t jd| jt jd�}|�d�d t|�d�� � S )Nz('{3}|"{3}|'|")(.*)$)�flags� r" )rg �searchrI �DOTALLri rD )r( rh r r r+ � _get_payload s �zString._get_payloadN)r- r. r/ r$ r0 rJ rj ro r r r r+ rf � s rf c @ s e Zd ZdZdZdZdS )� FStringString�x f-strings contain f-string expressions and normal python strings. These are the string parts of f-strings. Zfstring_stringr N�r- r. r/ r9 r$ r0 r r r r+ rp s rp c @ s e Zd ZdZdZdZdS )� FStringStartrq Z fstring_startr Nrr r r r r+ rs s rs c @ s e Zd ZdZdZdZdS )� FStringEndrq Z fstring_endr Nrr r r r r+ rt s rt c @ s e Zd ZdZdd� Zdd� ZdS )�_StringComparisonMixinr c C s t |t�r| j|kS | |u S )ze Make comparisons with strings easy. Improves the readability of the parser. )r3 �strrI �r( �otherr r r+ �__eq__, s z _StringComparisonMixin.__eq__c C s t | j�S r; )�hashrI r= r r r+ �__hash__6 s z _StringComparisonMixin.__hash__N)r- r. r/ r0 ry r{ r r r r+ ru ) s ru c @ s e Zd ZdZdZdS )�Operator�operatorr Nre r r r r+ r| : s r| c @ s e Zd ZdZdZdS )�Keyword�keywordr Nre r r r r+ r~ ? s r~ c sT e Zd ZdZdZ� fdd�Zdd� Zdd� Zd d � Zd d � Z d d� Z dd� Z � Z S )�Scopez� Super class for the parser tree, which represents the state of a python text file. A Scope is either a function, class or lambda. r c s t � �|� d S r; ��super�__init__�r( r% �� __class__r r+ r� L s zScope.__init__c C s | � d�S )z9 Returns a generator of `funcdef` nodes. r ��_search_in_scoper= r r r+ � iter_funcdefsO s zScope.iter_funcdefsc C s | � d�S )z: Returns a generator of `classdef` nodes. r r� r= r r r+ �iter_classdefsU s zScope.iter_classdefsc C s | � dd�S )zO Returns a generator of `import_name` and `import_from` nodes. r r r� r= r r r+ � iter_imports[ s zScope.iter_importsc s � �fdd���| j �S )Nc 3 s8 | D ].}|j � v r|V |j tv r�|j�E d H qd S r; )r$ �_FUNC_CONTAINERSr% �r% �element��names�scanr r+ r� b s z$Scope._search_in_scope.<locals>.scan�r% )r( r� r r� r+ r� a s zScope._search_in_scopec C s | j d S )zD Returns the part that is executed by the function. ���r� r= r r r+ � get_suitek s zScope.get_suitec C sF z | j j}W n ty" d}Y n0 dt| �j|| jd | jd f S )N� z<%s: %s@%s-%s>r )r2 rI �AttributeErrorr$ r- r4 r5 )r( r2 r r r+ rS q s �zScope.__repr__) r- r. r/ r9 r0 r� r� r� r� r� r� rS � __classcell__r r r� r+ r� D s r� c s8 e Zd ZdZdZdZ� fdd�Zdd� Zdd � Z� Z S ) �Modulez� The top scope, which is always a module. Depending on the underlying parser this may be a full module or just a part of a module. )� _used_namesr c s t � �|� d | _d S r; )r� r� r� r� r� r r+ r� � s zModule.__init__c c sd | � � D ]V}|jdkr|jdkr|�� D ]4}dd� |D �}t|�dkr(|d dkr(|d V q(qdS ) zU :return: A list of future import names. :rtype: list of str r r c S s g | ] }|j �qS r )rI )�.0r2 r r r+ � <listcomp>� � z4Module._iter_future_import_names.<locals>.<listcomp>rl � __future__r" N)r� r$ �level� get_pathsrD )r( �imp�pathr� r r r+ �_iter_future_import_names� s z Module._iter_future_import_namesc s4 | j du r.i � � �fdd���| � t� �| _ | j S )z� Returns all the :class:`Name` leafs that exist in this module. This includes both definitions and references of names. Nc sV z | j }W n4 ty> | jdkr:� �| jg �}|�| � Y n0 |D ] }�|� qDd S )Nr2 )r% r� r$ � setdefaultrI �append)r) r% Zarr�child��dct�recurser r+ r� � s z&Module.get_used_names.<locals>.recurse)r� �UsedNamesMappingr= r r� r+ �get_used_names� s zModule.get_used_names) r- r. r/ r9 r0 r$ r� r� r� r� r r r� r+ r� { s r� c @ s e Zd ZdZdZdS )� Decorator� decoratorr Nre r r r r+ r� � s r� c @ s$ e Zd ZdZedd� �Zdd� ZdS )� ClassOrFuncr c C s | j d S )zR Returns the `Name` leaf that defines the function or class name. r" r� r= r r r+ r2 � s zClassOrFunc.namec C sT | j }|jdkr|j }|jdkrL|jd jdkr<|jd jS |jdd� S ng S dS )z4 :rtype: list of :class:`Decorator` r r r Z decoratorsNr" )r' r$ r% )r( r r r r+ �get_decorators� s zClassOrFunc.get_decoratorsN)r- r. r/ r0 rJ r2 r� r r r r+ r� � s r� c s0 e Zd ZdZdZdZ� fdd�Zdd� Z� ZS )�Classz> Used to store the parsed contents of a python class. r r c s t � �|� d S r; r� r� r� r r+ r� � s zClass.__init__c C s2 | j d dkrdS | j d dkr$dS | j d S dS )z Returns the `arglist` node that defines the super classes. It returns None if there are no arguments. rl �(N� �)r� r= r r r+ �get_super_arglist� s zClass.get_super_arglist) r- r. r/ r9 r$ r0 r� r� r� r r r� r+ r� � s r� c C s z |d }W n t y" g Y S 0 |jdv r<t|g| �gS |dkrJ|gS |jdkr\|g}n|j}g }d}t|dg d�D ]�\}}|du s�|dkrz|||� }|rz|d dkr�t|�dks�|d dks�|d dkr�|D ] } | | _q�||7 }n|�t|| �� |}qz|S dS ) a� `argslist_list` is a list that can contain an argslist as a first item, but most not. It's basically the items between the parameter brackets (which is at most one item). This function modifies the parser structure. It generates `Param` objects from the normal ast. Those param objects do not exist in a normal ast, but make the evaluation of the ast tree so much easier. You could also say that this function replaces the argslist node with a list of Param objects. r )r2 Zfpdef�*�tfpdefNr" �,�/)� IndexErrorr$ �Paramr% � enumeraterD r' r� ) r' Z argslist_list�firstr% Z new_children�start�endr� Zparam_children�pr r r+ �_create_params� s< � � � r� c sp e Zd ZdZdZdZ� fdd�Zdd� Zdd � Ze d d � �Z d d � Z dd� Z dd� Z dd� Ze dd� �Z� ZS )�Functionan Used to store the parsed contents of a python function. Children:: 0. <Keyword: def> 1. <Name> 2. parameter list (including open-paren and close-paren <Operator>s) 3. or 5. <Operator: :> 4. or 6. Node() representing function body 3. -> (if annotation is also present) 4. annotation (if present) r r c sN t � �|� | jd }|jdd� }tdd� |D ��sJt||�|jdd�< d S )Nrl r" r� c s s | ]}t |t�V qd S r; �r3 r� �r� r� r r r+ � <genexpr>- r� z$Function.__init__.<locals>.<genexpr>)r� r� r% �anyr� )r( r% � parameters�parameters_childrenr� r r+ r� ' s zFunction.__init__c C s | j d j S )Nrl r� r= r r r+ �_get_param_nodes0 s zFunction._get_param_nodesc C s dd� | � � D �S )z. Returns a list of `Param()`. c S s g | ]}|j d kr|�qS )r )r$ )r� r� r r r+ r� 7 r� z'Function.get_params.<locals>.<listcomp>)r� r= r r r+ � get_params3 s zFunction.get_paramsc C s | j d S �Nr" r� r= r r r+ r2 9 s z Function.namec s � fdd�� � | j �S )z6 Returns a generator of `yield_expr`. c 3 sl | D ]b}|j dv rqz |j}W n8 tyV |jdkrR|jj dkrL|jV n|V Y q0 � |�E d H qd S )N)r r �lambdef�yield� yield_expr)r$ r% r� rI r' )r% r� Znested_children�r� r r+ r� A s z'Function.iter_yield_exprs.<locals>.scanr� r= r r� r+ �iter_yield_exprs= s zFunction.iter_yield_exprsc s � fdd�� � | j �S )z7 Returns a generator of `return_stmt`. c 3 sL | D ]B}|j dks&|j dkr,|jdkr,|V |j tv r� |j�E d H qd S )NZ return_stmtr rG �r$ rI �_RETURN_STMT_CONTAINERSr% r� r� r r+ r� W s �� z(Function.iter_return_stmts.<locals>.scanr� r= r r� r+ �iter_return_stmtsS s zFunction.iter_return_stmtsc s � fdd�� � | j �S )zi Returns a generator of `raise_stmt`. Includes raise statements inside try-except blocks c 3 sL | D ]B}|j dks&|j dkr,|jdkr,|V |j tv r� |j�E d H qd S )NZ raise_stmtr �raiser� r� r� r r+ r� e s �� z'Function.iter_raise_stmts.<locals>.scanr� r= r r� r+ �iter_raise_stmtsa s zFunction.iter_raise_stmtsc C s t | �� d�duS )zK :return bool: Checks if a function is a generator or not. N)�nextr� r= r r r+ � is_generatoro s zFunction.is_generatorc C sL z2| j d dkr | j d W S | j d dks.J �W dS tyF Y dS 0 dS )zW Returns the test node after `->` or `None` if there is no annotation. r� z->� r! N)r% r� r= r r r+ � annotationu s zFunction.annotation)r- r. r/ r9 r$ r0 r� r� r� rJ r2 r� r� r� r� r� r� r r r� r+ r� s r� c sP e Zd ZdZdZdZ� fdd�Zedd� �Zdd � Z ed d � �Z d d � Z � Z S )�Lambdaz� Lambdas are basically trimmed functions, so give it the same interface. Children:: 0. <Keyword: lambda> *. <Param x> for each argument x -2. <Operator: :> -1. Node() representing body r� r c sH t t| ��|� | jdd� }tdd� |D ��sDt| |�| jdd�< d S )Nr" ���c s s | ]}t |t�V qd S r; r� r� r r r+ r� � r� z"Lambda.__init__.<locals>.<genexpr>)r� r� r� r% r� r� )r( r% r� r� r r+ r� � s zLambda.__init__c C s t d��dS )zN Raises an AttributeError. Lambdas don't have a defined name. zlambda is not named.N)r� r= r r r+ r2 � s z Lambda.namec C s | j dd� S )Nr" r� r� r= r r r+ r� � s zLambda._get_param_nodesc C s dS )zA Returns `None`, lambdas don't have annotations. Nr r= r r r+ r� � s zLambda.annotationc C s d| j j| jf S )Nz<%s@%s>)r� r- r4 r= r r r+ rS � s zLambda.__repr__) r- r. r/ r9 r$ r0 r� rJ r2 r� r� rS r� r r r� r+ r� � s r� c @ s e Zd ZdZdS )�Flowr NrM r r r r+ r� � s r� c @ s, e Zd ZdZdZdd� Zdd� Zdd� Zd S ) �IfStmtr r c c s0 t | j�D ] \}}|dv r | j|d V q dS )z� E.g. returns all the `test` nodes that are named as x, below: if x: pass elif x: pass )�elif�ifr" N)r� r% )r( �ir* r r r+ �get_test_nodes� s zIfStmt.get_test_nodesc C sB |j }tt| �� ��D ]&}|j |k r||jk r4 dS | S qdS )z� Searches for the branch in which the node is and returns the corresponding test node (see function above). However if the node is in the test node itself and not in the suite return None. N)r4 �reversed�listr� r5 )r( r) r4 Z check_noder r r+ �get_corresponding_test_node� s z"IfStmt.get_corresponding_test_nodec C s* | j D ] }|dkr|j|jkr dS qdS )z; Checks if a node is defined after `else`. �elseTFN)r% r4 )r( r) r* r r r+ �is_node_after_else� s zIfStmt.is_node_after_elseN)r- r. r/ r$ r0 r� r� r� r r r r+ r� � s r� c @ s e Zd ZdZdZdS )� WhileStmtr r Nre r r r r+ r� � s r� c @ s& e Zd ZdZdZdd� Zd dd�ZdS ) �ForStmtr r c C s | j d S )zE Returns the input node ``y`` from: ``for x in y:``. r� r� r= r r r+ � get_testlist� s zForStmt.get_testlistFc C s t | jd |�S r� ��_defined_namesr% rZ r r r+ r_ � s zForStmt.get_defined_namesN)F)r- r. r/ r$ r0 r� r_ r r r r+ r� � s r� c @ s e Zd ZdZdZdd� ZdS )�TryStmtr r c c s6 | j D ]*}|jdkr"|j d V q|dkrdV qdS )z� Returns the ``test`` nodes found in ``except_clause`` nodes. Returns ``[None]`` for except clauses without an exception given. r\ r" �exceptN�r% r$ �r( r) r r r+ �get_except_clause_tests� s z TryStmt.get_except_clause_testsN)r- r. r/ r$ r0 r� r r r r+ r� � s r� c @ s& e Zd ZdZdZd dd�Zdd� ZdS ) �WithStmtr r Fc C s< g }| j ddd� D ]"}|jdkr|t|j d |�7 }q|S )z} Returns the a list of `Name` that the with statement defines. The defined names are set after `as`. r" r� rl � with_item)r% r$ r� )r( rX r� r� r r r+ r_ s zWithStmt.get_defined_namesc C s$ |� d�}|d u rtd��|jd S )Nr� z2The name is not actually part of a with statement.r )r � ValueErrorr% )r( r2 r) r r r+ �get_test_node_from_name s z WithStmt.get_test_node_from_nameN)F)r- r. r/ r$ r0 r_ r� r r r r+ r� s r� c @ s( e Zd ZdZdd� Zdd� Zdd� ZdS ) �Importr c C s` z| � � | }W n ty" Y n0 | �� D ]&}||v r,|d|�|�d � S q,td��dS )zo The path is the list of names that leads to the searched name. :return list of Name: Nr" z+Name should be defined in the import itself)�_aliases�KeyErrorr� r& r� )r( r2 r� r r r+ �get_path_for_name s zImport.get_path_for_namec C s dS )NFr r= r r r+ � is_nested/ s zImport.is_nestedc C s | j d dkS )Nr� r� r� r= r r r+ �is_star_import2 s zImport.is_star_importN)r- r. r/ r0 r� r� r� r r r r+ r� s r� c @ sJ e Zd ZdZdZddd�Zdd� Zdd � Zed d � �Z d d � Z dd� Z dS )� ImportFromr r Fc C s dd� | � � D �S )z� Returns the a list of `Name` that the import defines. The defined names are set after `import` or in case an alias - `as` - is present that name is returned. c S s g | ]\}}|p|�qS r r �r� r2 �aliasr r r+ r� @ r� z0ImportFrom.get_defined_names.<locals>.<listcomp>)�_as_name_tuplesrZ r r r+ r_ : s z ImportFrom.get_defined_namesc C s t dd� | �� D ��S )z-Mapping from alias to its corresponding name.c s s" | ]\}}|d ur||fV qd S r; r r� r r r+ r� D s �z&ImportFrom._aliases.<locals>.<genexpr>)�dictr� r= r r r+ r� B s zImportFrom._aliasesc C sP | j dd � D ]}|dvr q q|jdkr:|j d d d� S |dkrFg S |gS d S )Nr" ��.z...Z dotted_namerl �importr� )r( �nr r r+ �get_from_namesG s zImportFrom.get_from_namesc C s8 d}| j dd� D ] }|dv r.|t|j�7 }q q4q|S )�&The level parameter of ``__import__``.r r" Nr� �r% rD rI )r( r� r r r r+ r� R s zImportFrom.levelc c s� | j d }|dkr | j d }n |dkr*d S |jdkrF|j d d d� }n|g}|D ],}|jdkrj|d fV qP|j d d d� V qPd S )Nr� r� r� r� Zimport_as_namesrl r2 r� )r( �last�as_names�as_namer r r+ r� ] s zImportFrom._as_name_tuplesc s2 | � � � | jd dkr � gS � fdd�| �� D �S )z� The import paths defined in an import statement. Typically an array like this: ``[<Name: datetime>, <Name: date>]``. :return list of list of Name: r� r� c s g | ]\}}� |g �qS r r r� �Zdottedr r+ r� y r� z(ImportFrom.get_paths.<locals>.<listcomp>)r r% r� r= r r r+ r� n s zImportFrom.get_pathsN)F) r- r. r/ r$ r0 r_ r� r rJ r� r� r� r r r r+ r� 6 s r� c @ sN e Zd ZdZdZdZddd�Zedd� �Zd d � Z d d � Z d d� Z dd� Z dS )� ImportNamezBFor ``import_name`` nodes. Covers normal imports without ``from``.r r Fc C s dd� | � � D �S )z� Returns the a list of `Name` that the import defines. The defined names is always the first name after `import` or in case an alias - `as` - is present that name is returned. c S s g | ]\}}|p|d �qS )r r �r� r� r� r r r+ r� � r� z0ImportName.get_defined_names.<locals>.<listcomp>��_dotted_as_namesrZ r r r+ r_ � s z ImportName.get_defined_namesc C s dS )r r r r= r r r+ r� � s zImportName.levelc C s dd� | � � D �S )Nc S s g | ] \}}|�qS r r r r r r+ r� � r� z(ImportName.get_paths.<locals>.<listcomp>r r= r r r+ r� � s zImportName.get_pathsc c s� | j d }|jdkr&|j ddd� }n|g}|D ]V}|jdkrT|j d }|j d }nd}|jdkrp|g|fV q0|j ddd� |fV q0dS )z9Generator of (list(path), alias) where alias may be None.r" �dotted_as_namesNrl Zdotted_as_namer r2 r� )r( r r r r� r r r+ r � s zImportName._dotted_as_namesc C s t dd� | �� D ��S )z� This checks for the special case of nested imports, without aliases and from statement:: import foo.bar c S s( g | ] \}}|d u rt |�dkrd�qS r� )rD r r r r+ r� � s �z(ImportName.is_nested.<locals>.<listcomp>)�boolr r= r r r+ r� � s zImportName.is_nestedc C s t dd� | �� D ��S )z= :return list of Name: Returns all the alias c s s& | ] \}}|d ur||d fV qd S )Nr� r r r r r+ r� � s �z&ImportName._aliases.<locals>.<genexpr>)r� r r= r r r+ r� � s zImportName._aliasesN)F) r- r. r/ r9 r$ r0 r_ rJ r� r� r r� r� r r r r+ r | s r c @ s6 e Zd ZdZdZedd� �Zedd� �Zd dd �Zd S ) �KeywordStatementz� For the following statements: `assert`, `del`, `global`, `nonlocal`, `raise`, `return`, `yield`. `pass`, `continue` and `break` are not in there, because they are just simple keywords and the parser reduces it to a keyword. r c C s d| j S )z� Keyword statements start with the keyword and end with `_stmt`. You can crosscheck this with the Python grammar. z%s_stmt)r r= r r r+ r$ � s zKeywordStatement.typec C s | j d jS �Nr )r% rI r= r r r+ r � s zKeywordStatement.keywordFc C s: | j }|dkr t| jd |�S |dv r6| jdd d� S g S )N�delr" )�global�nonlocalrl )r r� r% )r( rX r r r r+ r_ � s z"KeywordStatement.get_defined_namesN)F) r- r. r/ r9 r0 rJ r$ r r_ r r r r+ r � s r c @ s e Zd ZdZedd� �ZdS )� AssertStmtr c C s | j d S r� r� r= r r r+ � assertion� s zAssertStmt.assertionN)r- r. r/ r0 rJ r r r r r+ r � s r c @ s e Zd ZdZdd� ZdS )� GlobalStmtr c C s | j dd d� S )Nr" rl r� r= r r r+ �get_global_names� s zGlobalStmt.get_global_namesN)r- r. r/ r0 r r r r r+ r � s r c @ s e Zd ZdZdS )� ReturnStmtr NrM r r r r+ r � s r c @ s e Zd ZdZdZdS )� YieldExprr� r Nre r r r r+ r � s r c C s g }| j dv r4| jddd� D ]}|t||�7 }q n�| j dv rT|t| jd |�7 }n�| j dv r�| jd dkr�| jd }|jd d kr�|�|jd � n^|jd d kr�|r�| jddd � D ]:}|j d kr�|�|jd � q�|j dkr�|�|� q�q�n |�| � |S )zk A helper function to find the defined names in statements, for loops and list comprehensions. )Ztestlist_star_exprZ testlist_compZexprlistZtestlistNrl )ZatomZ star_exprr" )�powerZ atom_exprr� �**r� r r� �[�trailerr2 )r$ r% r� r� )�currentrX r� r� r r) r r r+ r� � s* r� c @ s. e Zd ZdZdZd dd�Zdd� Zdd � Zd S ) �ExprStmtr r Fc sN g }�j d jdkr$t�j d � �}� �fdd�tdt�j �d d�D �| S )zG Returns a list of `Name` defined before the `=` sign. r" � annassignr c s: g | ]2}d �j |d jv rt�j | � �D ]}|�q,qS )�=r" )r% rI r� )r� r� r2 �rX r( r r+ r� s �z.ExprStmt.get_defined_names.<locals>.<listcomp>rl )r% r$ r� �rangerD )r( rX r� r r" r+ r_ s ��zExprStmt.get_defined_namesc C s< | j d }|jdkr8t|j �dkr.|j d }n |j d }|S )z*Returns the right-hand-side of the equals.r� r r� r� r" �r% r$ rD r� r r r+ �get_rhs s zExprStmt.get_rhsc c sP | j d }|jdkr0t|j �dkr&dS |j d }|V | j ddd� E dH dS )zZ Returns a generator of `+=`, `=`, etc. or None if there is no operation. r" r rl Nr� r$ �r( r� r r r+ �yield_operators' s zExprStmt.yield_operatorsN)F)r- r. r/ r$ r0 r_ r% r' r r r r+ r s r c @ s e Zd ZdZddd�ZdS )� NamedExprr Fc C s t | jd |�S r r� rZ r r r+ r_ 9 s zNamedExpr.get_defined_namesN)F)r- r. r/ r$ r_ r r r r+ r( 6 s r( c s� e Zd ZdZdZd � fdd� Zedd� �Zedd � �Zed d � �Z d d � Z edd� �Z d dd�Z edd� �Z dd� Zd � fdd� Zdd� Z� ZS ) r� z� It's a helper class that makes business logic with params much easier. The Python grammar defines no ``param`` node. It defines it in a different way that is not really suited to working with parameters. r Nc s t � �|� || _d S r; )r� r� r' )r( r% r' r� r r+ r� E s zParam.__init__c C s | j d }|dv r t|j�S dS )zc Is `0` in case of `foo`, `1` in case of `*foo` or `2` in case of `**foo`. r �r� r r r& r r r+ � star_countI s zParam.star_countc C sV | j d dk}z.| j dt|� dkr:| j dt|� W S W n tyP Y dS 0 dS )z{ The default is the test node that appears after the `=`. Is `None` in case no default is present. r� r� r� r! N)r% rK r� )r( Z has_commar r r+ �defaultT s z Param.defaultc C sL | � � }|jdkrD|jd dks$J �t|j�dks6J �|jd }|S dS dS )zz The default is the test node that appears after `:`. Is `None` in case no annotation is present. r� r" r! r� rl N)�_tfpdefr$ r% rD )r( r� r� r r r+ r� a s zParam.annotationc C s t | jd dv �}| j| S )z1 tfpdef: see e.g. grammar36.txt. r r) )rK r% )r( �offsetr r r+ r, p s z Param._tfpdefc C s( | � � jdkr | � � jd S | � � S dS )z/ The `Name` leaf of the param. r� r N)r, r$ r% r= r r r+ r2 w s z Param.nameFc C s | j gS r; )r2 rZ r r r+ r_ � s zParam.get_defined_namesc C s� | j j�| �}z"| j j�d�}||kr.|d8 }W n tyB Y n0 z"| j j�d�}||krd|d8 }W n tyx Y n0 |d S )zB Property for the positional index of a paramter. r� rl r� r" )r' r% r& r� )r( r& Zkeyword_only_indexr r r+ �position_index� s zParam.position_indexc C s | � dd�S )z= Returns the function/lambda of a parameter. r r� )r r= r r r+ �get_parent_function� s zParam.get_parent_functionTc s< |rt � �|�S | j}|d dkr.|dd� }| j||d�S )z� Like all the other get_code functions, but includes the param `include_comma`. :param include_comma bool: If enabled includes the comma in the string output. r� r� N)�include_prefix)r� �get_coder% Z_get_code_for_children)r( r0 Z include_commar% r� r r+ r1 � s �zParam.get_codec C s: | j d u rdn d| j �� }dt| �jt| �� �| f S )Nr� z=%srV )r+ r1 r$ r- rv r, )r( r+ r r r+ rS � s zParam.__repr__)N)F)TT)r- r. r/ r9 r$ r� rJ r* r+ r� r, r2 r_ r. r/ r1 rS r� r r r� r+ r� = s$ r� c @ s e Zd ZdZdZddd�ZdS )� SyncCompForr r Fc C s t | jd |�S )zN Returns the a list of `Name` that the comprehension defines. r" r� rZ r r r+ r_ � s z SyncCompFor.get_defined_namesN)F)r- r. r/ r$ r0 r_ r r r r+ r2 � s r2 c @ s@ e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd d � Z dS )r� zO This class exists for the sole purpose of creating an immutable dict. c C s || _ d S r; ��_dict)r( r� r r r+ r� � s zUsedNamesMapping.__init__c C s | j | S r; r3 )r( �keyr r r+ � __getitem__� s z UsedNamesMapping.__getitem__c C s t | j�S r; )rD r4 r= r r r+ �__len__� s zUsedNamesMapping.__len__c C s t | j�S r; )�iterr4 r= r r r+ �__iter__� s zUsedNamesMapping.__iter__c C s t | �S r; )�idr= r r r+ r{ � s zUsedNamesMapping.__hash__c C s | |u S r; r rw r r r+ ry � s zUsedNamesMapping.__eq__N) r- r. r/ r9 r� r6 r7 r9 r{ ry r r r r+ r� � s r� )Jr9 rg �collections.abcr � ImportError� collections�typingr Z parso.treer r r r r r Zparso.python.prefixr Z parso.utilsr �setZ_FLOW_CONTAINERSr� r� r^ r` r r1 r: rF rL rN rO rP rQ rT rW rb rc rf rp rs rt ru r| r~ r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r r r r r r r� r r( r� r2 ZCompForr� r r r r+ �<module> s� , �� 4 76-m--F; +z
| ver. 1.1 | |
.
| PHP 8.3.30 | Ð“ÐµÐ½ÐµÑ€Ð°Ñ†Ð¸Ñ Ñтраницы: 0 |
proxy
|
phpinfo
|
ÐаÑтройка