Файловый менеджер - Редактировать - /opt/imh-python/lib/python3.9/site-packages/astroid/nodes/__pycache__/node_classes.cpython-39.pyc
Ðазад
a k�h�� � @ s, U d Z ddlmZ ddlZddlZddlZddlZddlZddlZddl Z ddl m Z m Z m Z mZmZ ddlmZ ddlmZmZmZmZmZmZ ddlmZmZmZ ddl m Z m Z dd l m Z m!Z! dd l"m#Z#m$Z$m%Z% dd l&m'Z'm(Z(m)Z)m*Z*m+Z+m,Z,m-Z-m.Z.m/Z/m0Z0m1Z1 dd l2m3Z3 dd l4m5Z5 ddl6m7Z7 ddl8m9Z9 ddl:m;Z; ddl<m=Z=m>Z>m?Z?m@Z@ ejAdk�r|ddlmBZB n ddlCmBZB e�r�ddlmDZD ddl6mEZE dd�dd�ZFejGde;d�ZHejGd ejId�ZJed ZKe eHeKee$ eeLeM gef ZNe eHee$ ge ee?eJf f ZOe eHee$ ge e?dee> f f ZPe eHeQge=f ZRejSd�d d �d d!��ZTd�d"dd#�d$d%�ZUeV� ZWd�d d �d&d'�ZXd�d d �d(d)�ZYd�d d �d*d+�ZZG d,d-� d-e7j[e ej\d.�Z]G d/d0� d0e7j^e7j_e7j[�Z`G d1d2� d2e7j^e7j_e7j[�ZaG d3d4� d4e7j_e7j^�Zbd5ZcG d6d7� d7e7jd�Zed8d9� Zfd�d:d;d<�d=d>�Zgd�d?d d@dAdB�dCdD�ZhG dEdF� dFe7j_e7j[�ZiG dGdH� dHe7jj�ZkG dIdJ� dJe7jde7jj�ZlG dKdL� dLe7jde7jj�ZmG dMdN� dNe7jde7jne7jj�ZoG dOdP� dPe7jn�ZpG dQdR� dRe;�ZqG dSdT� dTe7j^e7jj�ZrG dUdV� dVe;�ZsejtejuejvejwejxejydWdX� dYdX� dZ�Zzd[e{d\< d]d^hZ|G d_d`� d`e;�Z}G dadb� dbe;�Z~G dcdd� dde7j^e �ZG dedf� dfe7j^e7jj�Z�G dgdh� dhe;�Z�G didj� dje7j[�Z�G dkdl� dle7jde7jj�Z�G dmdn� dne;e �Z�G dodp� dpe7jj�Z�G dqdr� dre7j^�Z�G dsdt� dte7j�e7jde7jj�Z�G dudv� dve7j�e7jde7jj�Z�G dwdx� dxe��Z�G dydz� dze;�Z�G d{d|� d|e7j��Z�G d}d~� d~e;�Z�G dd�� d�e7j^e7jj�Z�G d�d�� d�e7j�e7jj�Z�G d�d�� d�e;�Z�G d�d�� d�e7j��Z�G d�d�� d�e;�Z�G d�d�� d�e]�Z�G d�d�� d�e7j^e7jj�Z�G d�d�� d�e7jd�Z�G d�d�� d�e7j^e7jj�Z�G d�d�� d�e7jj�Z�G d�d�� d�e7jj�Z�G d�d�� d�e]�Z�G d�d�� d�e;�Z�G d�d�� d�e7j[�Z�G d�d�� d�e;�Z�G d�d�� d�e7j�e7jj�Z�G d�d�� d�e7j�e7jj�Z�G d�d�� d�e]�Z�G d�d�� d�e7jde7jj�Z�G d�d�� d�e7jd�ZGG d�d�� d�e7jd�Z�d�d�d�dd��Z�G d�d�� d�e7jn�Z�G d�d�� d�e7j�e7jj�Z�G d�d�� d�e7j�e7jde7jj�Z�G d�d�� d�e��Z�G d�d�� d�e;�Z�G d�d�� d�e��Z�G d�d�� d�e7j^�Z�G d�d�� d�e;�Z�d�Z�G d�d�� d�e;�Z�G d�d�� d�e7jd�Z�G d�dÄ d�e7jd�Z�G d�dń d�e;�Z�G d�dDŽ d�e7jje7j��Z�G d�dɄ d�e;�Z�G d�d˄ d�e7j��Z�G d�d̈́ d�e��Z�G d�dτ d�e��Z�G d�dф d�e��Z�G d�dӄ d�e7jde��Z�G d�dՄ d�e��Z�G d�dׄ d�e7jde��Z�G d�dل d�e7jde��Z�G d�dۄ d�e��Z�eLe�e�e�e�e�e�e�e�d�ee�e��ee�d܃ee�eeMee�ee�eeQee�ei Z�d�e{d�< d�d�d�d�d�d�Z�d�dnd�d�d�d�Z�d@d�d�d�d�Z�dS )�z;Module for some node classes. More nodes in scoped_nodes.py� )� annotationsN)�Callable� Generator�Iterable�Iterator�Mapping)�cached_property)� TYPE_CHECKING�Any�ClassVar�Literal�Optional�Union)� decorators� protocols�util)�Instance� _infer_stmts)�_EMPTY_OBJECT_MARKER�Context)� CallContext�InferenceContext� copy_context) �AstroidBuildingError� AstroidError�AstroidIndexError�AstroidTypeError�AstroidValueError�AttributeInferenceError�InferenceError�NameInferenceError� NoDefault�ParentMissingError�_NonDeducibleTypeHierarchy)� dunder_lookup)�AstroidManager)� _base_nodes)� OP_PRECEDENCE)�NodeNG)�ConstFactoryResult�InferenceErrorInfo�InferenceResult�SuccessfulInferenceResult)� � )�Self��nodes)�LocalsDictNodeNG�bool��returnc C s t | tt��S �N)� isinstance�tuple� CONST_CLS��value� r< ��/root/rpmbuild/BUILDROOT/imh-python39-modules-3.9.7-92.el8.x86_64/opt/imh-python/lib/python3.9/site-packages/astroid/nodes/node_classes.py� _is_constB s r> �_NodesT)�bound�_BadOpMessageT)�List�Tuple� AssignName� AssignAttrN�InferenceContext | None��contextc c s� t | ttf�rF| jD ]&}|tju r*|V qt||�E dH q| |d�S t| �|�tj�}|| u rp|V | |d�S | �|�D ](}t |tj �r�|V qzt||�E dH qz| |d�S )z�recursively generate nodes inferred by the given statement. If the inferred value is a list or a tuple, recurse on the elements N��noderH ) r7 rB rC �eltsr � Uninferable� unpack_infer�next�infer�UninferableBase)�stmtrH �elt�inferredr< r< r= rM ^ s rM �list[str] | None�� exceptionsr5 c C s� i }i }| }| � � D ]}d||< |||< |}q|}|� � D �]@}||v �rxt|t�r�|du r�|�|�\}}|�|| �\} } d| |fv r� dS | |kr� dS n�t|t��rr|�|�\}}|�|| �\} } | |u�rN|dko�| dko�|�|�} |dk�o| dk�o|| �|�} |dk�o | dk} |dk�o2| dk}t| | | |f��rr dS n$|dk�rr| dk�rr||| u S dS |}q:dS ) a� return true if the two given statements are mutually exclusive `exceptions` may be a list of exception names. If specified, discard If branches and check one of the statement is in an exception handler catching one of the given exceptions. algorithm : 1) index stmt1's parents 2) climb among stmt2's parents until we find a common parent 3) if the common parent is a If or Try statement, look if nodes are in exclusive branches � N�testFT�handlers�body�orelse)Znode_ancestorsr7 �IfZ locate_child�Try�catch�any)Zstmt1Zstmt2rV Z stmt1_parents�children�previousrJ Zc2attrZc2nodeZc1attrZc1nodeZ first_in_body_caught_by_handlersZ!second_in_body_caught_by_handlersZ first_in_else_other_in_handlersZ second_in_else_other_in_handlersr< r< r= � are_exclusivey s` �� � �����rb c C s� t | t�r&t | jttd�f�r�| jS n\| du r2dS zt| j|d��}W n ttfy\ Y n&0 t |t�r�t |jttd�f�r�|jS t S )z'Get the value of the given slice index.NrG ) r7 �Constr; �int�typerN rO r � StopIteration�_SLICE_SENTINEL)�indexrH rS r< r< r= � _slice_value� s ri c C s^ t | j|�}t | j|�}t | j|�}tdd� |||fD ��rHt|||�S td| | j|d��d S )Nc s s | ]}|t uV qd S r6 )rg ��.0�elemr< r< r= � <genexpr>� � z _infer_slice.<locals>.<genexpr>z'Could not infer slice used in subscript��messagerJ rh rH )ri �lower�upper�step�all�slicer �parent)rJ rH rq rr rs r< r< r= � _infer_slice� s �rw c C s zPt |t�r8t||d�}| �� }|| |_| j|_|W S t |t�rN||j W S W n� ty� } z t d| ||d�|�W Y d}~nrd}~0 t y� } z t d| ||d�|�W Y d}~n>d}~0 t y� } z t d| ||d�|�W Y d}~n d}~0 0 t d|� d���dS ) zHGet a slice or an item, using the given *index*, for the given sequence.rG z&Slice {index!r} cannot index containerro Nz Index {index!s} out of range�Type error {error!r}zCould not use � as subscript index)r7 �Slicerw � __class__rK rv rc r; � ValueErrorr � IndexErrorr � TypeErrorr )�instancerK rh rH Z index_sliceZnew_cls�excr< r< r= �_container_getitem� sD ������r� c s� e Zd ZdZdZddddddd�� fdd� Zd dd �d d �Zed dd �dd��Zdd� Z d&ddd�dd�Z e j dd�dd ��Z d d � Zejd'dd d d!�d"d#��Zd(dd d�d$d%�Z� ZS ))� BaseContainerz.Base class for Set, FrozenSet, Tuple and List.�rK � int | None� NodeNG | None�None��lineno� col_offsetrv � end_lineno�end_col_offsetr5 c s g | _ t� j|||||d� d S �N�r� r� r� r� rv )rK �super�__init__��selfr� r� rv r� r� �r{ r< r= r� s �zBaseContainer.__init__z list[SuccessfulInferenceResult])rK r5 c C s || _ d S r6 r� )r� rK r< r< r= �postinit+ s zBaseContainer.postinit� Iterable[Any]r/ c C s& | dddddd�}dd� |D �|_ |S )z�Create a node of this type from the given list of elements. :param elts: The list of elements that the node should contain. :returns: A new node containing the given elements. N�r� r� rv r� r� c S s g | ]}t |�rt|�n|�qS r< )r> � const_factory�rk �er< r< r= � <listcomp>= rn z/BaseContainer.from_elements.<locals>.<listcomp>r� )�clsrK rJ r< r< r= � from_elements. s �zBaseContainer.from_elementsc C s | j S )z�An iterator over the elements this node contains. :returns: The contents of this node. :rtype: iterable(NodeNG) r� �r� r< r< r= �itered@ s zBaseContainer.iteredNrF r3 �rH r5 c C s t | j�S )zeDetermine the boolean value of this node. :returns: The boolean value of this node. )r3 rK �r� rH r< r< r= � bool_valueH s zBaseContainer.bool_value�strr4 c C s dS )�eGet the name of the type that this node represents. :returns: The name of the type. Nr< r� r< r< r= �pytypeO s zBaseContainer.pytypec c s | j E d H d S r6 r� r� r< r< r= � get_childrenV s zBaseContainer.get_childrenr zIterator[Self]�rH �kwargsr5 c k s^ t dd� | jD ��}|rT| �|�}t| �| j| j| j| j| jd�}|� |� |V n| V d S )Nc s s | ]}t |ttf�V qd S r6 )r7 �Starred� NamedExprr� r< r< r= rm _ s z'BaseContainer._infer.<locals>.<genexpr>r� ) r_ rK �_infer_sequence_helperre r� r� rv r� r� r� )r� rH r� Zhas_starred_named_expr�values�new_seqr< r< r= �_inferY s � � zBaseContainer._inferc C s� g }| j D ]�}t|t�r^t�|j|�}|s6t| |d��t|d�sLt| |d��|�|� |�� q t|t �r�t�|j|�}|s�t| |d��|� |� q |� |� q |S )z-Infer all values based on BaseContainer.elts.rI rK ) rK r7 r� r � safe_inferr; r �hasattr�extendr� r� �append)r� rH r� rR Zstarredr; r< r< r= r� q s z$BaseContainer._infer_sequence_helper)N)N)N)�__name__� __module__� __qualname__�__doc__�_astroid_fieldsr� r� � classmethodr� r� r� �abc�abstractmethodr� r� r �raise_if_nothing_inferredr� r� � __classcell__r< r< r� r= r� s � �r� )� metaclassc sv e Zd ZdZdZdddddddd�� fd d � ZejZe j e j dd d dd�dd���Z e j dd d dd�dd��Z � ZS )rD a Variation of :class:`ast.Assign` representing assignment to a name. An :class:`AssignName` is the name of something that is assigned to. This includes variables defined in a function signature or in a loop. >>> import astroid >>> node = astroid.extract_node('variable = range(10)') >>> node <Assign l.1 at 0x7effe1db8550> >>> list(node.get_children()) [<AssignName.variable l.1 at 0x7effe1db8748>, <Call l.1 at 0x7effe1db8630>] >>> list(node.get_children())[0].as_string() 'variable' ��namer� rd r( r� r� �r� r� r� rv r� r� r5 c s || _ t� j|||||d� d S r� �r� r� r� �r� r� r� r� rv r� r� r� r< r= r� � s �zAssignName.__init__NrF r �;Generator[InferenceResult, None, InferenceErrorInfo | None]r� c K s2 t | jt�r| j�|�S t| j|d��}t||�S )zVInfer an AssignName: need to inspect the RHS part of the assign node. rG �r7 rv � AugAssignrO �list�assigned_stmtsr �r� rH r� �stmtsr< r< r= r� � s zAssignName._inferc K s� ddl m} ddlm} | �| j�\}}|sd|| �� �}|rL|�| j�\}}|sdt| j| �� |d��t|�}| j|_ || |�|j | j< t |||�S )zQInfer a Name: use name lookup rules. Same implementation as Name._infer.r ��get_constraints��_higher_function_scope�r� �scoperH � �astroid.constraintr� Zastroid.helpersr� �lookupr� r� r r � lookupname� constraintsr � r� rH r� r� r� �framer� Zparent_function�_r< r< r= � infer_lhs� s �zAssignName.infer_lhs)N)N)r� r� r� r� � _other_fieldsr� r �assend_assigned_stmtsr� r r� � path_wrapperr� r� r� r< r< r� r= rD � s � �rD c s6 e Zd ZdZdZdddddddd�� fd d � Z� ZS ) �DelNameah Variation of :class:`ast.Delete` representing deletion of a name. A :class:`DelName` is the name of something that is deleted. >>> import astroid >>> node = astroid.extract_node("del variable #@") >>> list(node.get_children()) [<DelName.variable l.1 at 0x7effe1da4d30>] >>> list(node.get_children())[0].as_string() 'variable' r� r� rd r( r� r� r� c s || _ t� j|||||d� d S r� r� r� r� r< r= r� � s �zDelName.__init__�r� r� r� r� r� r� r� r< r< r� r= r� � s r� c s^ e Zd ZdZdZdddddddd�� fd d � Zd d � Zejej ddddd�dd���Z � Z S )�Namea� Class representing an :class:`ast.Name` node. A :class:`Name` node is something that is named, but not covered by :class:`AssignName` or :class:`DelName`. >>> import astroid >>> node = astroid.extract_node('range(10)') >>> node <Call l.1 at 0x7effe1db8710> >>> list(node.get_children()) [<Name.range l.1 at 0x7effe1db86a0>, <Const.int l.1 at 0x7effe1db8518>] >>> list(node.get_children())[0].as_string() 'range' r� r� rd r( r� r� r� c s || _ t� j|||||d� d S r� r� r� r� r< r= r� " s �z Name.__init__c c s& | V | � � D ]}|�� E d H qd S r6 )r� �_get_name_nodes)r� � child_noder< r< r= r� 7 s zName._get_name_nodesNrF r r� r� c K s� ddl m} ddlm} | �| j�\}}|sd|| �� �}|rL|�| j�\}}|sdt| j| �� |d��t|�}| j|_ || |�|j | j< t |||�S )zZInfer a Name: use name lookup rules Same implementation as AssignName._infer_lhs.r r� r� r� r� r� r< r< r= r� = s �z Name._infer)N) r� r� r� r� r� r� r� r r� r� r� r� r< r< r� r= r� s �r� �DEPRECATED_ARGUMENT_DEFAULTc sx e Zd ZU dZdZdZded< ded< ded < ded < d ed < d ed< d ed< d ed< d ed< d ed< d ed< ded< ded< ded< ded< dEddd ddd d �� fd d � ZdFdddd d dd d ddd d d d d!�d"d#�Ze j Z d$d%� Z e d&d'�� fd(d)� �Ze d*d+� �Zdd,�d-d.d/�d0d1�Zd2d'�d3d4�Zd5d6� Zd7d'�d8d9�Zefd:d;�Zd<d=� ZejdGd>d?d@dAdB�dCdD��Z� ZS )H� ArgumentsaR Class representing an :class:`ast.arguments` node. An :class:`Arguments` node represents that arguments in a function definition. >>> import astroid >>> node = astroid.extract_node('def foo(bar): pass') >>> node <FunctionDef.foo l.1 at 0x7effe1db8198> >>> node.args <Arguments l.1 at 0x7effe1db82e8> ) �args�defaults� kwonlyargs� posonlyargs�posonlyargs_annotations� kw_defaultsr �varargannotation�kwargannotation�kwonlyargs_annotations�type_comment_args�type_comment_kwonlyargs�type_comment_posonlyargs)�vararg�kwargzlist[AssignName] | Noner� �list[NodeNG] | Noner� zlist[AssignName]r� r� zlist[NodeNG | None] | Noner� zlist[NodeNG | None]r r� r� r� r� r� r� r� r� �AssignName | None� vararg_node� kwarg_nodeN� str | Noner( r� )r� r� rv r� r� r5 c s2 t � j|ddddd� || _|| _|| _|| _dS )zPAlmost all attributes can be None for living objects where introspection failed.N�rv r� r� r� r� )r� r� r� r� r� r� )r� r� r� rv r� r� r� r< r= r� � s �zArguments.__init__)r� r� r� r� r r� r� r� r� r� r� r� r� r5 c C sv || _ || _|| _|| _|| _|| _|| _|| _| | _| | _ | d u rHg } | | _ | d u rZg } | | _ | d u rlg } | | _ d S r6 ) 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< r< r= r� � s& zArguments.postinitc C s | j |u r|S d S r6 �rv �r� r� r� r< r< r= � _infer_name s zArguments._infer_namerd r4 c s t � j}t|| jjpd�S )z�The first line that this node appears on in the source code. Can also return 0 if the line can not be determined. r )r� � fromlineno�maxrv �r� r� r� r< r= r� s zArguments.fromlinenoc C sR t t�| jpd| jpd��}| jr.|�| j� || jp8d7 }| jrN|�| j� |S )z�Get all the arguments for this node. This includes: * Positional only arguments * Positional arguments * Keyword arguments * Variable arguments (.e.g *args) * Variable keyword arguments (e.g **kwargs) r< ) r� � itertools�chainr� r� r� r� r� r� )r� �retvalr< r< r= � arguments s zArguments.arguments��skippable_names�set[str] | Noner� �r r5 c C s g }g }| j }| j rN| jp g }| j t|� d� }| j dt| j �t|� � }| jrx|�t| j|| j|d�� |�d� | jr�|�t| j|t| dd�|d�� | jr�|�d| j� �� | j r�| js�|�d� |�t| j | j | j |d�� | j �r|�d| j � �� d� |�S )zoGet the arguments formatted as string. :returns: The formatted arguments. :rtype: str Nr� �/r �*�**�, )r� r� �lenr� r� � _format_argsr� �getattrr� r� r� r� r� �join)r� r �result�positional_only_defaults� positional_or_keyword_defaultsr� r< r< r= � format_args0 sT �� �� ��zArguments.format_argszYtuple[dict[str, tuple[str | None, str | None]], dict[str, tuple[str | None, str | None]]]c C s� i }i }g }| j }| j rR| jp g }| j t|� d� }| j dt| j �t|� � }t| j�D ]F\}}| j| d }} |dur�|�� }|r�|| �� } || f||j< q\t| j�D ]z\}} | j| d }} |dur�|�� }|�rt| j�t|� } || } | dk�r|| du�r|| �� } || f|| j< q�| j �rX| j }|du�rJ|�� }|df|| j < t| j �D ]P\}} | j | }|du�r�|�� }| j | } | du�r�| �� } || f|| j< �qb| j�r�| j}|du�r�|�� }|df|| j< ||fS )ay Get the arguments as dictionary with information about typing and defaults. The return tuple contains a dictionary for positional and keyword arguments with their typing and their default value, if any. The method follows a similar order as format_args but instead of formatting into a string it returns the data that is used to do so. N���)r� r� r � enumerater� r� � as_stringr� r r� r� r� r� r� r� r� )r� Zpos_only�kw_onlyr r r� rh Zposonly� annotation�default�argZdefaults_offsetZ default_indexr� r< r< r= �_get_arguments_datab s^ � � z Arguments._get_arguments_datac s� � fdd�� j D �}t|� j�d }|dur`t� j�|kr`� j| durR� j| S t� j|d��t||�d }|dur�|t|�t� j� t� j� }|dkr�� j| S t� j|d��dS )z�Get the default value for an argument. :param argname: The name of the argument to get the default value for. :type argname: str :raises NoDefault: If there is no default value defined for the given argument. c s" g | ]}|j � j� jfvr|�qS r< )r� r� r� �rk r r� r< r= r� � s z+Arguments.default_value.<locals>.<listcomp>r N)�funcr� )r� � _find_argr� r r� r! rv r� )r� �argnamer� rh �idxr< r� r= � default_value� s � zArguments.default_valuer3 c C s. || j krdS || jkr dS | �|�d duS )z�Check if the given name is defined in the arguments. :param name: The name to check for. :type name: str :returns: Whether the given name is defined in the arguments, TrW N)r� r� � find_argname�r� r� r< r< r= � is_argument� s zArguments.is_argumentc C s> |t krtjdtdd� | jr:t|| j�\}}|r:||fS dS )a Get the index and :class:`AssignName` node for given name. :param argname: The name of the argument to search for. :type argname: str :returns: The index and node for the argument. :rtype: tuple(str or None, AssignName or None) z0The rec argument will be removed in astroid 3.1.� �� stacklevel�NN)r� �warnings�warn�DeprecationWarningr� r )r� r Zrecrh �argumentr< r< r= r � s �zArguments.find_argnamec c s� | j pdE d H | jD ]}|d ur|V q| jp2dE d H | jd urP| jE d H | jE d H | jpddD ]}|d urf|V qf| jD ]}|d ur�|V q�| jd ur�| jV | jd ur�| jV | j D ]}|d ur�|V q�d S )Nr< ) r� r� r� r� r� r� r r� r� r� )r� rR r< r< r= r� � s* zArguments.get_childrenznodes.ArgumentsrF r �Generator[InferenceResult]�r� rH r� r5 c K s8 ddl m} |d u s |jd u r*t| |d��|| |j|�S )Nr )�_arguments_infer_argnamerI )Zastroid.protocolsr* r� r )r� rH r� r* r< r< r= r� s zArguments._infer)NN)NNNNN)N)r� r� r� r� r� r� �__annotations__r� r� r Zarguments_assigned_stmtsr� r� r r� r� r r r r r� r r� r r� r� r� r< r< r� r= r� _ sT � % �*& 2E �r� c C s, t |�D ] \}}|j| kr||f S qdS )Nr# )r r� )r r� �ir r< r< r= r s r r r� r c C s |d u rt � }g }| d u r dS |d u r*g }|d urDt| �t|� }nd }t�| |�}t|�D ]�\}\}} |j|v rtq\t|t�r�|�dt |j �� d�� q\|j} d} | d ur�| d| � � 7 } d} |�| � |d ur\||kr\||| d ur\|d | ||| � � 7 < q\d� |�S ) N� �(�)�=z: z = r r ) �setr r� � zip_longestr r� r7 rC r� r rK r r ) r� r� r r r� Zdefault_offset�packedr, r r r Z default_sepr< r< r= r s4 "r z"nodes.AssignAttr | nodes.Attributer �4Generator[InferenceResult, None, InferenceErrorInfo])rJ rH r� r5 c k s� ddl m} ddlm} | j�|�D ]�}t|tj�r<|V q$t |�}|j }z�zr||_ t||t f�r�t||�rp|n|j }|| |d�|j | j< | jdkr�|jdkr�tjV n|�| j|�E dH W n tttfy� Y n0 W ||_ q$||_ 0 q$t| |d�S ) zMInfer an AssignAttr/Attribute node by using getattr on the associated object.r r� ��ClassDef)r� �argv�sysNrI )r� r� � astroid.nodesr6 �exprrO r7 r rP r � boundnoder �_proxiedr� �attrnamer� rL �igetattrr r �AttributeErrorr* )rJ rH r� r� r6 �ownerZ old_boundnoder� r< r< r= �_infer_attribute9 s0 � rA c s� e Zd ZU dZded< dZdZddddddd d �� fd d � Zdd d �dd�Ze j Z dd� Z e je jddddd�dd���Ze je jd dddd�dd���Z� ZS ) rE a� Variation of :class:`ast.Assign` representing assignment to an attribute. >>> import astroid >>> node = astroid.extract_node('self.attribute = range(10)') >>> node <Assign l.1 at 0x7effe1d521d0> >>> list(node.get_children()) [<AssignAttr.attribute l.1 at 0x7effe1d52320>, <Call l.1 at 0x7effe1d522e8>] >>> list(node.get_children())[0].as_string() 'self.attribute' r( r: �r: �r= r� rd r� r� �r= r� r� rv r� r� r5 c s || _ t� j|||||d� d S r� �r= r� r� �r� r= r� r� rv r� r� r� r< r= r� r s �zAssignAttr.__init__�r: r5 c C s || _ d S r6 rB �r� r: r< r< r= r� � s zAssignAttr.postinitc c s | j V d S r6 rB r� r< r< r= r� � s zAssignAttr.get_childrenNrF r r� r� c K s2 t | jt�r| j�|�S t| j|d��}t||�S )zVInfer an AssignAttr: need to inspect the RHS part of the assign node. rG r� r� r< r< r= r� � s zAssignAttr._inferc K s t | |fi |��S r6 �rA �r� rH r� r< r< r= r� � s zAssignAttr.infer_lhs)N)N)r� r� r� r� r+ r� r� r� r� r r� r� r� r r� r� r� r� r� r< r< r� r= rE ` s � �rE c @ s@ e Zd ZU dZdZded< ded< dddd�d d �Zd d � Zd S )�Asserta Class representing an :class:`ast.Assert` node. An :class:`Assert` node represents an assert statement. >>> import astroid >>> node = astroid.extract_node('assert len(things) == 10, "Not enough things"') >>> node <Assert l.1 at 0x7effe1d527b8> �rX �failr( rX r� rM r� )rX rM r5 c C s || _ || _d S r6 )rM rX )r� rX rM r< r< r= r� � s zAssert.postinitc c s | j V | jd ur| jV d S r6 rL r� r< r< r= r� � s zAssert.get_childrenN�r� r� r� r� r� r+ r� r� r< r< r< r= rK � s rK c @ sv e Zd ZU dZded< ded< ded< dZd Zdddd d �d d �Zej Z dd� Z e dd�dd��Z dd� Zdd� ZdS )�Assigna Class representing an :class:`ast.Assign` node. An :class:`Assign` is a statement where something is explicitly asssigned to. >>> import astroid >>> node = astroid.extract_node('variable = range(10)') >>> node <Assign l.1 at 0x7effe1db8550> � list[NodeNG]�targetsr( r; r� �type_annotation�rQ r; �rR r� )rQ r; rR r5 c C s || _ || _|| _d S r6 )rQ r; rR )r� rQ r; rR r< r< r= r� � s zAssign.postinitc c s | j E d H | jV d S r6 rS r� r< r< r= r� � s zAssign.get_childrenzlist[nodes.Assign]r4 c C s | g| j j�S r6 )r; �_assign_nodes_in_scoper� r< r< r= rU � s z Assign._assign_nodes_in_scopec c s | j �� E d H d S r6 )r; � _get_yield_nodes_skip_functionsr� r< r< r= rV � s z&Assign._get_yield_nodes_skip_functionsc c s | j �� E d H d S r6 )r; � _get_yield_nodes_skip_lambdasr� r< r< r= rW � s z$Assign._get_yield_nodes_skip_lambdasN)r� r� r� r� r+ r� �_other_other_fieldsr� r �assign_assigned_stmtsr� r� r rU rV rW r< r< r< r= rO � s rO c @ s^ e Zd ZU dZdZdZded< ded< ded < d ed < ddd dd d �dd�Zej Z dd� Z dS )� AnnAssigna Class representing an :class:`ast.AnnAssign` node. An :class:`AnnAssign` is an assignment with a type annotation. >>> import astroid >>> node = astroid.extract_node('variable: List[int] = range(10)') >>> node <AnnAssign l.1 at 0x7effe1d4c630> ��targetr r; )�simple� Name | Attribute | Subscriptr\ r( r r� r; rd r] r� )r\ r r] r; r5 c C s || _ || _|| _|| _d S r6 )r\ r r; r] )r� r\ r r] r; r< r< r= r� s zAnnAssign.postinitc c s& | j V | jV | jd ur"| jV d S r6 r[ r� r< r< r= r� ( s zAnnAssign.get_childrenN) r� r� r� r� r� r� r+ r� r Zassign_annassigned_stmtsr� r� r< r< r< r= rZ � s rZ c s� e Zd ZU dZdZdZded< ded< dd d dd d d d �� fd d� Zddd d�dd�Ze j Z d'ddd�dd�Z dd� Z � fdd�Z� fd d �Zd(dd d�d d �Zejejd)d!dd"d#d$�d%d&���Z� ZS )*r� z�Class representing an :class:`ast.AugAssign` node. An :class:`AugAssign` is an assignment paired with an operator. >>> import astroid >>> node = astroid.extract_node('variable += 1') >>> node <AugAssign l.1 at 0x7effe1db4d68> �r\ r; ��opr^ r\ r( r; r� rd r� r� �ra r� r� rv r� r� r5 c s || _ t� j|||||d� d S r� �ra r� r� �r� ra r� r� rv r� r� r� r< r= r� F s �zAugAssign.__init__�r\ r; r5 c C s || _ || _d S r6 r_ �r� r\ r; r< r< r= r� ^ s zAugAssign.postinitNrF �$list[util.BadBinaryOperationMessage]r� c C sZ g }z:| j |d�D ](}|tju r$t�t|tj�r|�|� qW n tyT g Y S 0 |S )a Get a list of type errors which can occur during inference. Each TypeError is represented by a :class:`BadBinaryOperationMessage` , which holds the original exception. If any inferred result is uninferable, an empty list is returned. rG )�_infer_augassignr rL r r7 �BadBinaryOperationMessager� �r� rH �badr r< r< r= � type_errorsg s zAugAssign.type_errorsc c s | j V | jV d S r6 r_ r� r< r< r= r� | s zAugAssign.get_childrenc # s$ | j �� E dH t� �� E dH dS �z7An AugAssign node can contain a Yield node in the valueN)r; rV r� r� r� r< r= rV � s z)AugAssign._get_yield_nodes_skip_functionsc # s$ | j �� E dH t� �� E dH dS rm )r; rW r� r� r� r< r= rW � s z'AugAssign._get_yield_nodes_skip_lambdasz;Generator[InferenceResult | util.BadBinaryOperationMessage]c c s� |pt � }|�� }| jj|d�}| jj|d�}t�||�D ]h\}}tdd� ||fD ��rft j V dS z | j ||| || j d�E dH W q: t y� t j V Y q:0 q:dS )z0Inference logic for augmented binary operations.rG c s s | ]}t |tj�V qd S r6 �r7 r rP �rk r; r< r< r= rm � rn z-AugAssign._infer_augassign.<locals>.<genexpr>N)�left�rightZ binary_opnoderH Z flow_factory)r �cloner\ r� r; rO r� �productr_ r rL �_infer_binary_operationZ _get_aug_flowr# )r� rH � rhs_context�lhs_iter�rhs_iter�lhs�rhsr< r< r= rh � s$ � zAugAssign._infer_augassignznodes.AugAssignr r( r) c K s | � | j|tj�S r6 )�_filter_operation_errorsrh r ri rJ r< r< r= r� � s �zAugAssign._infer)N)N)N)r� r� r� r� r� r� r+ r� r� r rY r� rl r� rV rW rh r r� r� r� r� r< r< r� r= r� 0 s& � � �r� c s� e Zd ZU dZdZdZded< ded< ddddd d d d �� fd d � Zddd d�dd�Zd(ddd�dd�Z dd� Z dd� Z dd �d d �Z d)dd d d!�d"d#�Z ejejd*d$dd d d%�d&d'���Z� ZS )+�BinOpz�Class representing an :class:`ast.BinOp` node. A :class:`BinOp` node is an application of a binary operator. >>> import astroid >>> node = astroid.extract_node('a + b') >>> node <BinOp l.1 at 0x7f23b2e8cfd0> �rp rq r` r( rp rq r� rd r� r� rb c s || _ t� j|||||d� d S r� rc rd r� r< r= r� � s �zBinOp.__init__)rp rq r5 c C s || _ || _d S r6 r| )r� rp rq r< r< r= r� � s zBinOp.postinitNrF rg r� c C sZ g }z:| j |d�D ](}|tju r$t�t|tj�r|�|� qW n tyT g Y S 0 |S )a Get a list of type errors which can occur during inference. Each TypeError is represented by a :class:`BadBinaryOperationMessage`, which holds the original exception. If any inferred result is uninferable, an empty list is returned. rG )� _infer_binopr rL r r7 ri r� rj r< r< r= rl � s zBinOp.type_errorsc c s | j V | jV d S r6 r| r� r< r< r= r� � s zBinOp.get_childrenc C s t | j S r6 �r' ra r� r< r< r= � op_precedence� s zBinOp.op_precedencer3 r4 c C s | j dkS )Nr r` r� r< r< r= �op_left_associative� s zBinOp.op_left_associativer r( r� c k s� | j }| j}|pt� }t|�}t|�}|j|d�}|j|d�}t�||�D ]f\} } tdd� | | fD ��rvtj V dS z | � | | | || j �E dH W qJ t y� tj V Y qJ0 qJdS )z!Binary operation inference logic.rG c s s | ]}t |tj�V qd S r6 rn ro r< r< r= rm rn z%BinOp._infer_binop.<locals>.<genexpr>N) rp rq r r rO r� rs r_ r rL rt Z_get_binop_flowr# ) r� rH r� rp rq � lhs_contextru rv rw rx ry r< r< r= r} � s" � zBinOp._infer_binopz nodes.BinOpr) c K s | � | j|tj�S r6 )rz r} r ri rJ r< r< r= r� s �z BinOp._infer)N)N)N)r� r� r� r� r� r� r+ r� r� rl r� r r� r} r Zyes_if_nothing_inferredr� r� r� r< r< r� r= r{ � s$ � � �r{ c s� e Zd ZdZdZdZd ddd�ddddddd d �� fd d �Zd d d d�dd�Zdd� Zdd� Z e j e j d ddddd�dd���Z � ZS ) �BoolOpz�Class representing an :class:`ast.BoolOp` node. A :class:`BoolOp` is an application of a boolean operator. >>> import astroid >>> node = astroid.extract_node('a and b') >>> node <BinOp l.1 at 0x7f23b2e71c50> �r� r` N�r� r� r� r� r� r� rb c s& || _ g | _t� j|||||d� dS )a� :param op: The operator. :param lineno: The line that this node appears on in the source code. :param col_offset: The column that this node appears on in the source code. :param parent: The parent node in the syntax tree. :param end_lineno: The last line this node appears on in the source code. :param end_col_offset: The end column this node appears on in the source code. Note: This is after the last symbol. r� N)ra r� r� r� rd r� r< r= r� 1 s �zBoolOp.__init__r� �r� r5 c C s |dur|| _ dS )znDo some setup after initialisation. :param values: The values being applied to the operator. Nr� �r� r� r< r< r= r� X s zBoolOp.postinitc c s | j E d H d S r6 r� r� r< r< r= r� ` s zBoolOp.get_childrenc C s t | j S r6 r~ r� r< r< r= r c s zBoolOp.op_precedencez nodes.BoolOprF r r� r) c + s� | j }| jdkrtj}ntj}z� fdd�|D �}W n tyP tjV Y dS 0 tj |� D ]|}t dd� |D ��r|tjV q\dd� |D �}t dd� |D ��r�tjV q\tj}t ||�D ]\}} || �r�|V q\q�|V q\t | � d �S ) z�Infer a boolean operation (and / or / not). The function will calculate the boolean operation for all pairs generated through inference for each component node. �orc s g | ]}|j � d ��qS )rG )rO ro rG r< r= r� x rn z!BoolOp._infer.<locals>.<listcomp>Nc s s | ]}t |tj�V qd S r6 rn �rk �itemr< r< r= rm ~ rn z BoolOp._infer.<locals>.<genexpr>c S s g | ] }|� � �qS r< )r� r� r< r< r= r� � rn c s s | ]}t |tj�V qd S r6 rn r� r< r< r= rm � rn rI ) r� ra �operator�truth�not_r r rL r� rs r_ �zipr* ) r� rH r� r� � predicateZinferred_values�pairZ bool_valuesr; r� r< rG r= r� f s0 z BoolOp._infer)NNN)N)N)r� r� r� r� r� r� r� r� r� r r r� r� r� r� r< r< r� r= r� # s" ��"' �r� c @ s e Zd ZdZdS )�Breakz�Class representing an :class:`ast.Break` node. >>> import astroid >>> node = astroid.extract_node('break') >>> node <Break l.1 at 0x7f23b2e9e5c0> N�r� r� r� r� r< r< r< r= r� � s r� c @ s� e Zd ZU dZdZded< ded< ded< dddd d �d d �Zed d�dd��Zedd�dd��Z dd� Z e j e j d dddd�dd���Zdd �d d �ZdS ) �Callz�Class representing an :class:`ast.Call` node. A :class:`Call` node is a call to a function, method, etc. >>> import astroid >>> node = astroid.extract_node('function()') >>> node <Call l.1 at 0x7f23b2e71eb8> �r r� �keywordsr( r rP r� z list[Keyword]r� r� )r r� r� r5 c C s || _ || _|| _d S r6 r� )r� r r� r� r< r< r= r� � s z Call.postinitz list[Starred]r4 c C s dd� | j D �S )z/The positional arguments that unpack something.c S s g | ]}t |t�r|�qS r< )r7 r� r r< r< r= r� � rn z!Call.starargs.<locals>.<listcomp>)r� r� r< r< r= �starargs� s z Call.starargsc C s dd� | j D �S )z,The keyword arguments that unpack something.c S s g | ]}|j d u r|�qS r6 �r )rk �keywordr< r< r= r� � rn z Call.kwargs.<locals>.<listcomp>)r� r� r< r< r= r� � s z Call.kwargsc c s$ | j V | jE d H | jE d H d S r6 r� r� r< r< r= r� � s zCall.get_childrenNrF r r4 r� c k s� t |�}d|_|dur&| �|�� �|_| j�|�D ]f}t|tj �rJ|V q2z6t |d�r~t | j | j |d�|_|j| |d�E dH W q2 ty� Y q2Y q20 q2t| |d�S )z?Infer a Call node by trying to guess what the function returns.N�infer_call_result)r� r� �callee)ZcallerrH rI )r r; �_populate_context_lookuprr Z extra_contextr rO r7 r rP r� r r� r� � callcontextr� r r* )r� rH r� r� r� r< r< r= r� � s& �� z Call._inferrG c C sf i }|du r|S | j D ]"}t|t�r0|||j< q|||< q| jdurJ| jng }|D ]}|||j< qR|S )zEAllows context to be saved for later for inference inside a function.N)r� r7 r� r; r� )r� rH Zcontext_lookupr r� r� r< r< r= r� � s z Call._populate_context_lookup)N)r� r� r� r� r� r+ r� �propertyr� r� r� r r� r� r� r� r< r< r< r= r� � s �r� c C s | |v S r6 r< ��a�br< r< r= �<lambda> rn r� c C s | |vS r6 r< r� r< r< r= r� rn )z==z!=�<z<=�>z>=�inznot inz%dict[str, Callable[[Any, Any], bool]]� COMPARE_OPS�iszis notc @ s� e Zd ZU dZdZded< ded< dddd�d d �Zd d � Zd d� Ze ddd�dd��Z ddddd�dd�Z d ddd d �d d �Z dS )!�CompareaL Class representing an :class:`ast.Compare` node. A :class:`Compare` node indicates a comparison. >>> import astroid >>> node = astroid.extract_node('a <= b <= c') >>> node <Compare l.1 at 0x7f23b2e9e6d8> >>> node.ops [('<=', <Name.b l.1 at 0x7f23b2e9e2b0>), ('<=', <Name.c l.1 at 0x7f23b2e9e390>)] �rp �opsr( rp zlist[tuple[str, NodeNG]]r� r� )rp r� r5 c C s || _ || _d S r6 r� )r� rp r� r< r< r= r� % s zCompare.postinitc c s" | j V | jD ]\}}|V qdS )z�Get the child nodes below this node. Overridden to handle the tuple fields and skip returning the operator strings. :returns: The children. :rtype: iterable(NodeNG) Nr� )r� r� Z comparatorr< r< r= r� ) s zCompare.get_childrenc C s | j d d S )zsAn optimized version of list(get_children())[-1] :returns: The last child. :rtype: NodeNG r rW )r� r� r< r< r= � last_child6 s zCompare.last_childr, r )rJ r5 c C s t �| �� �S r6 )�ast� literal_evalr )rJ r< r< r= � _to_literalA s zCompare._to_literalzIterable[InferenceResult]r� zbool | util.UninferableBase)� left_iterra � right_iterr5 c C s� d}|t v rtjS t| }t�||�D ]�\}}t|tj�sFt|tj�rPtj S z| �|�| �|� }}W n" t t t fy� tj Y S 0 z|||�}W n* t y� } zt | �W Y d} ~ n d} ~ 0 0 |du r�|}q&||kr&tj S q&|dus�J �|S )a� If all possible combinations are either True or False, return that: >>> _do_compare([1, 2], '<=', [3, 4]) True >>> _do_compare([1, 2], '==', [3, 4]) False If any item is uninferable, or if some combinations are True and some are False, return Uninferable: >>> _do_compare([1, 3], '<=', [2, 4]) util.Uninferable N)�UNINFERABLE_OPSr rL r� r� rs r7 rP r� � SyntaxErrorr| r? r~ r ) r� r� ra r� r� Zop_funcrp rq r: r� r< r< r= � _do_compareH s. � zCompare._do_compareNrF z-Generator[nodes.Const | util.UninferableBase]r� c k s� d}| j }| j}t|j|d��}|D ]Z\}}t|j|d��} z| �||| �}W n tyl tj}Y q�Y n0 |durz q�| }q$|tju r�|V n t|�V dS )z#Chained comparison inference logic.TrG N) r� rp r� rO r� r r rL rc ) r� rH r� r� r� Z left_noderx ra Z right_nodery r< r< r= r� x s" zCompare._infer)N) r� r� r� r� r� r+ r� r� r� � staticmethodr� r� r� r< r< r< r= r� s 1 �r� c @ sx e Zd ZU dZdZdZdZded< ded< ded < d ed < dddd d d �dd�Ze j Z dd� Z dd�dd�Z dd� ZdS )� Comprehensiona� Class representing an :class:`ast.comprehension` node. A :class:`Comprehension` indicates the loop inside any type of comprehension including generator expressions. >>> import astroid >>> node = astroid.extract_node('[x for x in some_values]') >>> list(node.get_children()) [<Name.x l.1 at 0x7f23b2e352b0>, <Comprehension l.1 at 0x7f23b2e35320>] >>> list(node.get_children())[1].as_string() 'for x in some_values' �r\ �iter�ifs)�is_asyncTr( r\ r� rP r� r3 r� r� )r\ r� r� r� r5 c C s || _ || _|| _|| _d S r6 )r\ r� r� r� )r� r\ r� r� r� r< r< r= r� � s zComprehension.postinitc C s | S )zwThe type of assignment that this node performs. :returns: The assignment type. :rtype: NodeNG r< r� r< r< r= � assign_type� s zComprehension.assign_typez _base_nodes.Statement | None)�mystmtc C s@ | |u r"t |ttf�r8|gdfS n| �� |u r8|gdfS |dfS )zmethod used in filter_stmtsTF)r7 rc r� Z statement)r� Z lookup_noderJ r� r� r< r< r= �_get_filtered_stmts� s z!Comprehension._get_filtered_stmtsc c s | j V | jV | jE d H d S r6 r� r� r< r< r= r� � s zComprehension.get_childrenN)r� r� r� r� r� r� �optional_assignr+ r� r �for_assigned_stmtsr� r� r� r� r< r< r< r= r� � s r� c s� e Zd ZdZdZd"ddd�dddddddd d �� fd d �ZejZej Z � fd d�Z d#dd�dd�Z dd�dd�Z dd� Zdd�dd�Zd$dd�d d �Zd%ddd d �d d!�Z� ZS )&rc a� Class representing any constant including num, str, bool, None, bytes. >>> import astroid >>> node = astroid.extract_node('(5, "This is a string.", True, None, b"bytes")') >>> node <Tuple.tuple l.1 at 0x7f23b2e358d0> >>> list(node.get_children()) [<Const.int l.1 at 0x7f23b2e35940>, <Const.str l.1 at 0x7f23b2e35978>, <Const.bool l.1 at 0x7f23b2e359b0>, <Const.NoneType l.1 at 0x7f23b2e359e8>, <Const.bytes l.1 at 0x7f23b2e35a20>] )r; �kindNr� r r� r� r� r� )r; r� r� rv r� r� r� r5 c s2 || _ || _t� j|||||d� t�| d� dS )a} :param value: The value that the constant represents. :param lineno: The line that this node appears on in the source code. :param col_offset: The column that this node appears on in the source code. :param parent: The parent node in the syntax tree. :param kind: The string prefix. "u" for u-prefixed strings and ``None`` otherwise. Python 3.8+ only. :param end_lineno: The last line this node appears on in the source code. :param end_col_offset: The end column this node appears on in the source code. Note: This is after the last symbol. r� N)r; r� r� r� r )r� r; r� r� rv r� r� r� r� r< r= r� � s �zConst.__init__c s |dkr t �t� �|�S )Nr; )r? r� � __getattr__r r� r< r= r� # s zConst.__getattr__rF rG c C s$ t |t�r|j}n,t |t�r*t||d�}ntdt|�� d���z$t | jttf�r`t| j| �W S W n� t y� } z$t d| j�d|���|�W Y d}~ntd}~0 t y� } z t d| ||d�|�W Y d}~n@d}~0 t �y } z td | ||d�|�W Y d}~n d}~0 0 t| �d | j� d ���dS ) a% Get an item from this node if subscriptable. :param index: The node to use as a subscript index. :type index: Const or Slice :raises AstroidTypeError: When the given index cannot be used as a subscript index, or if this node is not subscriptable. rG zCould not use type ry zCould not index z with Nz Index {index!r} out of rangero rx z (value=r/ )r7 rc r; rz rw r re r� �bytesr| r r} r r~ )r� rh rH � index_valuer� r< r< r= �getitem. s@ �������z Const.getitemr3 r4 c C s dS )z�Check if the node has a custom __getattr__ or __getattribute__. :returns: Whether the class has a custom __getattr__ or __getattribute__. For a :class:`Const` this is always ``False``. Fr< r� r< r< r= �has_dynamic_getattrV s zConst.has_dynamic_getattrc C s4 t | jt�r dd� | jD �S tdt| j�����dS )z�An iterator over the elements this node contains. :returns: The contents of this node. :rtype: iterable(Const) :raises TypeError: If this node does not represent something that is iterable. c S s g | ] }t |��qS r< )r� rj r< r< r= r� g rn z Const.itered.<locals>.<listcomp>zCannot iterate over type N)r7 r; r� r~ re r� r< r< r= r� ^ s z Const.iteredr� c C s | j �� S )r� )r< �qnamer� r< r< r= r� j s z Const.pytypec C s t | j�S �zzDetermine the boolean value of this node. :returns: The boolean value of this node. :rtype: bool )r3 r; r� r< r< r= r� q s zConst.bool_valuezIterator[Const]r� c k s | V d S r6 r< rJ r< r< r= r� y s z Const._infer)NNNN)N)N)N)r� r� r� r� r� r� r Zconst_infer_unary_op�infer_unary_opZconst_infer_binary_op�infer_binary_opr� r� r� r� r� r� r� r� r< r< r� r= rc � s( ��$, ( �rc c @ s e Zd ZdZdS )�Continuez�Class representing an :class:`ast.Continue` node. >>> import astroid >>> node = astroid.extract_node('continue') >>> node <Continue l.1 at 0x7f23b2e35588> Nr� r< r< r< r= r� s r� c @ sD e Zd ZU dZdZded< ddd�dd�Zd d �d d �Zd d� ZdS )� Decoratorsa� A node representing a list of decorators. A :class:`Decorators` is the decorators that are applied to a method or function. >>> import astroid >>> node = astroid.extract_node(''' @property def my_property(self): return 3 ''') >>> node <FunctionDef.my_property l.2 at 0x7f23b2e35d30> >>> list(node.get_children())[0] <Decorators l.1 at 0x7f23b2e35d68> r0 rP r1 r� )r1 r5 c C s || _ d S r6 r0 )r� r1 r< r< r= r� � s zDecorators.postinitr2 r4 c C s0 | j st| d��| j j s$t| j d��| j j �� S �z�The first parent node defining a new scope. These can be Module, FunctionDef, ClassDef, Lambda, or GeneratorExp nodes. :returns: The first parent scope node. �r\ )rv r" r� r� r< r< r= r� � s zDecorators.scopec c s | j E d H d S r6 r0 r� r< r< r= r� � s zDecorators.get_childrenN) r� r� r� r� r� r+ r� r� r� r< r< r< r= r� � s r� c s\ e Zd ZU dZdZdZded< ddddddd d �� fd d � Zdd d �dd�Zdd� Z � Z S )�DelAttra Variation of :class:`ast.Delete` representing deletion of an attribute. >>> import astroid >>> node = astroid.extract_node('del self.attr') >>> node <Delete l.1 at 0x7f23b2e35f60> >>> list(node.get_children())[0] <DelAttr.attr l.1 at 0x7f23b2e411d0> rB rC r( r: r� rd r� r� rD c s || _ t� j|||||d� d S r� rE rF r� r< r= r� � s �zDelAttr.__init__rG c C s || _ d S r6 rB rH r< r< r= r� � s zDelAttr.postinitc c s | j V d S r6 rB r� r< r< r= r� � s zDelAttr.get_children� r� r� r� r� r� r� r+ r� r� r� r� r< r< r� r= r� � s r� c sL e Zd ZdZdZddddddd�� fdd � Zd dd �d d �Zdd� Z� ZS )�Deletez�Class representing an :class:`ast.Delete` node. A :class:`Delete` is a ``del`` statement this is deleting something. >>> import astroid >>> node = astroid.extract_node('del self.attr') >>> node <Delete l.1 at 0x7f23b2e35f60> �rQ rd r( r� r� r� c s g | _ t� j|||||d� d S r� )rQ r� r� r� r� r< r= r� � s �zDelete.__init__rP )rQ r5 c C s || _ d S r6 r� )r� rQ r< r< r= r� s zDelete.postinitc c s | j E d H d S r6 r� r� r< r< r= r� s zDelete.get_children) r� r� r� r� r� r� r� r� r� r< r< r� r= r� � s r� c s� e Zd ZdZdZddddddd�� fdd� Zd dd �d d �ZejZ d d�dd�Z dd� Z dd� Z dd� Z d-dddd�d d �Zd.dd �d d �Zd/dd!d"d#�d$d%�Zed&d&d&d'�d(d)��Zdd&d*�d+d,�Z� ZS )0�Dictz�Class representing an :class:`ast.Dict` node. A :class:`Dict` is a dictionary that is created with ``{}`` syntax. >>> import astroid >>> node = astroid.extract_node('{1: "1"}') >>> node <Dict.dict l.1 at 0x7f23b2e35cc0> ��itemsr� r� r� r� c s g | _ t� j|||||d� d S r� )r� r� r� r� r� r< r= r� s �z Dict.__init__z-list[tuple[InferenceResult, InferenceResult]])r� r5 c C s || _ dS )ztDo some setup after initialisation. :param items: The key-value pairs contained in the dictionary. Nr� )r� r� r< r< r= r� * s z Dict.postinitzLiteral['builtins.dict']r4 c C s dS )r� z builtins.dictr< r� r< r< r= r� 3 s z Dict.pytypec c s | j D ]\}}|V |V qdS )z�Get the key and value nodes below this node. Children are returned in the order that they are defined in the source code, key first then the value. :returns: The children. :rtype: iterable(NodeNG) Nr� )r� �keyr; r< r< r= r� : s zDict.get_childrenc C s | j r| j d d S dS )z�An optimized version of list(get_children())[-1] :returns: The last child, or None if no children exist. :rtype: NodeNG or None r rW Nr� r� r< r< r= r� G s zDict.last_childc C s dd� | j D �S )z�An iterator over the keys this node contains. :returns: The keys of this node. :rtype: iterable(NodeNG) c S s g | ] \}}|�qS r< r< )rk r� r� r< r< r= r� W rn z Dict.itered.<locals>.<listcomp>r� r� r< r< r= r� Q s z Dict.iteredNz Const | SlicerF r( )rh rH r5 c C s� | j D ]�\}}t|t�r^t�||�}t|t�s0qz|�||�W S ttfy\ Y qY n0 |� |�D ]>}t|tj �rzqht|t �rht|t �rh|j |j krh| S qhqt|��dS )aT Get an item from this node. :param index: The node to use as a subscript index. :raises AstroidTypeError: When the given index cannot be used as a subscript index, or if this node is not subscriptable. :raises AstroidIndexError: If the given index does not exist in the dictionary. N) r� r7 � DictUnpackr r� r� r� r r rO rP rc r; )r� rh rH r� r; Zinferred_valueZ inferredkeyr< r< r= r� Y s z Dict.getitemrG c C s t | j�S r� )r3 r� r� r< r< r= r� z s zDict.bool_valuer zIterator[nodes.Dict]r� c k sb t dd� | jD ��s | V nB| �|�}t| �| j| j| j| j| jd�}|� t |�� �� |V d S )Nc s s | ]\}}t |t�V qd S r6 )r7 r� )rk �kr� r< r< r= rm � rn z Dict._infer.<locals>.<genexpr>r� ) r_ r� � _infer_mapre r� r� rv r� r� r� r� )r� rH r� r� r� r< r< r= r� � s �z Dict._inferz:dict[SuccessfulInferenceResult, SuccessfulInferenceResult])�lhs_dict�rhs_dictr5 c C s. t �| �� |�� �}dd� |D �}t|�� �S )a* Delete nodes that equate to duplicate keys. Since an astroid node doesn't 'equal' another node with the same value, this function uses the as_string method to make sure duplicate keys don't get through Note that both the key and the value are astroid nodes Fixes issue with DictUnpack causing duplicate keys in inferred Dict items :param lhs_dict: Dictionary to 'merge' nodes into :param rhs_dict: Dictionary with nodes to pull from :return : merged dictionary of nodes c S s i | ]\}}|� � ||f�qS r< )r )rk r� r; r< r< r= � <dictcomp>� rn z1Dict._update_with_replacement.<locals>.<dictcomp>)r� r� r� �dictr� )r� r� Z combined_dictZ string_mapr< r< r= �_update_with_replacement� s z Dict._update_with_replacementr� c C s� i }| j D ]�\}}t|t�r^t�||�}|s0t�t|t�sFt| |d��|�|�}| �||�}q tj||d�}tj||d�}t dd� ||fD ��r�t| |d��| �|||i�}q |S )z%Infer all values based on Dict.items.rI rG c s s | ] }| V qd S r6 r< rj r< r< r= rm � rn z"Dict._infer_map.<locals>.<genexpr>) r� r7 r� r r� r r� r� r� r_ ) r� rH r� r� r; Zdouble_starredZ unpack_itemsr� Z safe_valuer< r< r= r� � s zDict._infer_map)N)N)N)r� r� r� r� r� r� r� r Zdict_infer_unary_opr� r� r� r� r� r� r� r� r� r� r� r� r< r< r� r= r� s" �! �r� c @ sF e Zd ZU dZdZded< ddd�dd�Zd d � Zd d � Zd d� Z dS )�Expra6 Class representing an :class:`ast.Expr` node. An :class:`Expr` is any expression that does not have its value used or stored. >>> import astroid >>> node = astroid.extract_node('method()') >>> node <Call l.1 at 0x7f23b2e352b0> >>> node.parent <Expr l.1 at 0x7f23b2e35278> r: r( r; r� �r; r5 c C s || _ d S r6 r: �r� r; r< r< r= r� � s z Expr.postinitc c s | j V d S r6 r: r� r< r< r= r� � s zExpr.get_childrenc c s | j js| j �� E d H d S r6 )r; Z is_functionrV r� r< r< r= rV � s z$Expr._get_yield_nodes_skip_functionsc c s | j js| j �� E d H d S r6 )r; Z is_lambdarW r� r< r< r= rW � s z"Expr._get_yield_nodes_skip_lambdasN� r� r� r� r� r� r+ r� r� rV rW r< r< r< r= r� � s r� c sl e Zd ZdZdZdddd�ddddddd�� fdd�Zdd �d d �Zejej dd d dd�dd���Z � Z S )� EmptyNodezAHolds an arbitrary object in the :attr:`LocalsDictNodeNG.locals`.Nr� r� r� c s t � j|||||d� d S r� �r� r� r� r� r< r= r� � s �zEmptyNode.__init__r3 r4 c C s | j d uo| j tuS r6 )�objectr r� r< r< r= �has_underlying_object� s z EmptyNode.has_underlying_objectrF r r( r� c k sN | � � stjV n8z t� j| j|d�E d H W n tyH tjV Y n0 d S )NrG )r� r rL r% Zinfer_ast_from_somethingr� r rJ r< r< r= r� s � zEmptyNode._infer)NNN)N) r� r� r� r� r� r� r� r r� r� r� r� r< r< r� r= r� � s �� �r� c @ sp e Zd ZU dZdZdZded< ded< ded < ejZ dddd d �d d �Z dd� Z e dd� �Z ddd�dd�ZdS )� ExceptHandlera� Class representing an :class:`ast.ExceptHandler`. node. An :class:`ExceptHandler` is an ``except`` block on a try-except. >>> import astroid >>> node = astroid.extract_node(''' try: do_something() except Exception as error: print("Error!") ''') >>> node <Try l.2 at 0x7f23b2e9d908> >>> node.handlers [<ExceptHandler l.4 at 0x7f23b2e9e860>] �re r� rZ �rZ r� re r� r� rP rZ r� )re r� rZ r5 c C s || _ || _|| _d S r6 r� )r� re r� rZ r< r< r= r� 5 s zExceptHandler.postinitc c s4 | j d ur| j V | jd ur$| jV | jE d H d S r6 r� r� r< r< r= r� ? s zExceptHandler.get_childrenc C s" | j r| j jS | jr | jjS | jS ��PThe line on which the beginning of this block ends. :type: int )r� �tolinenore r� r� r< r< r= �blockstart_tolinenoH s z!ExceptHandler.blockstart_tolinenorT r3 rU c s2 | j du s� du rdS t� fdd�| j �� D ��S )zzCheck if this node handles any of the given :param exceptions: The names of the exceptions to check for. NTc 3 s | ]}|j � v V qd S r6 r� )rk rJ �rV r< r= rm [ rn z&ExceptHandler.catch.<locals>.<genexpr>)re r_ r� )r� rV r< r� r= r^ T s zExceptHandler.catchN)r� r� r� r� r� �_multi_line_block_fieldsr+ r Z excepthandler_assigned_stmtsr� r� r� r r� r^ r< r< r< r= r� s r� c @ s| e Zd ZU dZdZdZdZdZded< ded< d ed < d ed < d ed < ddd d d dd�dd�Z e j Z e dd� �Zdd� ZdS )�Forz�Class representing an :class:`ast.For` node. >>> import astroid >>> node = astroid.extract_node('for thing in things: print(thing)') >>> node <For l.1 at 0x7f23b2e8cf28> �r\ r� rZ r[ rT �rZ r[ Tr( r\ r� rP rZ r[ r� rR r� )r\ r� rZ r[ rR r5 c C s" || _ || _|| _|| _|| _d S r6 )r\ r� rZ r[ rR )r� r\ r� rZ r[ rR r< r< r= r� � s z For.postinitc C s | j jS r� )r� r� r� r< r< r= r� � s zFor.blockstart_tolinenoc c s, | j V | jV | jE d H | jE d H d S r6 r� r� r< r< r= r� � s zFor.get_childrenN)r� r� r� r� r� rX r� r� r+ r� r r� r� r r� r� r< r< r< r= r� ^ s r� c @ s e Zd ZdZdS )�AsyncFora� Class representing an :class:`ast.AsyncFor` node. An :class:`AsyncFor` is an asynchronous :class:`For` built with the ``async`` keyword. >>> import astroid >>> node = astroid.extract_node(''' async def func(things): async for thing in things: print(thing) ''') >>> node <AsyncFunctionDef.func l.2 at 0x7f23b2e416d8> >>> node.body[0] <AsyncFor l.3 at 0x7f23b2e417b8> Nr� r< r< r< r= r� � s r� c @ s6 e Zd ZU dZdZded< ddd�dd�Zd d � Zd S ) �Awaita� Class representing an :class:`ast.Await` node. An :class:`Await` is the ``await`` keyword. >>> import astroid >>> node = astroid.extract_node(''' async def func(things): await other_func() ''') >>> node <AsyncFunctionDef.func l.2 at 0x7f23b2e41748> >>> node.body[0] <Expr l.3 at 0x7f23b2e419e8> >>> list(node.body[0].get_children())[0] <Await l.3 at 0x7f23b2e41a20> r: r( r; r� r� c C s || _ d S r6 r: r� r< r< r= r� � s zAwait.postinitc c s | j V d S r6 r: r� r< r< r= r� � s zAwait.get_childrenNrN r< r< r< r= r� � s r� c sf e Zd ZdZdZdddd�dddddd ddd d � � fd d �Zejejdddddd�dd���Z � Z S )� ImportFromz�Class representing an :class:`ast.ImportFrom` node. >>> import astroid >>> node = astroid.extract_node('from my_package import my_module') >>> node <ImportFrom l.1 at 0x7f23b2e415c0> )�modname�names�levelr Nr� r� � list[tuple[str, str | None]]r� r� r� ) �fromnamer� r� r� r� rv r� r� r5 c s, || _ || _|| _t� j|||||d� dS )a� :param fromname: The module that is being imported from. :param names: What is being imported from the module. :param level: The level of relative import. :param lineno: The line that this node appears on in the source code. :param col_offset: The column that this node appears on in the source code. :param parent: The parent node in the syntax tree. :param end_lineno: The last line this node appears on in the source code. :param end_col_offset: The end column this node appears on in the source code. Note: This is after the last symbol. r� N)r� r� r� r� r� ) r� r� r� r� r� r� rv r� r� r� r< r= r� � s �zImportFrom.__init__TrF r3 r r( �rH �asnamer� r5 c K s |pt � }|j}|du r$t| |d��|rjz| �|�}W n2 tyh } zt| |d�|�W Y d}~n d}~0 0 z | �� }W n2 ty� } zt| |d�|�W Y d}~n d}~0 0 z0t|�}||_|j||| � � u d�}t ||�W S t�y } z"tt |�| ||d�|�W Y d}~n d}~0 0 dS )z;Infer a ImportFrom node: return the imported module/object.NrI )Z ignore_locals�r\ � attributerH ) r r� r � real_namer �do_import_moduler r r �rootr r� ) r� rH r� r� r� r� �moduler� �errorr< r< r= r� s0 $ $ ��zImportFrom._infer)r NNN)NT� r� r� r� r� r� r� r r� r� r� r� r< r< r� r= r� � s � �&< �r� c s| e Zd ZU dZded< dZdZddddddd d �� fd d � Zdd d �dd�Zdd� Z e j e j ddddd�dd���Z � ZS )� Attributez2Class representing an :class:`ast.Attribute` node.r( r: rB rC r� rd r� r� rD c s || _ t� j|||||d� d S r� rE rF r� r< r= r� J s �zAttribute.__init__rG c C s || _ d S r6 rB rH r< r< r= r� _ s zAttribute.postinitc c s | j V d S r6 rB r� r< r< r= r� b s zAttribute.get_childrenNrF r r4 r� c K s t | |fi |��S r6 rI rJ r< r< r= r� e s zAttribute._infer)N)r� r� r� r� r+ r� r� r� r� r� r r� r� r� r� r< r< r� r= r B s �r c sh e Zd ZdZdZdddd�dddddddd �� fd d �Zd d � Zejej ddddd�dd���Z � Z S )�Globalz�Class representing an :class:`ast.Global` node. >>> import astroid >>> node = astroid.extract_node('global a_global') >>> node <Global l.1 at 0x7f23b2e9de10> �r� Nr� � list[str]r� r� r� �r� r� r� rv r� r� r5 c s || _ t� j|||||d� dS )a :param names: The names being declared as global. :param lineno: The line that this node appears on in the source code. :param col_offset: The column that this node appears on in the source code. :param parent: The parent node in the syntax tree. :param end_lineno: The last line this node appears on in the source code. :param end_col_offset: The end column this node appears on in the source code. Note: This is after the last symbol. r� N�r� r� r� �r� r� r� r� rv r� r� r� r< r= r� x s �zGlobal.__init__c C s |S r6 r< r� r< r< r= r� � s zGlobal._infer_namerF r r( r� c K sx |d u s|j d u r t| |d��zt| �� �|j �|�W S tyr } z$tt|�| |j |d�|�W Y d }~n d }~0 0 d S )NrI r� )r� r r r� r r r� )r� rH r� r� r< r< r= r� � s ��z Global._infer)NNN)N) r� r� r� r� r� r� r� r r� r� r� r� r< r< r� r= r m s ��"$ �r c s� e Zd ZU dZdZdZded< ded< ded< dddd d �d d �Zed d� �Z ddd�dd�Z dd� Z dd� Z � fdd�Z � fdd�Z� ZS ) r\ z�Class representing an :class:`ast.If` node. >>> import astroid >>> node = astroid.extract_node('if condition: print(True)') >>> node <If l.1 at 0x7f23b2e9dd30> �rX rZ r[ r� r( rX rP rZ r[ r� �rX rZ r[ r5 c C s || _ || _|| _d S r6 r �r� rX rZ r[ r< r< r= r� � s z If.postinitc C s | j jS r� �rX r� r� r< r< r= r� � s zIf.blockstart_tolinenord �tuple[int, int]�r� r5 c C sT || j d jkr||fS || j d jkr8|| j d jfS | �|| j| j d jd �S )��Get a range from the given line number to where this node ends. :param lineno: The line number to start the range at. :returns: The range of line numbers that this node belongs to, starting at the given line number. r r rW )rZ r� r� �_elsed_block_ranger[ r� r< r< r= � block_range� s zIf.block_rangec c s$ | j V | jE d H | jE d H d S r6 r r� r< r< r= r� � s zIf.get_childrenc C s t | j�dko t| jd t�S )NrW r )r r[ r7 r\ r� r< r< r= �has_elif_block� s zIf.has_elif_blockc # s$ | j �� E dH t� �� E dH dS �z/An If node can contain a Yield node in the testN�rX rV r� r� r� r< r= rV � s z"If._get_yield_nodes_skip_functionsc # s$ | j �� E dH t� �� E dH dS r �rX rW r� r� r� r< r= rW � s z If._get_yield_nodes_skip_lambdas)r� r� r� r� r� r� r+ r� r r� r r� r rV rW r� r< r< r� r= r\ � s r\ c @ sr e Zd ZU dZdZded< ded< ded< ddddd�d d �Zd d � Zd d�dd�Ze j ddddd�dd��Z dS )�IfExpz�Class representing an :class:`ast.IfExp` node. >>> import astroid >>> node = astroid.extract_node('value if condition else other') >>> node <IfExp l.1 at 0x7f23b2e9dbe0> r r( rX rZ r[ r� r c C s || _ || _|| _d S r6 r r r< r< r= r� s zIfExp.postinitc c s | j V | jV | jV d S r6 r r� r< r< r= r� s zIfExp.get_childrenzLiteral[False]r4 c C s dS )NFr< r� r< r< r= r� s zIfExp.op_left_associativeNrF r r( r� c k s� d}|p t � }t|�}t|�}zt| jj|�� d��}W n ttfyR d}Y nF0 t|t j �s�|� � r~| j j|d�E dH q�| j j|d�E dH nd}|r�| j j|d�E dH | j j|d�E dH dS )z�Support IfExp inference. If we can't infer the truthiness of the condition, we default to inferring both branches. Otherwise, we infer either branch depending on the condition. FrG TN)r r rN rX rO rr r rf r7 r rP r� rZ r[ )r� rH r� Z both_branchesr� ru rX r< r< r= r� s z IfExp._infer)N) r� r� r� r� r� r+ r� r� r� r r� r� r< r< r< r= r � s �r c sb e Zd ZdZdZdddd�dddddddd �� fd d �Zejejdd dddd�dd���Z � Z S )�Importz�Class representing an :class:`ast.Import` node. >>> import astroid >>> node = astroid.extract_node('import astroid') >>> node <Import l.1 at 0x7f23b2e4e5c0> r Nr� r� r� r� r� r c s || _ t� j|||||d� dS )a :param names: The names being imported. :param lineno: The line that this node appears on in the source code. :param col_offset: The column that this node appears on in the source code. :param parent: The parent node in the syntax tree. :param end_lineno: The last line this node appears on in the source code. :param end_col_offset: The end column this node appears on in the source code. Note: This is after the last symbol. r� Nr r r� r< r= r� B s �zImport.__init__TrF r3 r zGenerator[nodes.Module]r� c k s� |pt � }|j}|du r$t| |d��z(|r>| �| �|��V n | �|�V W n2 ty~ } zt| |d�|�W Y d}~n d}~0 0 dS )z8Infer an Import node: return the imported module/object.NrI )r r� r r� r� r )r� rH r� r� r� r� r< r< r= r� j s z Import._infer)NNN)NTr r< r< r� r= r 8 s ��"( �r c s\ e Zd ZU dZdZdZded< dddddddd �� fd d � Zddd �d d�Zdd� Z � Z S )�Keywordz�Class representing an :class:`ast.keyword` node. >>> import astroid >>> node = astroid.extract_node('function(a_kwarg=True)') >>> node <Call l.1 at 0x7f23b2e9e320> >>> node.keywords [<Keyword l.1 at 0x7f23b2e9e9b0>] r: r� r( r; r� r� r� )r r� r� rv r� r� r5 c s || _ t� j|||||d� d S r� )r r� r� )r� r r� r� rv r� r� r� r< r= r� � s �zKeyword.__init__r� c C s || _ d S r6 r: r� r< r< r= r� � s zKeyword.postinitc c s | j V d S r6 r: r� r< r< r= r� � s zKeyword.get_childrenr� r< r< r� r= r � s r c sp e Zd ZdZdZdddd�dddddddd �� fd d �ZejZej Z ej Z d d �dd�Z ddd�dd�Z� ZS )rB z�Class representing an :class:`ast.List` node. >>> import astroid >>> node = astroid.extract_node('[1, 2, 3]') >>> node <List.list l.1 at 0x7f23b2e9e128> ��ctxNr� �Context | Noner� r� r� �r r� r� rv r� r� r5 c s || _ t� j|||||d� dS )a :param ctx: Whether the list is assigned to or loaded from. :param lineno: The line that this node appears on in the source code. :param col_offset: The column that this node appears on in the source code. :param parent: The parent node in the syntax tree. :param end_lineno: The last line this node appears on in the source code. :param end_col_offset: The end column this node appears on in the source code. Note: This is after the last symbol. r� N�r r� r� �r� r r� r� rv r� r� r� r< r= r� � s �z List.__init__zLiteral['builtins.list']r4 c C s dS )r� z builtins.listr< r� r< r< r= r� � s z List.pytyperF rG c C s t | | j||d�S �z�Get an item from this node. :param index: The node to use as a subscript index. :type index: Const or Slice rG �r� rK �r� rh rH r< r< r= r� � s z List.getitem)NNNN)N)r� r� r� r� r� r� r �sequence_assigned_stmtsr� Zlist_infer_unary_opr� �tl_infer_binary_opr� r� r� r� r< r< r� r= rB � s ��"$rB c sH e Zd ZdZdZdddd�dddddddd �� fd d �Zd d � Z� ZS )�Nonlocala Class representing an :class:`ast.Nonlocal` node. >>> import astroid >>> node = astroid.extract_node(''' def function(): nonlocal var ''') >>> node <FunctionDef.function l.2 at 0x7f23b2e9e208> >>> node.body[0] <Nonlocal l.3 at 0x7f23b2e9e908> r Nr� r r� r� r� r c s || _ t� j|||||d� dS )a :param names: The names being declared as not local. :param lineno: The line that this node appears on in the source code. :param col_offset: The column that this node appears on in the source code. :param parent: The parent node in the syntax tree. :param end_lineno: The last line this node appears on in the source code. :param end_col_offset: The end column this node appears on in the source code. Note: This is after the last symbol. r� Nr r r� r< r= r� s �zNonlocal.__init__c C s |S r6 r< r� r< r< r= r� ) s zNonlocal._infer_name)NNN)r� r� r� r� r� r� r� r� r< r< r� r= r# � s ��"$r# c sh e Zd ZU dZdZded< ddddddd�� fd d � Zddd �d d �Zddddd�dd�Ze j Z � Z S )� ParamSpecz�Class representing a :class:`ast.ParamSpec` node. >>> import astroid >>> node = astroid.extract_node('type Alias[**P] = Callable[P, int]') >>> node.type_params[0] <ParamSpec l.1 at 0x7f23b2e4e198> r� rD r� rd r( r� r� c s t � j|||||d� d S r� r� r� r� r< r= r� : s �zParamSpec.__init__�r� r5 c C s || _ d S r6 r� r r< r< r= r� K s zParamSpec.postinitNrF r zIterator[ParamSpec]r� c k s | V d S r6 r< rJ r< r< r= r� N s zParamSpec._infer)N� r� r� r� r� r� r+ r� r� r� r Zgeneric_type_assigned_stmtsr� r� r< r< r� r= r$ - s �r$ c @ s e Zd ZdZdS )�Passz�Class representing an :class:`ast.Pass` node. >>> import astroid >>> node = astroid.extract_node('pass') >>> node <Pass l.1 at 0x7f23b2e9e748> Nr� r< r< r< r= r' Y s r' c @ sN e Zd ZU dZdZded< ded< dddd�dd �Zd d �d d �Zdd� ZdS )�Raisez�Class representing an :class:`ast.Raise` node. >>> import astroid >>> node = astroid.extract_node('raise RuntimeError("Something bad happened!")') >>> node <Raise l.1 at 0x7f23b2e9e828> �r� �causer� r� r* r� )r� r* r5 c C s || _ || _d S r6 r) )r� r� r* r< r< r= r� t s zRaise.postinitr3 r4 c C s" | j s dS tdd� | j �� D ��S )z�Check if this node raises a :class:`NotImplementedError`. :returns: Whether this node raises a :class:`NotImplementedError`. Fc s s | ]}|j d kV qdS )�NotImplementedErrorNr� )rk r� r< r< r= rm � s z/Raise.raises_not_implemented.<locals>.<genexpr>)r� r_ r� r� r< r< r= �raises_not_implemented| s �z Raise.raises_not_implementedc c s( | j d ur| j V | jd ur$| jV d S r6 r) r� r< r< r= r� � s zRaise.get_childrenN) r� r� r� r� r� r+ r� r, r� r< r< r< r= r( c s r( c @ sF e Zd ZU dZdZded< ddd�dd�Zd d � Zd d � Zd d� Z dS )�Returnz�Class representing an :class:`ast.Return` node. >>> import astroid >>> node = astroid.extract_node('return True') >>> node <Return l.1 at 0x7f23b8211908> r: r� r; r� r� c C s || _ d S r6 r: r� r< r< r= r� � s zReturn.postinitc c s | j d ur| j V d S r6 r: r� r< r< r= r� � s zReturn.get_childrenc C s t | jt�S r6 )r7 r; rC r� r< r< r= �is_tuple_return� s zReturn.is_tuple_returnc c s | V d S r6 r< r� r< r< r= � _get_return_nodes_skip_functions� s z'Return._get_return_nodes_skip_functionsN) r� r� r� r� r� r+ r� r� r. r/ r< r< r< r= r- � s r- c @ s$ e Zd ZdZejZdd�dd�ZdS )�Setz�Class representing an :class:`ast.Set` node. >>> import astroid >>> node = astroid.extract_node('{1, 2, 3}') >>> node <Set.set l.1 at 0x7f23b2e71d68> zLiteral['builtins.set']r4 c C s dS )r� z builtins.setr< r� r< r< r= r� � s z Set.pytypeN)r� r� r� r� r Zset_infer_unary_opr� r� r< r< r< r= r0 � s r0 c @ s� e Zd ZU dZdZded< ded< ded< ddddd�d d �Zd d � Zed d�dd��Z dd�dd�Z dd�dd�Z d(dddd�d d �Z d)dd �d d �Z d!d"� Zd*dd#d$d%�d&d'�ZdS )+rz z�Class representing an :class:`ast.Slice` node. >>> import astroid >>> node = astroid.extract_node('things[1:3]') >>> node <Subscript l.1 at 0x7f23b2e71f60> >>> node.slice <Slice l.1 at 0x7f23b2e71e80> �rq rr rs r� rq rr rs r� )rq rr rs r5 c C s || _ || _|| _d S r6 r1 )r� rq rr rs r< r< r= r� � s zSlice.postinitc C s |st |�}| |_|S |S )z7Wrap the empty attributes of the Slice in a Const node.)r� rv )r� �attr�constr< r< r= �_wrap_attribute� s zSlice._wrap_attributeznodes.ClassDefr4 c C s t � j}|�d�d S )Nru r )r% Zbuiltins_moduler )r� �builtinsr< r< r= r< � s zSlice._proxiedzLiteral['builtins.slice']c C s dS )r� zbuiltins.slicer< r� r< r< r= r� � s z Slice.pytypezLiteral['Slice']c C s dS )zVA human readable type of this node. :returns: The type of this node. rz r< r� r< r< r= � display_type� s zSlice.display_typeNr� rF z#Iterator[SuccessfulInferenceResult])r= rH r5 c c s` |dkr| � | j�V nD|dkr0| � | j�V n,|dkrH| � | j�V n| j||d�E dH dS )z�Infer the possible values of the given attribute on the slice. :param attrname: The name of the attribute to infer. :returns: The inferred possible values. �start�stoprs rG N)r4 rq rr rs r �r� r= rH r< r< r= r> � s zSlice.igetattrrG c C s | j �||�S r6 )r< r r9 r< r< r= r s z Slice.getattrc c s: | j d ur| j V | jd ur$| jV | jd ur6| jV d S r6 r1 r� r< r< r= r� s zSlice.get_childrenr zIterator[Slice]r� c k s | V d S r6 r< rJ r< r< r= r� s z Slice._infer)N)N)N)r� r� r� r� r� r+ r� r4 r r< r� r6 r> r r� r� r< r< r< r= rz � s" � �rz c sb e Zd ZU dZdZdZded< ddddddd d �� fd d � Zdd d �dd�Ze j Z dd� Z � Z S )r� z�Class representing an :class:`ast.Starred` node. >>> import astroid >>> node = astroid.extract_node('*args') >>> node <Starred l.1 at 0x7f23b2e41978> r: r r( r; r rd r� r� r c s || _ t� j|||||d� d S r� r r r� r< r= r� - s �zStarred.__init__r� c C s || _ d S r6 r: r� r< r< r= r� B s zStarred.postinitc c s | j V d S r6 r: r� r< r< r= r� J s zStarred.get_children)r� r� r� r� r� r� r+ r� r� r Zstarred_assigned_stmtsr� r� r� r< r< r� r= r� s r� c s� e Zd ZU dZe� ZdZdZded< ded< ddddd d d d �� fd d � Z ddd d�dd�Z dd� Z d dddd�dd�Z e je jd ddd�dd ���Ze jd!ddd�d d ��Z� ZS )"� Subscriptz�Class representing an :class:`ast.Subscript` node. >>> import astroid >>> node = astroid.extract_node('things[1:3]') >>> node <Subscript l.1 at 0x7f23b2e71f60> �r; ru r r( r; ru r rd r� r� r c s || _ t� j|||||d� d S r� r r r� r< r= r� a s �zSubscript.__init__)r; ru r5 c C s || _ || _d S r6 r; )r� r; ru r< r< r= r� w s zSubscript.postinitc c s | j V | jV d S r6 r; r� r< r< r= r� { s zSubscript.get_childrenNrF r r� r� c k s\ ddl m} d}| j�|�D �]&}t|tj�r<tjV dS | j�|�D ]�}t|tj�rhtjV dS | j }|j t kr~|}n"|j t kr�|� |�}|r�|}n|}|| j u r�t | |d��z|�||�} W n> tttttf�y } zt | |d�| �W Y d} ~ n d} ~ 0 0 | | u �s t| tj��r.tjV dS | �|�E dH d}qHq |�rXt| |d�S dS )z�Inference for subscripts. We're understanding if the index is a Const or a slice, passing the result of inference to the value's `getitem` method, which should handle each supported index type accordingly. r )�helpersFNrI T)�astroidr< r; rO r7 r rP rL ru �_SUBSCRIPT_SENTINELr{ r Zclass_instance_as_indexr r� r r r r r? r* ) r� rH r� r< Z found_oner; rh r� Zinstance_as_index�assignedr� r< r< r= �_infer_subscript sL �$ zSubscript._infer_subscript)rH r� c K s | j |fi |��S r6 �r@ rJ r< r< r= r� � s zSubscript._inferc K s | j |fi |��S r6 rA rJ r< r< r= r� � s zSubscript.infer_lhs)N)N)N)r� r� r� r� r� r> r� r� r+ r� r� r� r@ r r� r� r� r� r� r< r< r� r= r: N s �;r: c sn e Zd ZdZdZdZddddddd�� fdd� Zd d d d dd �d d �Zdd� Zddd�dd�Z dd� Z � Z S )r] a@ Class representing a :class:`ast.Try` node. >>> import astroid >>> node = astroid.extract_node(''' try: do_something() except Exception as error: print("Error!") finally: print("Cleanup!") ''') >>> node <Try l.2 at 0x7f23b2e41d68> �rZ rY r[ � finalbodyrd r( r� �r� r� r� r� rv r5 c s2 g | _ g | _g | _g | _t� j|||||d� dS ��� :param lineno: The line that this node appears on in the source code. :param col_offset: The column that this node appears on in the source code. :param parent: The parent node in the syntax tree. :param end_lineno: The last line this node appears on in the source code. :param end_col_offset: The end column this node appears on in the source code. Note: This is after the last symbol. r� N�rZ rY r[ rC r� r� �r� r� r� r� r� rv r� r< r= r� � s �z Try.__init__rP zlist[ExceptHandler]�rZ rY r[ rC r5 c C s || _ || _|| _|| _dS )a& Do some setup after initialisation. :param body: The contents of the block to catch exceptions from. :param handlers: The exception handlers. :param orelse: The contents of the ``else`` block. :param finalbody: The contents of the ``finally`` block. NrB �r� rZ rY r[ rC r< r< r= r� s z Try.postinitc C s |S r6 r< r� r< r< r= r� s zTry._infer_namer r c C s� || j kr||fS | jrP| jd j | kr<| jd jkrPn n|| jd jfS | jD ]^}|jrx||jj krx||f S |jd j | kr�|jd jkrVn qV||jd jf S qV| j�r| jd j d |kr�||fS | jd j | k�r| jd jk�rn n|| jd jfS | j�rx| jd j d |k�r<||fS | jd j | k�rd| jd jk�rxn n|| jd jfS || jfS �z=Get a range from a given line number to where this node ends.r r rW �r� rZ r� rY re r[ rC �r� r� Z exhandlerr< r< r= r s( . (,,zTry.block_rangec c s4 | j E d H | jE d H | jE d H | jE d H d S r6 rB r� r< r< r= r� 3 s zTry.get_children� r� r� r� r� r� r� r� r� r� r r� r� r< r< r� r= r] � s *r] c s� e Zd ZdZdZdZdddddd�ddddddd�� fd d �Zddddd�d d d d dd �dd�Zdd� Zddd�dd�Z dd� Z � Z S )�TryStarz0Class representing an :class:`ast.TryStar` node.rB Nr� r� r� r� rD c s2 g | _ g | _g | _g | _t� j|||||d� dS )a� :param lineno: The line that this node appears on in the source code. :param col_offset: The column that this node appears on in the source code. :param parent: The parent node in the syntax tree. :param end_lineno: The last line this node appears on in the source code. :param end_col_offset: The end column this node appears on in the source code. Note: This is after the last symbol. r� NrG rH r� r< r= r� @ s �zTryStar.__init__r� zlist[ExceptHandler] | NonerI c C s, |r || _ |r|| _|r || _|r(|| _dS )a" Do some setup after initialisation. :param body: The contents of the block to catch exceptions from. :param handlers: The exception handlers. :param orelse: The contents of the ``else`` block. :param finalbody: The contents of the ``finally`` block. NrB rJ r< r< r= r� f s zTryStar.postinitc C s |S r6 r< r� r< r< r= r� } s zTryStar._infer_namerd r r c C s� || j kr||fS | jrP| jd j | kr<| jd jkrPn n|| jd jfS | jD ]^}|jrx||jj krx||f S |jd j | kr�|jd jkrVn qV||jd jf S qV| j�r| jd j d |kr�||fS | jd j | k�r| jd jk�rn n|| jd jfS | j�rx| jd j d |k�r<||fS | jd j | k�rd| jd jk�rxn n|| jd jfS || jfS rK rL rM r< r< r= r � s( . (,,zTryStar.block_rangec c s4 | j E d H | jE d H | jE d H | jE d H d S r6 rB r� r< r< r= r� � s zTryStar.get_childrenrN r< r< r� r= rO : s" � )�rO c sp e Zd ZdZdZdddd�dddddddd �� fd d �ZejZej Z ej Z d d �dd�Z ddd�dd�Z� ZS )rC z�Class representing an :class:`ast.Tuple` node. >>> import astroid >>> node = astroid.extract_node('(1, 2, 3)') >>> node <Tuple.tuple l.1 at 0x7f23b2e41780> r Nr� r r� r� r� r c s || _ t� j|||||d� dS )a :param ctx: Whether the tuple is assigned to or loaded from. :param lineno: The line that this node appears on in the source code. :param col_offset: The column that this node appears on in the source code. :param parent: The parent node in the syntax tree. :param end_lineno: The last line this node appears on in the source code. :param end_col_offset: The end column this node appears on in the source code. Note: This is after the last symbol. r� Nr r r� r< r= r� � s �zTuple.__init__zLiteral['builtins.tuple']r4 c C s dS )r� zbuiltins.tupler< r� r< r< r= r� � s z Tuple.pytyperF rG c C s t | | j||d�S r r r r< r< r= r� � s z Tuple.getitem)NNNN)N)r� r� r� r� r� r� r r! r� Ztuple_infer_unary_opr� r" r� r� r� r� r< r< r� r= rC � s ��"$rC c s� e Zd ZU dZdZded< ded< ded< d d dd d d d �� fd d � Zdddd d�dd�Zddddd�dd�Ze j Z ded< � Z S )� TypeAliasz�Class representing a :class:`ast.TypeAlias` node. >>> import astroid >>> node = astroid.extract_node('type Point = tuple[float, float]') >>> node <TypeAlias l.1 at 0x7f23b2e4e198> �r� � type_paramsr; rD r� z(list[TypeVar | ParamSpec | TypeVarTuple]rR r( r; rd r� r� c s t � j|||||d� d S r� r� r� r� r< r= r� � s �zTypeAlias.__init__)r� rR r; r5 c C s || _ || _|| _d S r6 rQ )r� r� rR r; r< r< r= r� s zTypeAlias.postinitNrF r zIterator[TypeAlias]r� c k s | V d S r6 r< rJ r< r< r= r� s zTypeAlias._inferz]ClassVar[Callable[[TypeAlias, AssignName, InferenceContext | None, None], Generator[NodeNG]]]r� )N) r� r� r� r� r� r+ r� r� r� r rY r� r� r< r< r� r= rP � s ��rP c sr e Zd ZU dZdZded< ded< dddddd d �� fd d � Zddd d �dd�Zddddd�dd�Ze j Z � Z S )�TypeVarz�Class representing a :class:`ast.TypeVar` node. >>> import astroid >>> node = astroid.extract_node('type Point[T] = tuple[float, float]') >>> node.type_params[0] <TypeVar l.1 at 0x7f23b2e4e198> �r� r@ rD r� r� r@ rd r( r� r� c s t � j|||||d� d S r� r� r� r� r< r= r� 1 s �zTypeVar.__init__)r� r@ r5 c C s || _ || _d S r6 rT )r� r� r@ r< r< r= r� B s zTypeVar.postinitNrF r zIterator[TypeVar]r� c k s | V d S r6 r< rJ r< r< r= r� F s zTypeVar._infer)Nr& r< r< r� r= rS # s �rS c sh e Zd ZU dZdZded< ddddddd�� fd d � Zddd �d d �Zddddd�dd�Ze j Z � Z S )� TypeVarTuplez�Class representing a :class:`ast.TypeVarTuple` node. >>> import astroid >>> node = astroid.extract_node('type Alias[*Ts] = tuple[*Ts]') >>> node.type_params[0] <TypeVarTuple l.1 at 0x7f23b2e4e198> r� rD r� rd r( r� r� c s t � j|||||d� d S r� r� r� r� r< r= r� ^ s �zTypeVarTuple.__init__r% c C s || _ d S r6 r� r r< r< r= r� o s zTypeVarTuple.postinitNrF r zIterator[TypeVarTuple]r� c k s | V d S r6 r< rJ r< r< r= r� r s zTypeVarTuple._infer)Nr& r< r< r� r= rU Q s �rU �__pos__�__neg__� __invert__)�+�-�~�notc s� e Zd ZU dZdZdZded< ddddddd d �� fd d � Zdd d �dd�Zd#ddd�dd�Z dd� Z � fdd�Z d$dddd d �d d �Z e je jd%dddd d �d!d"���Z� ZS )&�UnaryOpz�Class representing an :class:`ast.UnaryOp` node. >>> import astroid >>> node = astroid.extract_node('-5') >>> node <UnaryOp l.1 at 0x7f23b2e4e198> ��operandr` r( r_ r� rd r� r� rb c s || _ t� j|||||d� d S r� rc rd r� r< r= r� � s �zUnaryOp.__init__)r_ r5 c C s || _ d S r6 r^ )r� r_ r< r< r= r� � s zUnaryOp.postinitNrF z#list[util.BadUnaryOperationMessage]r� c C sZ g }z:| j |d�D ](}|tju r$t�t|tj�r|�|� qW n tyT g Y S 0 |S )a Get a list of type errors which can occur during inference. Each TypeError is represented by a :class:`BadUnaryOperationMessage`, which holds the original exception. If any inferred result is uninferable, an empty list is returned. rG )�_infer_unaryopr rL r r7 �BadUnaryOperationMessager� rj r< r< r= rl � s zUnaryOp.type_errorsc c s | j V d S r6 r^ r� r< r< r= r� � s zUnaryOp.get_childrenc s | j dkrt| j S t� �� S )Nr\ )ra r' r� r r� r� r< r= r � s zUnaryOp.op_precedencez nodes.UnaryOpr zTGenerator[InferenceResult | util.BadUnaryOperationMessage, None, InferenceErrorInfo]r) c k s, ddl m} | j�|�D �] }z|�| j�V W q tyf } z t�|| j|�V W Y d}~qd}~0 t �y$ } �z�t | j }|du r�|� � }t |tj �s�t| �V ntjV �nXt |t|f�s�t�|| j|�V W Y d}~qz�zt�||�}W n6 t�y, t�|| j|�V Y W W Y d}~qY n0 |d }t|j|d�d�} t | tj ��s`| �� �snW W Y d}~qt|�}||_tg | d�|_| j| |d�} t| d�} | du �r�|V n| V W nR t�y� } z t�|| j| �V W Y d} ~ n$d} ~ 0 t�y tjV Y n0 W Y d}~qd}~0 0 qdS )�3Infer what an UnaryOp should return when evaluated.r r5 NrG )r� r� ) r9 r6 r_ rO r� ra r~ r ra r? �UNARY_OP_METHODr� r7 rP r� rL r r$ r� r rN �callabler r; r r� r� r ) r� rH r� r6 r_ r� �methr� �methodsrS Z call_resultsr Z inner_excr< r< r= r` � sR & �� &zUnaryOp._infer_unaryopr4 c k s$ | � | j|tj�E dH t| |d�S )rb NrI )rz r` r ra r* rJ r< r< r= r� s � zUnaryOp._infer)N)N)N)r� r� r� r� r� r� r+ r� r� rl r� r r` r r� r� r� r� r< r< r� r= r] � s � �@ �r] c s� e Zd ZU dZdZdZded< ded< ded< dddd d �d d �Zed d� �Z ddd�dd�Z dd� Z � fdd�Z � fdd�Z � ZS )�Whilez�Class representing an :class:`ast.While` node. >>> import astroid >>> node = astroid.extract_node(''' while condition(): print("True") ''') >>> node <While l.2 at 0x7f23b2e4e390> r r� r( rX rP rZ r[ r� r c C s || _ || _|| _d S r6 r r r< r< r= r� . s zWhile.postinitc C s | j jS r� r r� r< r< r= r� 8 s zWhile.blockstart_tolinenord r r c C s | � || j�S )r )r r[ r� r< r< r= r @ s zWhile.block_rangec c s$ | j V | jE d H | jE d H d S r6 r r� r< r< r= r� J s zWhile.get_childrenc # s$ | j �� E dH t� �� E dH dS �z1A While node can contain a Yield node in the testNr r� r� r< r= rV P s z%While._get_yield_nodes_skip_functionsc # s$ | j �� E dH t� �� E dH dS rh r r� r� r< r= rW U s z#While._get_yield_nodes_skip_lambdas)r� r� r� r� r� r� r+ r� r r� r r� rV rW r� r< r< r� r= rg s rg c sv e Zd ZdZdZdZdZdddd�dddddd d �� fd d �Zdd ddd d�dd�Ze j Z e dd� �Z dd� Z� ZS )�Withz�Class representing an :class:`ast.With` node. >>> import astroid >>> node = astroid.extract_node(''' with open(file_path) as file_: print(file_.read()) ''') >>> node <With l.2 at 0x7f23b2e4e710> �r� rZ rT r� Nr� r� r� r� r� c s, g | _ g | _d| _t� j|||||d� dS �rF Nr� )r� rZ rR r� r� r� r� r< r= r� o s �z With.__init__z)list[tuple[NodeNG, NodeNG | None]] | Noner� )r� rZ rR r5 c C s& |dur|| _ |dur || _|| _dS )z�Do some setup after initialisation. :param items: The pairs of context managers and the names they are assigned to. :param body: The contents of the ``with`` block. N)r� rZ rR )r� r� rZ rR r< r< r= r� � s z With.postinitc C s | j d d jS )r� r r )r� r� r� r< r< r= r� � s zWith.blockstart_tolinenoc c s0 | j D ]\}}|V |r|V q| jE dH dS )zoGet the child nodes below this node. :returns: The children. :rtype: iterable(NodeNG) Nrj )r� r: �varr< r< r= r� � s zWith.get_children)NNN)NNN)r� r� r� r� r� rX r� r� r� r Zwith_assigned_stmtsr� r r� r� r� r< r< r� r= ri [ s& �� ) � ri c @ s e Zd ZdZdS )� AsyncWithz7Asynchronous ``with`` built with the ``async`` keyword.Nr� r< r< r< r= rm � s rm c @ sF e Zd ZU dZdZded< ddd�dd�Zd d � Zd d � Zd d� Z dS )�Yieldz�Class representing an :class:`ast.Yield` node. >>> import astroid >>> node = astroid.extract_node('yield True') >>> node <Yield l.1 at 0x7f23b2e4e5f8> r: r� r; r� r� c C s || _ d S r6 r: r� r< r< r= r� � s zYield.postinitc c s | j d ur| j V d S r6 r: r� r< r< r= r� � s zYield.get_childrenc c s | V d S r6 r< r� r< r< r= rV � s z%Yield._get_yield_nodes_skip_functionsc c s | V d S r6 r< r� r< r< r= rW � s z#Yield._get_yield_nodes_skip_lambdasNr� r< r< r< r= rn � s rn c @ s e Zd ZdZdS )� YieldFromz2Class representing an :class:`ast.YieldFrom` node.Nr� r< r< r< r= ro � s ro c @ s e Zd ZdZdS )r� z>Represents the unpacking of dicts into dicts using :pep:`448`.Nr� r< r< r< r= r� � s r� c sx e Zd ZdZdZdZdddd�ddddddd �� fd d �Zdd �d dddd�dd�Zdd� Zd dddd�dd�Z � Z S ) �FormattedValueaP Class representing an :class:`ast.FormattedValue` node. Represents a :pep:`498` format string. >>> import astroid >>> node = astroid.extract_node('f"Format {type_}"') >>> node <JoinedStr l.1 at 0x7f23b2e4ed30> >>> node.values [<Const.str l.1 at 0x7f23b2e4eda0>, <FormattedValue l.1 at 0x7f23b2e4edd8>] �r; � format_spec)� conversionNr� r� r� r� r� c s( | | d| _ t� j|||||d� dS rk )rr r� r� r� r� r< r= r� � s �zFormattedValue.__init__)rr r( rd zJoinedStr | None)r; rs rr r5 c C s || _ || _|| _dS )a2 Do some setup after initialisation. :param value: The value to be formatted into the string. :param conversion: The type of formatting to be applied to the value. :param format_spec: The formatting to be applied to the value. :type format_spec: JoinedStr or None N)r; rs rr )r� r; rs rr r< r< r= r� * s zFormattedValue.postinitc c s | j V | jd ur| jV d S r6 rq r� r< r< r= r� > s zFormattedValue.get_childrenrF r r� r� c k s� | j d u rtd�n| j }d}|j|fi |��D ]�}t|t�sN|s.tjV d}q.| jj|fi |��D ]n}|}t|t�rz|j}z0t||j�}t|| j| j | j | j d�V W qbW qb t t fy� tjV d}Y qb0 qbqbq.d S )Nr- FT)r� r� r� r� )rr rc rO r7 r rL r; �formatr� r� r� r� r| r~ ) r� rH r� Z format_specs� uninferable_already_generatedrr r; Zvalue_to_format� formattedr< r< r= r� D s4 � zFormattedValue._infer)NNN)N) r� r� r� r� r� r� r� r� r� r� r� r< r< r� r= rp � s �� 4� �rp z{MISSING_VALUE}c s� e Zd ZdZdZdddd�ddddddd�� fd d �Zd d dd �d d�Zdd� Zd dddd�dd�Ze d ddddd�dd��Z � Z S ) � JoinedStrz�Represents a list of string expressions to be joined. >>> import astroid >>> node = astroid.extract_node('f"Format {type_}"') >>> node <JoinedStr l.1 at 0x7f23b2e4ed30> r� Nr� r� r� r� r� c s g | _ t� j|||||d� dS rE )r� r� r� r� r� r< r= r� r s �zJoinedStr.__init__r� r� c C s |dur|| _ dS )z�Do some setup after initialisation. :param value: The string expressions to be joined. :type: list(FormattedValue or Const) Nr� r� r< r< r= r� � s zJoinedStr.postinitc c s | j E d H d S r6 r� r� r< r< r= r� � s zJoinedStr.get_childrenrF r r� r� c k s | � | j|�E d H d S r6 )�_infer_from_valuesr� rJ r< r< r= r� � s zJoinedStr._inferrP )r1 rH r� r5 c k s� |sd V d S t |�dkr:|d j|fi |��E d H d S d}|d j|fi |��D ]~}| j|dd � |fi |��D ]\}d}||fD ]&}t|t�r�|t|j�7 }q�|t7 }q�t|v r�|s�d}tj V qtt|�V qtqTd S )NrW r Fr- T) r r� rx r7 rc r� r; � MISSING_VALUEr rL ) r� r1 rH r� ru �prefix�suffixr rJ r< r< r= rx � s( z JoinedStr._infer_from_values)NNN)N)N)N) r� r� r� r� r� r� r� r� r� r� rx r� r< r< r� r= rw g s �� $ � �rw c s� e Zd ZdZdZdZd ddd�ddddddd �� fd d �Zd d dd �dd�Zej Z dd�ddd�dd�Z dd�dd�Z dd dd�d d �Z � ZS ) r� z�Represents the assignment from the assignment expression >>> import astroid >>> module = astroid.parse('if a := 1: pass') >>> module.body[0].test <NamedExpr l.1 at 0x7f23b2e4ed30> r_ TNr� r� r� r� r� c s" | | t � j|||||d� dS rE r� r� r� r< r= r� � s �zNamedExpr.__init__r( re c C s || _ || _d S r6 r_ rf r< r< r= r� � s zNamedExpr.postinit)�futurezLiteral[None, True]z@nodes.FunctionDef | nodes.Module | nodes.ClassDef | nodes.Lambda)r| r5 c C s~ |durt jdtdd� | js(t| d��t| jtttf�rt| jjsNt| jd��| jjjsft| jjd��| jjj� � S | j� � S )z�The first parent frame node. A frame node is a :class:`Module`, :class:`FunctionDef`, or :class:`ClassDef`. :returns: The first parent frame node. Nz.The future arg will be removed in astroid 4.0.r r! r� ) r$ r% r& rv r" r7 r� r r� r� )r� r| r< r< r= r� s � zNamedExpr.framer2 r4 c C sf | j st| d��t| j tttf�r\| j j s6t| j d��| j j j sNt| j j d��| j j j �� S | j �� S r� )rv r" r7 r� r r� r� r� r< r< r= r� s zNamedExpr.scoper� )r� rQ r5 c C s | � � �||� dS )a{ Define that the given name is declared in the given statement node. NamedExpr's in Arguments, Keyword or Comprehension are evaluated in their parent's parent scope. So we add to their frame's locals. .. seealso:: :meth:`scope` :param name: The name that is being defined. :param stmt: The statement that defines the given name. N)r� � set_local)r� r� rQ r< r< r= r} 3 s zNamedExpr.set_local)NNN)r� r� r� r� r� r� r� r� r Znamed_expr_assigned_stmtsr� r� r� r} r� r< r< r� r= r� � s �� '� r� c s\ e Zd ZdZd Zdddd�ddddddd�� fdd�Zdd �d d �Zdd d �dd�Z� ZS )�Unknownz�This node represents a node in a constructed AST where introspection is not possible. At the moment, it's only used in the args attribute of FunctionDef nodes where function signature introspection failed. Nr� r� r� c s t � j|||||d� d S r� r� r� r� r< r= r� J s �zUnknown.__init__zLiteral['Unknown']r4 c C s dS )Nr~ r< r� r< r< r= r� [ s z Unknown.qnamerF rG c k s t jV dS )z4Inference on an Unknown node immediately terminates.N)r rL rJ r< r< r= r� ^ s zUnknown._infer)NNN)N) r� r� r� r� r� r� r� r� r� r< r< r� r= r~ A s �� r~ c sJ e Zd ZdZd ZdZdZdddd�� fdd � Zdd d d d�dd�Z� Z S )�EvaluatedObjectz�Contains an object that has already been inferred This class is useful to pre-evaluate a particular node, with the resulting class acting as the non-evaluated node. )�originalr: r, r+ r� )r� r; r5 c s: || _ || _t� j| j j| j j| j j| j j| j jd� d S )Nr� ) r� r; r� r� r� r� rv r� r� )r� r� r; r� r< r= r� n s �zEvaluatedObject.__init__NrF r z(Generator[NodeNG | util.UninferableBase]r� c k s | j V d S r6 r: rJ r< r< r= r� s zEvaluatedObject._infer)N) r� r� r� r� r� r� r� r� r� r� r< r< r� r= r c s �r c sT e Zd ZdZdZdZdddd�ddddddd �� fd d �Zd d dd�dd�Z� ZS )�Matchz�Class representing a :class:`ast.Match` node. >>> import astroid >>> node = astroid.extract_node(''' match x: case 200: ... case _: ... ''') >>> node <Match l.2 at 0x10c24e170> ��subject�cases)r� Nr� r� r� r� r� c s" | | t � j|||||d� d S r� r� r� r� r< r= r� � s �zMatch.__init__r( zlist[MatchCase])r� r� r5 c C s || _ || _d S r6 r� )r� r� r� r< r< r= r� � s zMatch.postinit)NNN) r� r� r� r� r� r� r� r� r� r< r< r� r= r� � s �� r� c @ s e Zd ZdZdS )�Patternz!Base class for all Pattern nodes.Nr� r< r< r< r= r� � s r� c sl e Zd ZU dZdZdZded< ded< ded< ded< d d �d dd �� fd d�Zdd ddd�dd�Z� Z S )� MatchCasez�Class representing a :class:`ast.match_case` node. >>> import astroid >>> node = astroid.extract_node(''' match x: case 200: ... ''') >>> node.cases[0] <MatchCase l.3 at 0x10c24e590> ��pattern�guardrZ r� r� r� r� r� r� Nr� r� )rv r5 c s& | | | t � j|d d d d d� d S )Nr� r� )r� rv r� r< r= r� � s �zMatchCase.__init__r� rP )r� r� rZ r5 c C s || _ || _|| _d S r6 r� )r� r� r� rZ r< r< r= r� � s zMatchCase.postinit) r� r� r� r� r� r� r+ r� r� r� r< r< r� r= r� � s r� c sN e Zd ZdZdZdddd�ddddddd�� fd d �Zd dd �d d�Z� ZS )� MatchValuez�Class representing a :class:`ast.MatchValue` node. >>> import astroid >>> node = astroid.extract_node(''' match x: case 200: ... ''') >>> node.cases[0].pattern <MatchValue l.3 at 0x10c24e200> r: Nr� r� r� r� r� c s | t � j|||||d� d S r� r� r� r� r< r= r� � s �zMatchValue.__init__r( r� c C s || _ d S r6 r: r� r< r< r= r� s zMatchValue.postinit)NNN�r� r� r� r� r� r� r� r� r< r< r� r= r� � s �� r� c sD e Zd ZdZdZdddddd�dddddddd �� fd d �Z� ZS ) �MatchSingletona� Class representing a :class:`ast.MatchSingleton` node. >>> import astroid >>> node = astroid.extract_node(''' match x: case True: ... case False: ... case None: ... ''') >>> node.cases[0].pattern <MatchSingleton l.3 at 0x10c2282e0> >>> node.cases[1].pattern <MatchSingleton l.5 at 0x10c228af0> >>> node.cases[2].pattern <MatchSingleton l.7 at 0x10c229f90> r: Nr� zLiteral[True, False, None]r� r� r� )r; r� r� r� r� rv r5 c s || _ t� j|||||d� d S r� )r; r� r� )r� r; r� r� r� r� rv r� r< r= r� $ s �zMatchSingleton.__init__r� r< r< r� r= r� s �r� c sN e Zd ZdZdZdddd�ddddddd�� fd d �Zd dd �d d�Z� ZS )� MatchSequenceah Class representing a :class:`ast.MatchSequence` node. >>> import astroid >>> node = astroid.extract_node(''' match x: case [1, 2]: ... case (1, 2, *_): ... ''') >>> node.cases[0].pattern <MatchSequence l.3 at 0x10ca80d00> >>> node.cases[1].pattern <MatchSequence l.5 at 0x10ca80b20> ��patternsNr� r� r� r� r� c s | t � j|||||d� d S r� r� r� r� r< r= r� K s �zMatchSequence.__init__� list[Pattern]�r� r5 c C s || _ d S r6 r� �r� r� r< r< r= r� ] s zMatchSequence.postinit)NNNr� r< r< r� r= r� 8 s �� r� c sX e Zd ZdZdZdddd�ddddddd�� fd d �Zd d d dd�dd�ZejZ � Z S )� MatchMappinga Class representing a :class:`ast.MatchMapping` node. >>> import astroid >>> node = astroid.extract_node(''' match x: case {1: "Hello", 2: "World", 3: _, **rest}: ... ''') >>> node.cases[0].pattern <MatchMapping l.3 at 0x10c8a8850> ��keysr� �restNr� r� r� r� r� c s& | | | t � j|||||d� d S r� r� r� r� r< r= r� p s �zMatchMapping.__init__rP r� r� )r� r� r� r5 c C s || _ || _|| _d S r6 r� )r� r� r� r� r< r< r= r� � s zMatchMapping.postinit)NNN) r� r� r� r� r� r� r� r Z match_mapping_assigned_stmtsr� r� r< r< r� r= r� a s �� r� c sX e Zd ZdZdZdZdddd�ddddddd �� fd d �Zd d dd dd�dd�Z� ZS )� MatchClassar Class representing a :class:`ast.MatchClass` node. >>> import astroid >>> node = astroid.extract_node(''' match x: case Point2D(0, 0): ... case Point3D(x=0, y=0, z=0): ... ''') >>> node.cases[0].pattern <MatchClass l.3 at 0x10ca83940> >>> node.cases[1].pattern <MatchClass l.5 at 0x10ca80880> )r� r� � kwd_patterns)� kwd_attrsNr� r� r� r� r� c s* | | | | t � j|||||d� d S r� r� r� r� r< r= r� � s �zMatchClass.__init__r( r� r )r� r� r� r� r5 c C s || _ || _|| _|| _d S r6 )r� r� r� r� )r� r� r� r� r� r< r< r= r� � s zMatchClass.postinit)NNN) r� r� r� r� r� r� r� r� r� r< r< r� r= r� � s �� r� c sT e Zd ZdZdZdddd�ddddddd�� fd d �Zd dd �d d�ZejZ � Z S )� MatchStarz�Class representing a :class:`ast.MatchStar` node. >>> import astroid >>> node = astroid.extract_node(''' match x: case [1, *_]: ... ''') >>> node.cases[0].pattern.patterns[1] <MatchStar l.3 at 0x10ca809a0> r� Nr� r� r� r� r� c s | t � j|||||d� d S r� r� r� r� r< r= r� � s �zMatchStar.__init__r� r% c C s || _ d S r6 r� r r< r< r= r� � s zMatchStar.postinit)NNN) r� r� r� r� r� r� r� r Zmatch_star_assigned_stmtsr� r� r< r< r� r= r� � s �� r� c sV e Zd ZdZdZdddd�ddddddd�� fd d �Zd d dd �dd�ZejZ � Z S )�MatchAsa= Class representing a :class:`ast.MatchAs` node. >>> import astroid >>> node = astroid.extract_node(''' match x: case [1, a]: ... case {'key': b}: ... case Point2D(0, 0) as c: ... case d: ... ''') >>> node.cases[0].pattern.patterns[1] <MatchAs l.3 at 0x10d0b2da0> >>> node.cases[1].pattern.patterns[0] <MatchAs l.5 at 0x10d0b2920> >>> node.cases[2].pattern <MatchAs l.7 at 0x10d0b06a0> >>> node.cases[3].pattern <MatchAs l.9 at 0x10d09b880> �r� r� Nr� r� r� r� r� c s" | | t � j|||||d� d S r� r� r� r� r< r= r� s �zMatchAs.__init__zPattern | Noner� )r� r� r5 c C s || _ || _d S r6 r� )r� r� r� r< r< r= r� $ s zMatchAs.postinit)NNN) r� r� r� r� r� r� r� r Zmatch_as_assigned_stmtsr� r� r< r< r� r= r� � s �� r� c sN e Zd ZdZdZdddd�ddddddd�� fd d �Zd dd �d d�Z� ZS )�MatchOrz�Class representing a :class:`ast.MatchOr` node. >>> import astroid >>> node = astroid.extract_node(''' match x: case 400 | 401 | 402: ... ''') >>> node.cases[0].pattern <MatchOr l.3 at 0x10d0b0b50> r� Nr� r� r� r� r� c s | t � j|||||d� d S r� r� r� r� r< r= r� B s �zMatchOr.__init__r� r� c C s || _ d S r6 r� r� r< r< r= r� T s zMatchOr.postinit)NNNr� r< r< r� r= r� 3 s �� r� .zdict[type, type[NodeNG]]r9 r� zList | Set | TuplerP )r; rJ r5 c C s* g }| D ] }t |�}||_|�|� q|S )zACreate a list of nodes to function as the elements of a new node.)r� rv r� )r; rJ �elements�elementZ element_noder< r< r= �_create_basic_elementsm s r� zMapping[Any, Any]zAlist[tuple[SuccessfulInferenceResult, SuccessfulInferenceResult]])r� rJ r5 c C sD g }| � � D ]2\}}t|�}||_t|�}||_|�||f� q |S )zHCreate a list of node pairs to function as the items of a new dict node.)r� r� rv r� )r� rJ r� r� r; Zkey_nodeZ value_noder< r< r= �_create_dict_itemsz s r� r) r� c C s� t | �}t|t�rJ �|tvr.t� }| |_|S t| }t|tttf�rl|dddddd�}|� t | |�� |S t|t �r�|dddddd�}|� t | |�� |S t | �S )z*Return an astroid node for a python value.Nr� )re � issubclassr( r9 r� r� rB r0 rC r� r� r� r� rc )r; Z value_typerJ Zinitializer_clsr r< r< r= r� � s8 � �r� )N)N)N)N)N)NNN)N)�r� � __future__r r� r� r� r� r8 �typingr$ �collections.abcr r r r r � functoolsr r r r r r r r= r r r Z astroid.basesr r Z astroid.constr r Zastroid.contextr r r Zastroid.exceptionsr r r r r r r r r! r" r# Zastroid.interpreterr$ Zastroid.managerr% r9 r& Zastroid.nodes.constr' Zastroid.nodes.node_ngr( Zastroid.typingr) r* r+ r, � version_infor/ �typing_extensionsr1 r2 r> rS r? ZBadOperationMessagerA ZAssignedStmtsPossibleNoder� rd ZAssignedStmtsCallZInferBinaryOperationZInferLHSr� Z InferUnaryOpr� rM rb r� rg ri rw r� ZParentAssignNode�ABCMetar� ZNoChildrenNodeZ LookupMixInrD r� r� r� ZAssignTypeNoder� r r rA rE Z StatementrK rO rZ Z OperatorNoder� r{ r� r� r� �eq�ne�lt�le�gt�ger� r+ r� r� r� rc r� r� r� r� r� r� r� ZMultiLineBlockNoder� ZMultiLineWithElseBlockNoder� r� r� Z ImportNoder� r r r\ r r r rB r# r$ r' r( r- r0 rz r� r: r] rO rC rP rU rc r] rg ri rm rn ro r� rp ry rw r� r~ r r� r� r� r� r� r� r� r� r� r� r� r8 r� r1 re �NotImplementedr3 �float�complexr� r9 r� r� r� r< r< r< r= �<module> s� 4 ��� �� ��K!{ �\ �'L � 4 �$ �'H 73 � sz Z� � P +-( =") �N �I j+BDEI-G8, , `0vveG=.-� E �h y\~"%/-%+)47*=*�
| ver. 1.1 | |
.
| PHP 8.3.30 | Ð“ÐµÐ½ÐµÑ€Ð°Ñ†Ð¸Ñ Ñтраницы: 0 |
proxy
|
phpinfo
|
ÐаÑтройка