Файловый менеджер - Редактировать - /opt/imh-python/lib/python3.9/site-packages/pylint/checkers/refactoring/__pycache__/refactoring_checker.cpython-39.pyc
Ðазад
a n�h�� � @ s� d dl mZ d dlZd dlZd dlZd dlZd dlmZ d dlm Z m Z d dl m Z d dl mZmZmZmZmZ d dlZd dlmZmZ d dlmZ d d lmZ d d lmZ d d l m Z d d l m Z d d l m!Z!m"Z"m#Z# er�d dl$m%Z% eej&ej'ej(ej)f Z*ddhZ+e,d�Z-e,d�Z.e,d�Z/dddd�dd�Z0dddd�d d �Z1d d dd �d!d"�Z2d#dd$�d%d&�Z3d#dd$�d'd(�Z4d#dd$�d)d*�Z5d#dd$�d+d,�Z6ddd$�d-d.�Z7G d/d0� d0e�Z8G d1d2� d2ej9�Z:dS )3� )� annotationsN)�Iterator)�cached_property�reduce)�Pattern)� TYPE_CHECKING�Any� NamedTuple�Union�cast)�bases�nodes)�UninferableBase)�checkers)�utils)�_loop_exits_early)�node_frame_class)�HIGH� INFERENCE� Confidence)�PyLinterzitertools.countzitertools.cycle)�quit�exit)zthreading.lock.acquirezthreading._RLock.acquirezthreading.Semaphore.acquirez*multiprocessing.managers.BaseManager.startz*multiprocessing.managers.SyncManager.start)z_io.openzpathlib.Path.openzpathlib._local.Path.openz codecs.openzurllib.request.urlopenztempfile.NamedTemporaryFilez tempfile.SpooledTemporaryFileztempfile.TemporaryDirectoryztempfile.TemporaryFilezzipfile.ZipFilezzipfile.PyZipFilezzipfile.ZipFile.openzzipfile.PyZipFile.openztarfile.TarFileztarfile.TarFile.openz(multiprocessing.context.BaseContext.Poolzsubprocess.Popen�nodes.If� nodes.NodeNG�bool)�if_node�returning_node_class�returnc s t � fdd�| jD ��S )Nc 3 s | ]}t |� �V qd S �N�� isinstance��.0�node�r � ��/root/rpmbuild/BUILDROOT/imh-python39-modules-3.9.7-92.el8.x86_64/opt/imh-python/lib/python3.9/site-packages/pylint/checkers/refactoring/refactoring_checker.py� <genexpr>E � z4_if_statement_is_always_returning.<locals>.<genexpr>��any�body)r r r& r% r' �!_if_statement_is_always_returningB s r- � nodes.Try)r$ r r c s t � fdd�| jD ��S )z'Detect if all except statements return.c 3 s& | ] }t � fd d�|jD ��V qdS )c 3 s | ]}t |� �V qd S r r �r# �childr% r& r' r( M r) zB_except_statement_is_always_returning.<locals>.<genexpr>.<genexpr>Nr* )r# �handlerr% r& r' r( L s �z8_except_statement_is_always_returning.<locals>.<genexpr>)�all�handlers)r$ r r& r% r' �%_except_statement_is_always_returningH s �r4 �list[tokenize.TokenInfo]�int)�tokens�indexr c s� �� }|j tjkrdS t���d d�}d}|D ]4}|jd |jd kr2d}|jtjtjfvr2 dS q2|spdS dd���fdd � }|� }d d h� t � fd d ��|�� D ��S )a Check if the given token is a trailing comma. :param tokens: Sequence of modules tokens :type tokens: list[tokenize.TokenInfo] :param int index: Index of token under check in tokens :returns: True if the token is a comma which trails an expression :rtype: bool F� Nr Tr6 �r c s: t t�d� � ��D ] \} }|jtjkr� | S qdS )z5Get the index denoting the start of the current line.Nr )� enumerate�reversed�type�tokenize�NEWLINE)Zsubindex�token)r8 r7 r& r' �get_curline_index_startm s z3_is_trailing_comma.<locals>.get_curline_index_startr �yieldc 3 s" | ]}d |j v p|j � v V qdS )�=N)�string)r# Z prevtoken)�expected_tokensr& r' r( w s �z%_is_trailing_comma.<locals>.<genexpr>) � exact_typer> �COMMA� itertools�islice�startr= r? �COMMENTr+ )r7 r8 r@ Z left_tokensZmore_tokens_on_lineZremaining_tokenrA Z curline_startr& )rE r8 r7 r' �_is_trailing_commaR s$ �rL � nodes.Call�r$ r c C s8 | � � }t|tjtjtjf�s"dS |jdkp6t� |d�S )NF� __enter__zcontextlib.contextmanager) �framer! r � FunctionDef�astroid� BoundMethodZ UnboundMethod�namer Zdecorated_with)r$ rP r& r& r' �_is_inside_context_manager} s ��rU c C s8 | � � }| �� D ]"}||u r q4t|tj�r dS qdS )NTF)rP Znode_ancestorsr! r �Return)r$ rP �parentr& r& r' �_is_a_return_statement� s rX c C sf | � � }| }||krbt|tj�rZ|jd d j}|jd d j}|| j koT|kS S |j}q dS )z�Checks if one of the node's parents is a ``nodes.With`` node and that the node itself is located somewhere under its ``items``. r ���F)rP r! r �With�items�linenoZtolinenorW )r$ rP �currentZ items_startZ items_endr& r& r' �_is_part_of_with_items� s r^ c C s< t d�}t| jtj�sdS t�| jj�}|s0dS |�� |v S )z�Checks if a call that could be used in a ``with`` statement is used in an alternative construct which would ensure that its __exit__ method is called. )z'contextlib._BaseExitStack.enter_contextz"contextlib.ExitStack.enter_contextF) � frozensetr! rW r �Callr � safe_infer�func�qname)r$ Z callables_taking_care_of_exitrb r& r& r' � _will_be_released_automatically� s �rd c C sV t | jtj�r| | jjv S t | jtj�r4| | jjkS t | jtjtjf�rRt | j�S dS )z�Check whether use of a variable is happening as part of the left-hand side of an assignment. This requires recursive checking, because destructuring assignment can have arbitrarily nested tuples and lists to unpack. F) r! rW r �Assign�targets� AugAssign�target�Tuple�List� _is_part_of_assignment_target�r$ r& r& r' rk � s rk c @ sb e Zd ZU dZi Zded< i Zded< i Zded< dd�dd �Zd dd �d d �Z dd�dd�Z dS )�ConsiderUsingWithStackzzStack for objects that may potentially trigger a R1732 message if they are not used in a ``with`` block later on. �dict[str, nodes.NodeNG]� module_scope� class_scope�function_scopez!Iterator[dict[str, nodes.NodeNG]]r: c c s | j | j| jfE d H d S r )rq rp ro ��selfr& r& r' �__iter__� s z ConsiderUsingWithStack.__iter__z1nodes.FunctionDef | nodes.ClassDef | nodes.Module)rP r c C s* t |tj�r| jS t |tj�r$| jS | jS )z<Get the stack corresponding to the scope of the given frame.)r! r rQ rq �ClassDefrp ro )rs rP r& r& r' �get_stack_for_frame� s z*ConsiderUsingWithStack.get_stack_for_frame�Nonec C s | D ] }|� � qdS )z'Convenience method to clear all stacks.N)�clear)rs �stackr& r& r' � clear_all� s z ConsiderUsingWithStack.clear_allN) �__name__� __module__� __qualname__�__doc__ro �__annotations__rp rq rt rv rz r& r& r& r' rm � s rm c & s8 e Zd ZdZdZddddddd d d d gifd ddd dgifdddddddddddd d d d d d!d"d#d$d%d&d'd(d)d*d+d,d-d.d/�%Zd0d1d2d3d4d5�fd6d7d8d9d:d5�fd;d<d=d>d?d5�ffZd@dAdB�� fdCdD� ZdAdE�dFdG�ZdAdE�dHdI�Z e dJdE�dKdL��Z e dMdNdO�dPdQ��Z dRdNdO�dSdT�ZdUdAdO�dVdW�ZdXdAdY�dZd[�Ze�d\�d]dAd^�d_d`��Ze�d da�dbdAdO�dcdd��ZeZdedAdf�dgdh�Ze�did djdk�dldAdO�dmdn��Ze�di�dodAdO�dpdq��Ze�did\�drdAdO�dsdt��ZdRdudvdAdw�dxdy�ZdUdAdO�dzd{�ZdUdAdO�d|d}�Z dUdAdO�d~d�Z dUdAdO�d�d��Z e d�d�dNd��d�d���Z dUdNdO�d�d��Z dUdAdO�d�d��Z!e�d ddad�d�d�d�d�d�� dUdAdO�d�d���Z"dUdAdO�d�d��Z#e�d��d�dAdO�d�d���Z$d�dAdO�d�d��Z%e�d d�d�d\�d�dAdO�d�d���Z&e�d\�d�dAd^�d�d���Z'e�d��d�dAdO�d�d���Z(d�dAdO�d�d��Z)e d�dNd��d�d���Z*d�dAdO�d�d��Z+d�dAdO�d�d��Z,e�d�d�d�d�d�d�d\d�d�d�� d�dAdO�d�d���Z-e�d��d�dAdO�d�d���Z.e d�dNd��d�d�Z/d�dAdO�d�dĄZ0d�dAdO�d�dƄZ1d�dAdO�d�dȄZ2d�dAdO�d�d˄Z3d�dAd͜d�dτZ4d�dAdќd�dӄZ5e d�d�dO�d�dׄ�Z6d�dAdO�d�dلZ7d�dAdO�d�dۄZ8d�dAdO�d�d݄Z9e dud�d�dߜd�d��Z:d�d�d�d�d�Z;d�dAdO�d�d�Z<e�d�d�d�d�d�d�dAdO�d�d��Z=e d�dNdO�d�d��Z>dMdAdO�d�d�Z?e�d�d�d�d\�d�dAdO�d�d���Z@e�d�d�d��dMdAdO�d�d���ZAd�dAdO�d�d��ZBd�dAdO�d�d��ZCd�dAdO�d��d �ZDd�dAdO��d�d�ZEe d�dudO��d�d��ZFdv�ddO��d�d�ZG�ddA�d ��d �d �ZHe��d ��ddAdO��d �d��ZIe��ddjdk��ddAdO��d�d��ZJ�ddAdO��d�d�ZKe d�dNdO��d�d��ZLe dԐddO��d�d��ZMd�dAdO��d�d�ZNd�dAdO��d �d �ZOdUdNdO��d �d �ZPd�dNdO��d �d!�ZQdvdNdO��d"�d#�ZRe dvdNdO��d$�d%��ZS�d&dNdO��d'�d(�ZTd�dAdO��d)�d*�ZU�d+dAdO��d,�d-�ZV�d+dAdO��d.�d/�ZW�d+�d0dO��d1�d2�ZXdv�d3dO��d4�d5�ZY� ZZS (6 �RefactoringCheckerz�Looks for code which can be refactored. This checker also mixes the astroid and the token approaches in order to create knowledge about whether an "else if" node is a true "else if" node, or an "elif" node. Z refactoring)z?Consider merging these isinstance calls to isinstance(%s, (%s))�consider-merging-isinstancezGUsed when multiple consecutive isinstance calls can be merged into one.)zConsider using ternary (%s)�consider-using-ternaryz=Used when one of known pre-python 2.5 ternary syntax is used.)z*Boolean expression may be simplified to %s�simplify-boolean-expressionz=Emitted when redundant pre-python 2.5 ternary syntax is used.)z0Boolean condition "%s" may be simplified to "%s"�simplifiable-conditionz:Emitted when a boolean condition is able to be simplified.)z3Boolean condition '%s' will always evaluate to '%s'�condition-evals-to-constantzGEmitted when a boolean condition can be simplified to a constant value.z Too many nested blocks (%s/%s)�too-many-nested-blockszvUsed when a function or a method has too many nested blocks. This makes the code less understandable and maintainable.Z old_names)ZR0101zold-too-many-nested-blocksz(The if statement can be replaced with %s�simplifiable-if-statementz<Used when an if statement can be replaced with 'bool(test)'.)ZR0102z old-simplifiable-if-statement)z*Redefining argument with the local name %r� redefined-argument-from-localz�Used when a local name is redefining an argument, which might suggest a potential error. This is taken in account only for a handful of name binding operations, such as for iteration, with statement assignment and exception handler assignment.)z#Unnecessary "%s" after "return", %s�no-else-returnz�Used in order to highlight an unnecessary block of code following an if containing a return statement. As such, it will warn when it encounters an else following a chain of ifs, all of them containing a return statement.)z Disallow trailing comma tuple�trailing-comma-tuplea In Python, a tuple is actually created by the comma symbol, not by the parentheses. Unfortunately, one can actually create a tuple by misplacing a trailing comma, which can lead to potential weird bugs in your code. You should always use parentheses explicitly for creating a tuple.)zEDo not raise StopIteration in generator, use return statement instead�stop-iteration-returnz�According to PEP479, the raise of StopIteration to end the loop of a generator may lead to hard to find bugs. This PEP specify that raise StopIteration has to be replaced by a simple return statement)z_Either all return statements in a function should return an expression, or none of them should.� inconsistent-return-statementsz�According to PEP8, if any return statement returns an expression, any return statements where no value is returned should explicitly state this as return None, and an explicit return statement should be present at the end of the function (if reachable))z+Useless return at end of function or method�useless-returnz�Emitted when a single "return" or "return None" statement is found at the end of function or method definition. This statement can safely be removed because Python will implicitly return None)z5Consider using tuple unpacking for swapping variables�consider-swap-variablesz�You do not have to use a temporary variable in order to swap variables. Using "tuple unpacking" to directly swap variables makes the intention more clear.)zLConsider using str.join(sequence) for concatenating strings from an iterable�consider-using-joinznUsing str.join(sequence) is faster, uses less memory and increases readability compared to for-loop iteration.)zqConsider merging these comparisons with 'in' by using '%s %sin (%s)'. Use a set instead if elements are hashable.�consider-using-inz�To check if a variable is equal to one of many values, combine the values into a set or tuple and check if the variable is contained "in" it instead of checking for equality against each of the values. This is faster and less verbose.)z^Consider using dict.get for getting values from a dict if a key is present or a default if not�consider-using-getz�Using the builtin dict.get for getting a value from a dictionary if a key is present or a default if not, is simpler and considered more idiomatic, although sometimes a bit slower)z0Simplify chained comparison between the operands�chained-comparisonz�This message is emitted when pylint encounters boolean operation like "a < b and b < c", suggesting instead to refactor it to "a < b < c")z)Consider using a dictionary comprehension�!consider-using-dict-comprehensiona+ Emitted when we detect the creation of a dictionary using the dict() callable and a transient list. Although there is nothing syntactically wrong with this code, it is hard to read and can be simplified to a dict comprehension. Also it is faster since you don't need to create another transient list)z"Consider using a set comprehension� consider-using-set-comprehensionz�Although there is nothing syntactically wrong with this code, it is hard to read and can be simplified to a set comprehension. Also it is faster since you don't need to create another transient list)z)The if expression can be replaced with %s�simplifiable-if-expressionznUsed when an if expression can be replaced with 'bool(test)' or simply 'test' if the boolean cast is implicit.)z"Unnecessary "%s" after "raise", %s� no-else-raisez�Used in order to highlight an unnecessary block of code following an if containing a raise statement. As such, it will warn when it encounters an else following a chain of ifs, all of them containing a raise statement.)z3Unnecessary use of a comprehension, use %s instead.�unnecessary-comprehensionzwInstead of using an identity comprehension, consider using the list, dict or set constructor. It is faster and simpler.)z!Consider using 'sys.exit' instead�consider-using-sys-exitz�Contrary to 'exit()' or 'quit()', 'sys.exit' does not rely on the site module being available (as the 'sys' module is always available).)z"Unnecessary "%s" after "break", %s� no-else-breakz�Used in order to highlight an unnecessary block of code following an if containing a break statement. As such, it will warn when it encounters an else following a chain of ifs, all of them containing a break statement.)z%Unnecessary "%s" after "continue", %s�no-else-continuez�Used in order to highlight an unnecessary block of code following an if containing a continue statement. As such, it will warn when it encounters an else following a chain of ifs, all of them containing a continue statement.)z7Consider using Python 3 style super() without arguments�super-with-argumentsz�Emitted when calling the super() builtin with the current class and instance. On Python 3 these arguments are the default and they can be omitted.)z+Consider using a generator instead '%s(%s)'�consider-using-generatorzOIf your container can be large using a generator will bring better performance.)z Use a generator instead '%s(%s)'�use-a-generatorzwComprehension inside of 'any', 'all', 'max', 'min' or 'sum' is unnecessary. A generator would be sufficient and faster.)�3Consider using '%s' instead of unnecessary if block�consider-using-min-builtinzTUsing the min builtin instead of a conditional improves readability and conciseness.)r� �consider-using-max-builtinzTUsing the max builtin instead of a conditional improves readability and conciseness.)z8Consider using 'with' for resource-allocating operations�consider-using-withz�Emitted if a resource-allocating assignment or call may be replaced by a 'with' block. By using 'with' the release of the allocated resources is ensured even in the case of an exception.)z5Unnecessary dictionary index lookup, use '%s' instead� unnecessary-dict-index-lookupz�Emitted when iterating over the dictionary items (key-item pairs) and accessing the value by index lookup. The value can be accessed directly instead.)z#Consider using [] instead of list()�use-list-literalz�Emitted when using list() to create an empty list instead of the literal []. The literal is faster as it avoids an additional function call.)z0Consider using '%s' instead of a call to 'dict'.�use-dict-literalz�Emitted when using dict() to create a dictionary instead of a literal '{ ... }'. The literal is faster as it avoids an additional function call.)z/Unnecessary list index lookup, use '%s' instead� unnecessary-list-index-lookupzEmitted when iterating over an enumeration and accessing the value by index lookup. The value can be accessed directly instead.)zEUse 'yield from' directly instead of yielding each element one by one�use-yield-fromzzYielding directly from the iterator is faster and arguably cleaner code than yielding each element one by one in the loop.)%ZR1701ZR1706ZR1709ZR1726ZR1727ZR1702ZR1703ZR1704ZR1705�R1707ZR1708ZR1710ZR1711ZR1712ZR1713ZR1714ZR1715ZR1716ZR1717ZR1718ZR1719ZR1720ZR1721ZR1722ZR1723ZR1724ZR1725ZR1728ZR1729ZR1730ZR1731ZR1732ZR1733ZR1734ZR1735ZR1736ZR1737zmax-nested-blocks� r6 z<int>z:Maximum number of nested blocks for function / method body)�defaultr= �metavar�helpznever-returning-functions)zsys.exitzargparse.parse_error�csvz<members names>z�Complete name of functions that never returns. When checking for inconsistent-return-statements if a never returning function is called then it will be considered as an explicit return statement and no message will be printed.z%suggest-join-with-non-empty-separatorTZynz<y or n>z�Let 'consider-using-join' be raised when the separator to join on would be non-empty (resulting in expected fixes of the type: ``"- " + " - ".join(items)``)r rw )�linterr c s4 t � �|� i | _t� | _| �� t� | _d| _d S �NF) �super�__init__� _return_nodesrm �_consider_using_with_stack�_init�set�_never_returning_functions�&_suggest_join_with_non_empty_separator)rs r� �� __class__r& r' r� s zRefactoringChecker.__init__r: c C s( g | _ g | _t� | _d| _| j�� d S r� )�_nested_blocks�_elifsr� �_reported_swap_nodes�_can_simplify_bool_opr� rz rr r& r& r' r� s zRefactoringChecker._initc C s t | jjj�| _| jjj| _d S r )r� r� �configZnever_returning_functionsr� Z%suggest_join_with_non_empty_separatorr� rr r& r& r' �open" s ��zRefactoringChecker.openz Pattern[str]c C s | j jjS r )r� r� Zdummy_variables_rgxrr r& r& r' � _dummy_rgx+ s z RefactoringChecker._dummy_rgxznodes.Return | nodes.Assignr rN c C s t | jtj�ot | jjt�S r )r! �valuer �Constr rl r& r& r' �_is_bool_const/ s �z!RefactoringChecker._is_bool_constznodes.If | nodes.Tryc C s> t |jtj�r:|jj}|r:||gkr:|j|jf| jv r:dS dS )a Check if the given node is an actual elif. This is a problem we're having with the builtin ast module, which splits `elif` branches into a separate if statement. Unfortunately we need to know the exact type in certain cases. TF)r! rW r �If�orelser\ � col_offsetr� )rs r$ r� r& r& r' �_is_actual_elif5 s z"RefactoringChecker._is_actual_elifr c C s" | � |�rdS t|j�dks*t|j�dkr.dS |jd }|jd }t|tj�rxt|tj�s^dS | �|�}| �|�}d}nzt|tj�r�t|tj�s�dS dd� |j D �}dd� |j D �}|r�|s�dS t |�t |�kr�dS | �|�}| �|�}d}ndS |r�|s�dS |j j �s dS | j d ||fd � dS ) au Check if the given if node can be simplified. The if statement can be reduced to a boolean expression in some cases. For instance, if there are two branches and both of them return a boolean value that depends on the result of the statement's test, then this can be reduced to `bool(test)` without losing any functionality. Nr9 r z'return bool(test)'c S s g | ]}t |tj�r|j�qS r& �r! r � AssignNamerT �r# rh r& r& r' � <listcomp>b s �z=RefactoringChecker._check_simplifiable_if.<locals>.<listcomp>c S s g | ]}t |tj�r|j�qS r& r� r� r& r& r' r� g s �z'var = bool(test)'r� �r$ �args) r� �lenr� r, r! r rV r� re rf �sortedr� � add_message) rs r$ Z first_branchZ else_branchZfirst_branch_is_boolZelse_branch_is_bool� reduced_toZfirst_branch_targetsZelse_branch_targetsr& r& r' �_check_simplifiable_ifE sD �� z)RefactoringChecker._check_simplifiable_ifr5 )r7 r c s� | j �d�}|}t|�D ]�\}}|d � |sp� �d�rpd� dd � v rpd� dd � v rpt� fdd�d D ��rpd }� d kr�| j�|d ||d d g� q|s�|rt||�r| jd|j d t d� qd S )Nr� r9 �#zpylint:�enable� c 3 s | ]}|� d d� v V qdS )� Nr& )r# �c�Z token_stringr& r' r( � s z4RefactoringChecker.process_tokens.<locals>.<genexpr>)r� r� T�elif� r )�line� confidence) r� Zis_message_enabledr; � startswithr+ r� �extendrL r� rJ r )rs r7 Z%trailing_comma_tuple_enabled_for_fileZ!trailing_comma_tuple_enabled_oncer8 r@ r& r� r' �process_tokens� s< ����� ��"��� �z!RefactoringChecker.process_tokensr� z nodes.Module)�_r c C s | � | jj� | �� d S r )�#_emit_consider_using_with_if_neededr� ro r� �rs r� r& r& r' � leave_module� s �z RefactoringChecker.leave_moduler� r. c C s" | � |� | �|� | �|� d S r )�_check_nested_blocks� _check_superfluous_else_return� _check_superfluous_else_raise�rs r$ r& r& r' � visit_try� s z RefactoringChecker.visit_tryznodes.AssignName)� name_noder c C sz | j r| j �|j�rd S |js"d S |�� }t|tj�s:d S |jj tj tj fd�D ]$}|j|jkrP| j d||jfd� qPd S )N�Z skip_klassr� r� ) r� �matchrT r\ �scoper! r rQ r� �nodes_of_classr� �Lambdar� )rs r� r� Zdefined_argumentr& r& r' �$_check_redefined_argument_from_local� s � �z7RefactoringChecker._check_redefined_argument_from_localr� r� r� z nodes.Forc C s@ | � |� | �|� | �|� |j�tj�D ]}| �|� q,d S r )r� �$_check_unnecessary_dict_index_lookup�$_check_unnecessary_list_index_lookuprh r� r r� r� )rs r$ rT r& r& r' � visit_for� s z RefactoringChecker.visit_forznodes.ExceptHandlerc C s$ |j r t|j tj�r | �|j � d S r )rT r! r r� r� r� r& r& r' �visit_excepthandler� s z&RefactoringChecker.visit_excepthandlerz nodes.Withc C sd |j D ]X\}}t|tj�r<| jD ]}|j|v r ||j= q<q |sBq|�tj�D ]}| �|� qNqd S r ) r[ r! r �Namer� rT r� r� r� )rs r$ �var�namesry rT r& r& r' � visit_with� s z RefactoringChecker.visit_with�strr )r$ �msg_idr r c C s� t |tj�r|jrd S |js d S | �|�r.d S t |tj�rDt||�s`t |tj�r�|js�t||�r�|jd }|j |j f| j v r�d}nd}| j |||t d� d S )Nr )r� z#remove the leading "el" from "elif")�elsez2remove the "else" and de-indent the code inside it�r$ r� r� )r! r �Try� finalbodyr� r� r� r- r4 r\ r� r� r� r )rs r$ r� r r� r� r& r& r' �_check_superfluous_else s* �� ��� z*RefactoringChecker._check_superfluous_elsec C s | j |dtjd�S )Nr� �r� r )r� r rV r� r& r& r' r� ' s �z1RefactoringChecker._check_superfluous_else_returnc C s | j |dtjd�S )Nr� r� )r� r �Raiser� r& r& r' r� , s �z0RefactoringChecker._check_superfluous_else_raisec C s | j |dtjd�S )Nr� r� )r� r �Breakr� r& r& r' � _check_superfluous_else_break1 s �z0RefactoringChecker._check_superfluous_else_breakc C s | j |dtjd�S )Nr� r� )r� r �Continuer� r& r& r' � _check_superfluous_else_continue6 s �z3RefactoringChecker._check_superfluous_else_continuer )�node_a�node_br c C sp t | tj�r$t |tj�r$| j|jkS t | tj�rHt |tj�rH| j|jkS t | tj�rlt |tj�rl| j|jkS dS r� )r! r r� rT r� r� r� )r r r& r& r' �_type_and_name_are_equal; s � z+RefactoringChecker._type_and_name_are_equalc C s� t |jtj�sdS t|j�dkr$dS |jd }t |tj�rtt|jd j�dkrtt |jd jd tj�rtt |j tj �sxdS |j j }| � |j j |jj d d �r�| � ||jj�s�dS t t�|jj d d �tj�S )NFr9 r )r! �testr �Comparer� r, re rf r� r� � Subscript�slicer �ops�leftr ra �Dict)rs r$ �stmt� slice_valuer& r& r' �_is_dict_get_blockG s* ��� ���z%RefactoringChecker._is_dict_get_blockc C s� | � |�}|r$|js$| jd|d� nj|r�t|j�dkr�t|jd tj�r�| �|jd jd |j d jd �r�t|jd j�dkr�| jd|d� d S )Nr� rl r9 r ) r r� r� r� r! r re r rf r, )rs r$ Z if_block_okr& r& r' �_check_consider_gete s � �� ��� z&RefactoringChecker._check_consider_getr� r� r� r� r� r� c C sT | � |� | �|� | �|� | �|� | �|� | �|� | �|� | �|� d S r )r� r� r� r� r r r �%_check_consider_using_min_max_builtinr� r& r& r' �visit_ift s zRefactoringChecker.visit_ifc C s� | � |�s|jrdS t|j�dkr&dS ddd�dd�}|jd }t|d �rXt|j�dkr\dS |jd }t|jtj �r�t|tj �s�t|jj tj �s�t|tj �s�dS t|d �s�t|d �s�dS ||�}t|jj �dkr�dS |jj d \}}||j�}||jj �} ||�} | |k�rn| |k�r$t�|�}ndS || | fv�r:dS |d v �rn|� d |� d|� d�} | jd|| fd� n2|dv �r�|� d|� d|� d�} | jd|| fd� dS )zICheck if the given if node can be refactored as a min/max python builtin.Nr9 r r� rN c S s0 t | tj�r| jS t | tj�r(t| j�S | �� S )z5Obtain simplest representation of a node as a string.)r! r r� rT r� r� r� � as_stringrl r& r& r' � get_node_name� s zORefactoringChecker._check_consider_using_min_max_builtin.<locals>.get_node_namer rf rT �attrname� �<z<=z = max(�, �)r� r� � z>=�>z = min(r� )r� r� r� r, �hasattrrf r! r r r r r re r r� r Zget_inverse_comparatorr� ) rs r$ r r, rh Ztarget_assignation�operatorZright_statementZ body_value� left_operandZright_statement_valuer� r& r& r' r � s\ � �� � �� ��z8RefactoringChecker._check_consider_using_min_max_builtinr� z nodes.IfExpc C s | � |� d S r )�_check_simplifiable_ifexpr� r& r& r' � visit_ifexp� s z RefactoringChecker.visit_ifexpc C s� t |jtj�r t |jtj�s d S t |jjt�r<t |jjt�s@d S t |jtj�rTd}nd}|jj|jjfdkrzd|� d�}n |jj|jjfdkr�d}nd S | j d||fd� d S ) Nr z bool(test))TF�')FTz 'not test'r� r� ) r! r, r r� r� r� r r r r� )rs r$ Ztest_reduced_tor� r& r& r' r � s" ��z,RefactoringChecker._check_simplifiable_ifexpr� r� znodes.FunctionDefc C sP | � | j� g | _| �|� | �|� g | j|j< | �| jj� | jj� � d S r ) �%_emit_nested_blocks_message_if_neededr� �_check_consistent_returns�_check_return_at_the_endr� rT r� r� rq rx r� r& r& r' �leave_functiondef� s �z$RefactoringChecker.leave_functiondefznodes.ClassDefc C s | � | jj� | jj�� d S r )r� r� rp rx r� r& r& r' �leave_classdef s �z!RefactoringChecker.leave_classdefr� z nodes.Raisec C s | � |� d S r )�&_check_stop_iteration_inside_generatorr� r& r& r' � visit_raise s z RefactoringChecker.visit_raisec C s~ |� � }t|tj�r |�� s dS t�|t�r0dS |js:dS t� |j�}|r\t|t j tj f�s`dS | � |�rz| jd|td� dS )zICheck if an exception of type StopIteration is raised inside a generator.Nr� �r$ r� )rP r! r rQ � is_generatorr �node_ignores_exception� StopIteration�excra r �Instanceru �+_check_exception_inherit_from_stopiterationr� r )rs r$ rP r. r& r& r' r( s z9RefactoringChecker._check_stop_iteration_inside_generatorz nodes.ClassDef | bases.Instance)r. r c s& t j� d�� t� fdd�| �� D ��S )zIReturn True if the exception node in argument inherit from StopIteration.z.StopIterationc 3 s | ]}|� � � kV qd S r )rc )r# �_class�Zstopiteration_qnamer& r' r( . r) zQRefactoringChecker._check_exception_inherit_from_stopiteration.<locals>.<genexpr>)r ZEXCEPTIONS_MODULEr+ �mro)r. r& r2 r' r0 ( s z>RefactoringChecker._check_exception_inherit_from_stopiterationrM c C s t |jtj��r|j�rt |jd tj��r|jjdkr�|jd j}t |tj�rTd S t |tj �r�t |j tj tj f�r�t |j j�dkr�t |jtj tj f�r�t |jj�dkr�|j j\}}|jj\}}|�� |�� kr�|�� |�� kr�d S d}| j||d� n |jjdk�rd}| j||d� d S )Nr �dictr� r� rl r� r� )r! rb r r� r� �ListComprT �eltr` �IfExpr, ri rj r� �eltsr� r r� )rs r$ �element�key1Zvalue1�key2Zvalue2Z message_namer& r& r' �/_check_consider_using_comprehension_constructor0 s@ ��� ����� ��zBRefactoringChecker._check_consider_using_comprehension_constructorc C s� g d�}t |tj�r�|jr�t |jtj�r�|jj|v r�t|j�dkr�t |jd tj�r�|jd � � dd� }|j r�d|� d�}|d7 }|d� dd � |j D ��7 }|jj}|d v r�| j d |||fd � n| j d |||fd � d S )N)r+ r2 �sum�max�min�list�tupler9 r rY �(r r c s s | ]}|� � V qd S r �r )r# �kwr& r& r' r( g r) zERefactoringChecker._check_consider_using_generator.<locals>.<genexpr>> r2 r+ r� r� r� ) r! r r` rb r� rT r� r� r5 r �keywords�joinr� )rs r$ Z checked_callZ inside_compZ call_namer& r& r' � _check_consider_using_generatorR s6 �� � � ��z2RefactoringChecker._check_consider_using_generatorr� r� r� r� r� r� r� r� c C sT | � |� | �|� | �|� | �|� | �|� | �|� | �|� | �|� d S r )�3_check_raising_stopiteration_in_generator_next_callr< �_check_quit_exit_call�_check_super_with_argumentsrG �_check_consider_using_with�_check_use_list_literal�_check_use_dict_literalr� r& r& r' � visit_callv s z RefactoringChecker.visit_callr� z nodes.Yieldc C s� t |jtj�sd S |jj}t |tj�rNt |tj�sNt|j�dksNt |jtj �sRd S |j j |jj krfd S t |� � tj �rzd S | jd|td� d S )Nr9 r� r* )r! r� r r� rW �For�AsyncForr� r, �Exprrh rT rP �AsyncFunctionDefr� r )rs r$ Z loop_noder& r& r' � visit_yield� s" � � � �z RefactoringChecker.visit_yieldznodes.LocalsDictNodeNG)r� r c C s* | j �d�}t|o&t|d tjtjf��S )Nr r )�locals�getr r! r � ImportFrom�Import)r� Z exit_funcr& r& r' �_has_exit_in_scope� s �z%RefactoringChecker._has_exit_in_scopec C sR t |jtj�rN|jjtv rN|�� }| �|�s:| �|�� �r>d S | j d|t d� d S )Nr� r* ) r! rb r r� rT �BUILTIN_EXIT_FUNCSr� rX �rootr� r )rs r$ Z local_scoper& r& r' rI � s �z(RefactoringChecker._check_quit_exit_callc C s� t |jtj�r|jjdkr d S t|j�dksrtdd� |jD ��rr|jd jdksrt|� }d u sr|jd j|jkrvd S | j d|d � d S ) Nr� r� c s s | ]}t |tj�V qd S r �r! r r� )r# �argr& r& r' r( � r) zARefactoringChecker._check_super_with_arguments.<locals>.<genexpr>r9 rs r r� rl ) r! rb r r� rT r� r� r2 r r� )rs r$ Z frame_classr& r& r' rJ � s �����z.RefactoringChecker._check_super_with_argumentsc C s� ddd�dd�}t |jtj�r"dS t|j�dkr4dS t�|j�}t |tj�r�|� � dkr�|� � }t|j�d k}t |tj�r�|� � r�|s�t� |t �s�||jd �s�| jd |td � dS ) a Check if a StopIteration exception is raised by the call to next function. If the next value has a default value, then do not add message. :param node: Check to see if this Call node is a next function :type node: :class:`nodes.Call` r r )�paramr c S s& t �| �}t|tj�r"|�� tv S dS r� )r ra r! r r/ rc �KNOWN_INFINITE_ITERATORS)r] �inferredr& r& r' � _looks_like_infinite_iterator� s zmRefactoringChecker._check_raising_stopiteration_in_generator_next_call.<locals>._looks_like_infinite_iteratorNr z builtins.nextr9 r� r* )r! rb r � Attributer� r� r ra rQ rc rP r+ r, r- r� r )rs r$ r` r_ rP Zhas_sentinel_valuer& r& r' rH � s2 � � ��� � ��zFRefactoringChecker._check_raising_stopiteration_in_generator_next_call�NodesWithNestedBlocksc C s� t |�� tj�sdS | jdd� }|j|�� kr:|g| _nZt| j�D ] }||jkrV qb| j�� qDt |tj�r�| � |�r�| jr�| j�� | j� |� t |�t | j�kr�| � |� dS )z-Update and check the number of nested blocks.N) r! r� r rQ r� rW r< �popr� r� �appendr� r# )rs r$ � nested_blocksZ ancestor_noder& r& r' r� � s z'RefactoringChecker._check_nested_blockszlist[NodesWithNestedBlocks])re r c C s8 t |�| jjjkr4| jd|d t |�| jjjfd� d S )Nr� r r� )r� r� r� Zmax_nested_blocksr� )rs re r& r& r' r# s �z8RefactoringChecker._emit_nested_blocks_message_if_neededrn )ry r c C s |� � D ]}| jd|d� qd S �Nr� rl )�valuesr� )rs ry r$ r& r& r' r� s z6RefactoringChecker._emit_consider_using_with_if_neededz nodes.BoolOpzdict[str, set[str]]c s� t � � t�t �}| jD ]�}t|tj�rt|j�dkr6qt � |j �}|rt � |�sRq|j dkr^q|jd �� }|jd }||v r�� �|� t|tj�r�dd� |�� D �}n |�� g}|| �|� q� fdd�|�� D �S ) aF Get the duplicated types from the underlying isinstance calls. :param nodes.BoolOp node: Node which should contain a bunch of isinstance calls. :returns: Dictionary of the comparison objects from the isinstance calls, to duplicate values from consecutive calls. :rtype: dict r� r! r r9 c S s g | ] }|� � �qS r& rC )r# Z class_typer& r& r' r� ? s zCRefactoringChecker._duplicated_isinstance_types.<locals>.<listcomp>c s i | ]\}}|� v r||�qS r& r& )r# �keyr� �Zduplicated_objectsr& r' � <dictcomp>G s zCRefactoringChecker._duplicated_isinstance_types.<locals>.<dictcomp>)r� � collections� defaultdictrg r! r r` r� r� r ra rb Zis_builtin_objectrT r �addri Zitered�updater[ )r$ Z all_types�callr_ Zisinstance_objectZisinstance_typesZelemsr& ri r' � _duplicated_isinstance_types! s. � �z/RefactoringChecker._duplicated_isinstance_typesc C sZ |j dkrdS | �|�}|�� D ]4\}}tdd� |D ��}| jd||d�|�fd� q dS )z4Check isinstance calls which can be merged together.�orNc s s | ] }|V qd S r r& )r# rT r& r& r' r( R r) zHRefactoringChecker._check_consider_merging_isinstance.<locals>.<genexpr>r� r r� )�oprp r[ r� r� rF )rs r$ Z first_argsZduplicated_nameZ class_namesr� r& r& r' �"_check_consider_merging_isinstanceK s �z5RefactoringChecker._check_consider_merging_isinstancec C s� ddd�}|j |vs"t|j�dk r&d S |jD ]j}t|tj�rbt|j�dksb|jd d ||j vrh d S |j|jd d fD ]}t|tj�r| d S q|q,g g }}|jD ]\}t � }|j|jd d fD ]2}t|tj tj f�r�|� |� � � |�|� � � q�|�|� q�tdd� |�}|�s d S tt|��d } ttj�|��}|�| � t|�dk�r`d �|�n |d d } |j d k�r|d nd } | jd|| | | ftd� d S )Nz==z!=)rq �andr� r9 r c S s | � |�S r )� intersection)�a�br& r& r' �<lambda>u r) z=RefactoringChecker._check_consider_using_in.<locals>.<lambda>r �,rq � znot r� r� )rr r� rg r! r r r r r` r� r� ra rm r rd r r� r@ rk � OrderedDict�fromkeys�removerF r� r ) rs r$ Z allowed_opsr� Z comparable� variablesrg Z variable_setZcommon_variablesZcommon_variableZ values_stringZ maybe_notr& r& r' �_check_consider_using_inY sH � �� $�z+RefactoringChecker._check_consider_using_inc C s� |j dkst|j�dk r dS dddd�dd �}t�d d � �}|jD ]}t|tj�rB|||� qB|�� D ]T}t|d �|d ��}t|d �}t|d �}||k rf||k rf| j d|d� q�qfdS )a Check if there is any chained comparison in the expression. Add a refactoring message if a boolOp contains comparison like a < b and b < c, which can be chained as a < b < c. Care is taken to avoid simplifying a < b < c and b < d. rt r� Nz nodes.Comparez;collections.defaultdict[str, dict[str, set[nodes.Compare]]]rw )�comparison_node�usesr c S s� | j }| jD ]�\}}||fD ]�}d }t|tj�r8|j}nt|tj�rJ|j}|d u rTq |dv r�||u rx|| d �| � q�||u r�|| d �| � q |dv r ||u r�|| d �| � q ||u r || d �| � q |}q d S )Nr � lower_bound� upper_boundr ) r r r! r r� rT r� r� rm )r� r� r r Z right_operand�operandr� r& r& r' �_find_lower_upper_bounds� s* zNRefactoringChecker._check_chained_comparison.<locals>._find_lower_upper_boundsc S s t � t � d�S )N)r� r� )r� r& r& r& r' rx � r) z>RefactoringChecker._check_chained_comparison.<locals>.<lambda>r� r� r� rl ) rr r� rg rk rl r! r r ru r� ) rs r$ r� r� r� ZboundsZ num_sharedZnum_lower_boundsZnum_upper_boundsr& r& r' �_check_chained_comparison� s" �� z,RefactoringChecker._check_chained_comparisonzlist[nodes.NodeNG])r rg r c C sz g }|D ]\}d}t |�tj�d�s8t�|�}|r8|�� }t|t�sN|� |� q| dk|kr|g S q|pxt� | dk�gS )a[ Removes irrelevant values or returns short-circuiting values. This function applies the following two rules: 1) an OR expression with True in it will always be true, and the reverse for AND 2) False values in OR expressions are only relevant if all values are false, and the reverse for AND NFrq rt ) �nextr� r r� r ra � bool_valuer! r rd r� )r rg Zsimplified_valuesZsubnodeZ inferred_boolr_ r& r& r' �#_apply_boolean_simplification_rules� s z6RefactoringChecker._apply_boolean_simplification_rules)�bool_opr c sn t |�� �}� fdd�|D �}� �|j|�}t|�t|�k rBd� _t|�dkrV|d S t�|�}|�|� |S )z�Attempts to simplify a boolean operation. Recursively applies simplification on the operator terms, and keeps track of whether reductions have been made. c s& g | ] }t |tj�r � �|�n|�qS r& )r! r �BoolOp�_simplify_boolean_operationr/ rr r& r' r� � s � � zBRefactoringChecker._simplify_boolean_operation.<locals>.<listcomp>Tr9 r )r@ � get_childrenr� rr r� r� �copyZpostinit)rs r� �childrenZ intermediate�resultZsimplified_bool_opr& rr r' r� � s � z.RefactoringChecker._simplify_boolean_operationc C sx t �|�sdS d| _| �|�}| js(dS t|�tj�d�sX| jd||� � |� � fd� n | jd||� � |� � fd� dS )z�Check if a boolean condition can be simplified. Variables will not be simplified, even if the value can be inferred, and expressions like '3 + 4' will remain expanded. NFr� r� r� ) r Zis_test_conditionr� r� r� r� r r� r� r )rs r$ Zsimplified_exprr& r& r' � _check_simplifiable_condition� s" ��z0RefactoringChecker._check_simplifiable_conditionr� r� r� r� r� c C s, | � |� | �|� | �|� | �|� d S r )rs r r� r� r� r& r& r' � visit_boolop s z RefactoringChecker.visit_boolopznodes.NodeNG | Nonec C s: t | tj�o8t| j�dko8t | jd tj�o8t | jtj�S �Nr9 r )r! r re r� rf r� r� r� rl r& r& r' �_is_simple_assignment s �� �z(RefactoringChecker._is_simple_assignmentc s� |� � r|� � � � sd S ||� � |� � � � g}t� fdd�|D ��sHd S t� fdd�|D ��rbd S dd� |D �}dd� |D �}|d |d kr�|d d � |d d� krĈ j�|� d }� j||d � d S ) Nc 3 s | ]}� � |�V qd S r )r� r" rr r& r' r( * r) z;RefactoringChecker._check_swap_variables.<locals>.<genexpr>c 3 s | ]}|� j v V qd S r )r� r" rr r& r' r( , r) c S s g | ]}|j d j�qS )r )rf rT r" r& r& r' r� . r) z<RefactoringChecker._check_swap_variables.<locals>.<listcomp>c S s g | ] }|j j�qS r& )r� rT r" r& r& r' r� / r) r rY r9 r� rl )� next_siblingr2 r+ r� rn r� )rs r$ Z assignmentsr �right�messager& rr r' �_check_swap_variables& s ( z(RefactoringChecker._check_swap_variablesr� r� r� z nodes.Assignc C s | � |� | �|� d S r )�!_append_context_managers_to_stack� visit_returnr� r& r& r' � visit_assign5 s z RefactoringChecker.visit_assignc C s� | � |� | �|j�r*| �|j�\}}}nd S tdd� ||fD ��rHd S tj|dd�}|d u sht|t�rld S |� � }|du r�d}|� � }n$d}|� � � d|� � � d |� � � �}| j |||ft d � d S ) Nc s s | ]}t |tj�V qd S r )r! r r �r# r� r& r& r' r( K s z2RefactoringChecker.visit_return.<locals>.<genexpr>T)Zcompare_constantsFr� r� z if z else r� ) r� �_is_and_or_ternaryr� �_and_or_ternary_argumentsr2 r ra r! r r� r r� r ) rs r$ ZcondZ truth_value� false_valueZinferred_truth_valueZtruth_boolean_valuer� � suggestionr& r& r' r� ? s( � � z RefactoringChecker.visit_returnc C sJ t |�r d S t|jd tjtjtjf�r^|jd j}t� |j �}|d u sRt |d�sVd S |j}n|jd g}|j g}t dd� ||fD ��r�d S t ||�D ]�\}}t|tj�s�q�t� |j�}|r�|�� tvs�t|tjtjf�s�q�| j�|�� �}t|tj�r�|jn|j}||v �r<|| } t�|| ��r.|||< q�| jd| d� |||< q�d S )Nr r8 c s s | ]}t |t�V qd S r )r! r )r# �nr& r& r' r( n r) zGRefactoringChecker._append_context_managers_to_stack.<locals>.<genexpr>r� rl ) rU r! rf r ri rj �Setr8 r ra r� r r+ �zipr` rb rc � CALLS_RETURNING_CONTEXT_MANAGERSr� Z AssignAttrr� rv rP rT r rR Z are_exclusiver� ) rs r$ Z assigneesr� rg Zassigneer_ ry �varnameZ existing_noder& r& r' r� _ sL � �� �� �z4RefactoringChecker._append_context_managers_to_stackc C s� t |�st|�rd S || j�|�� ��� v r0d S t�|j�}|rVt |t j t j t jf�sZd S |�� tv pz|�� tv ozt|� }|r�t|�s�| jd|d� d S rf )rU rX r� rv rP rg r ra rb r! r rQ ru r rS rc �$CALLS_THAT_COULD_BE_REPLACED_BY_WITHr� r^ rd r� )rs r$ r_ Zcould_be_used_in_withr& r& r' rK � s( ��� � � z-RefactoringChecker._check_consider_using_withc C sH |� � dkrDt�|j�}t|tj�rD|jsD|�� dkrD| j d|d� dS )z7Check if empty list is created by using the literal [].zlist()z builtins.listr� rl N) r r ra rb r! r ru r� rc r� �rs r$ r_ r& r& r' rL � s z*RefactoringChecker._check_use_list_literalc C sf t |jtj�r|jjdkr dS t�|j�}t |tj�rb|� � dkrb|j sb| j d| � |�f|t d� dS )z1Check if dict is created by using the literal {}.r4 Nz builtins.dictr� )r� r$ r� )r! rb rR r� rT r ra r ru rc r� r� �_dict_literal_suggestionr r� r& r& r' rM � s � �� �z*RefactoringChecker._check_use_dict_literalc C s� g }| j D ]B}td�|��dkr$ qN|| jvr |�d|j� d|j�� � �� q | jD ]0}td�|��dkrn q�|�d|j�� � �� qTd�|�}d|� t|�dkr�dnd� d �S ) z)Return a suggestion of reasonable length.r �@ �"z": z**�{z, ... rz �})rE r� rF �kwargsrd r\ r� r )r$ �elements�keywordr� r& r& r' r� � s z+RefactoringChecker._dict_literal_suggestion� str | Nonec C s� t |tj�rtd|j�S t |tj�s(dS dd� |jD �}t|�dksVt |d jtj�sZdS t|j�t|�k}|rz| j szdS td|d jj�S )z5Try to extract the name used in a concatenation loop.r� Nc S s g | ]}t |tj�r|�qS r& )r! r �FormattedValuer� r& r& r' r� � s z;RefactoringChecker._name_to_concatenate.<locals>.<listcomp>r9 r ) r! r r� r rT � JoinedStrrg r� r� r� )rs r$ rg Zwith_separatorsr& r& r' �_name_to_concatenate� s � z'RefactoringChecker._name_to_concatenateznodes.AugAssign)� aug_assignr c C s� |j }t|tj�r t|j�dkr$dS |�� }t|tj�s<dS dd� |jD �}|j dko�t|j tj �o�t|j�dko�|j j |v o�t|j tj�o�t|j j t�o�| �|j �|j j k}|r�| jd|d� dS )z�We start with the augmented assignment and work our way upwards. Names of variables for nodes if match successful: result = '' # assign for number in ['1', '2', '3'] # for_loop result += number # aug_assign r9 Nc S s h | ]}t |tj�r|j�qS r& r� r� r& r& r' � <setcomp>� s �z@RefactoringChecker._check_consider_using_join.<locals>.<setcomp>z+=r� rl )rW r! r rO r� r, Zprevious_siblingre rf rr rh r� rT r� r� r� r� r� )rs r� Zfor_loopZassignZresult_assign_namesZis_concat_loopr& r& r' �_check_consider_using_join� s0 � � � � � �� z-RefactoringChecker._check_consider_using_joinr� c C s | � |� d S r )r� r� r& r& r' �visit_augassign s z"RefactoringChecker.visit_augassignr� znodes.Comprehensionc C s" | � |� | �|� | �|� d S r )� _check_unnecessary_comprehensionr� r� r� r& r& r' �visit_comprehension s z&RefactoringChecker.visit_comprehensionc C s� t |jtj�s2t|j�dks2t|jj�dks2|jr6d S t |jtj�r�t |jj tj �r�t |jj tj �r�t |j tj �r�tdd� |j jD ��r�|jj j|jj jg}dd� |j jD �}n�t |jtjtjf��rf|jj}t |tj �r�|j}n>t |tj ��r tdd� |jD ���r d S dd� |jD �}ng }|jjd j }t |tj��rB|jn t |tj ��r`d d� |jD �ng }nd S ||k�r�|�r�d }t�|j�}t |jtj��r�t |tjj��r�d |jj j � � � d �f}nft |jtj��r�t |tj ��r�d |j� � � d �f}n2t |jtj��r*t |tj ��r*d |j� � � d �f}|�rF| j!d|j|d� d S t |jtj��r\d}n0t |jtj��rrd}nt |jtj��r�d}nd S | j!d|j|� d|j� � � d �fd� d S )Nr r9 c s s | ]}t |tj�V qd S r )r! r r� �r# r6 r& r& r' r( ' r) zFRefactoringChecker._check_unnecessary_comprehension.<locals>.<genexpr>c S s g | ] }|j �qS r& �rT r� r& r& r' r� * r) zGRefactoringChecker._check_unnecessary_comprehension.<locals>.<listcomp>c s s | ]}t |tj� V qd S r r[ r� r& r& r' r( 1 r) c S s g | ] }|j �qS r& r� r� r& r& r' r� 3 r) c S s g | ]}t |tj�r|j�qS r& r� r� r& r& r' r� ; s �zdict(r zlist(zset(r� r� r4 r@ r� rB )"r! rW r � GeneratorExpr� �ifs� generators�is_async�DictComprh r� r� rh ri r2 r8 rT r5 �SetCompr6 r+ r� r ra �iterrR �objectsZ DictItemsrb �exprr rj r� r� ) rs r$ Z expr_listZ target_listr� rh r� r_ rb r& r& r' r� s� � ��� ��� �� � � �� �����z3RefactoringChecker._check_unnecessary_comprehensionc C s� t | tj�o�| jdko�t| j�dko�t | jd tj�o�t | jd tj� o�| jd jdko�t | jd jd tj� o�t| jd j�dkS )z�Returns true if node is 'condition and true_value or false_value' form. All of: condition, true_value and false_value should not be a complex boolean expression rq r� r r9 rt )r! r r� rr r� rg rl r& r& r' r� j s � ������z%RefactoringChecker._is_and_or_ternaryz/tuple[nodes.NodeNG, nodes.NodeNG, nodes.NodeNG]c C s$ | j d }| j d j \}}|||fS r� )rg )r$ r� � conditionZ true_valuer& r& r' r� { s z,RefactoringChecker._and_or_ternary_argumentsc C s" t |jtjtjd��| j|j< d S )Nr� )r@ r� r rV rQ r� rT r� r& r& r' �visit_functiondef� s �z$RefactoringChecker.visit_functiondefc C sV dd� | j |j D �}|s dS t|�t| j |j �krD| �|�rDdS | jd|d� dS )ax Check that all return statements inside a function are consistent. Return statements are consistent if: - all returns are explicit and if there is no implicit return; - all returns are empty and if there is, possibly, an implicit return. Args: node (nodes.FunctionDef): the function holding the return statements. c S s g | ]}|j d ur|�qS r )r� )r# �_noder& r& r' r� � s z@RefactoringChecker._check_consistent_returns.<locals>.<listcomp>Nr� rl )r� rT r� �_is_node_return_endedr� )rs r$ Zexplicit_returnsr& r& r' r$ � s � ��z,RefactoringChecker._check_consistent_returnsc sP t � fdd�|jD ��}|js0� �|�s,dS |S t � fdd�|jD ��}|oN|S )z�Check if the If node ends with an explicit return statement. Args: node (nodes.If): If node to be checked. Returns: bool: True if the node ends with an explicit statement, False otherwise. c 3 s$ | ] }t |tj�s� �|�V qd S r �r! r rQ r� )r# Z_ifnrr r& r' r( � s �z>RefactoringChecker._is_if_node_return_ended.<locals>.<genexpr>Fc 3 s$ | ] }t |tj�s� �|�V qd S r r� )r# Z_orerr r& r' r( � s �)r+ r, r� �_has_return_in_siblings)rs r$ Zis_if_returningZis_orelse_returningr& rr r' �_is_if_node_return_ended� s � �z+RefactoringChecker._is_if_node_return_endedc s� |j s dS t�|�sdS t�|j �}|du s@t|t�s@t|d�sDdS |�� �d�d }t� ||�}|durrt |�ng }|r�t � fdd�|D ��S dS ) z�Check if the Raise node ends with an explicit return statement. Args: node (nodes.Raise): Raise node to be checked. Returns: bool: True if the node ends with an explicit statement, False otherwise. TN�pytypeF�.rY c 3 s | ]}� � |�V qd S r �r� )r# Z_handlerrr r& r' r( � r) zARefactoringChecker._is_raise_node_return_ended.<locals>.<genexpr>) r. r Zis_node_inside_try_exceptra r! r r r� �splitZget_exception_handlersr@ r+ )rs r$ r. Zexc_namer3 r& rr r' �_is_raise_node_return_ended� s$ ��� z.RefactoringChecker._is_raise_node_return_endedc s> t |tj�rdS t |tj�r:t� fdd�t�|j�D ��S t |tj�rr|j � � rZt |� ppt� fdd�|j D ��S t |tj �r�� �|�S t |tj�r�� �|�S t |tj�r�dd� |�� D �}t|�� �| }t� fdd�|D ��o�t� fdd�|D ��S t |tj��r$t |j tj��r$|j j�s$dS t� fd d�|�� D ��S ) z�Check if the node ends with an explicit return statement. Args: node (nodes.NodeNG): node to be checked. Returns: bool: True if the node ends with an explicit statement, False otherwise. Tc 3 s* | ]"}t |tjtjf�o � �|�V qd S r )r! r rQ r rS � _is_function_def_never_returning)r# Z maybe_funcrr r& r' r( � s �z;RefactoringChecker._is_node_return_ended.<locals>.<genexpr>c 3 s | ]}� � |�V qd S r r� r/ rr r& r' r( � s c S s h | ]}t |tj�r|�qS r& )r! r � ExceptHandler�r# �_childr& r& r' r� s �z;RefactoringChecker._is_node_return_ended.<locals>.<setcomp>c 3 s | ]}� � |�V qd S r r� r� rr r& r' r( s c 3 s | ]}� � |�V qd S r r� r� rr r& r' r( r) c 3 s | ]}� � |�V qd S r r� r� rr r& r' r( r) )r! r rV r` r+ r Z infer_allrb �Whiler r� r r� r� r� r� r� r� r� r� r2 �Assertr� r� )rs r$ r3 Zall_but_handlerr& rr r' r� � s@ � � � �� � ��z(RefactoringChecker._is_node_return_endedc C s* | � � }|r&t|tj�r dS |� � }qdS )zDReturns True if there is at least one return in the node's siblings.TF)r� r! r rV )r$ r� r& r& r' r� s z*RefactoringChecker._has_return_in_siblingsz'nodes.FunctionDef | astroid.BoundMethodc C s| z|� � | jv rW dS W n ttfy. Y n0 z |j}W n tyN Y dS 0 t|tj�rf|jdv pzt|tj �oz|j dv S )a Return True if the function never returns, False otherwise. Args: node (nodes.FunctionDef or astroid.BoundMethod): function definition node to be analyzed. Returns: bool: True if the function never returns, False otherwise. TF> �NoReturn�Never) rc r� � TypeError�AttributeError�returnsr! r ra r r� rT )rs r$ r� r& r& r' r� s � �z3RefactoringChecker._is_function_def_never_returningc C s� t | j|j �dkrdS |js"dS |jd }t|tj�rJt |j�dkrJdS t|tjtjtj f�rj|� � }qJt|tj�r�|j du r�| j d|d� n(t|j tj �r�|j j du r�| j d|d� dS )a Check for presence of a *single* return statement at the end of a function. "return" or "return None" are useless because None is the default return type if they are missing. NOTE: produces a message only if there is a single return statement in the function body. Otherwise _check_consistent_returns() is called! Per its implementation and PEP8 we can have a "return None" at the end of the function body if there are other return statements before that! r9 NrY r� rl )r� r� rT r, r! r rV r� r� r� Z last_childr� r� r� )rs r$ �lastr& r& r' r% : s z+RefactoringChecker._check_return_at_the_endz nodes.For | nodes.Comprehensionc C s� t |jtj��r�t |jjtj��r�|jjjdk�r�t�|jj�}t |t j �sPdS |jjj � � }g }t |tj �rt|jn t|j�� �}tj�dd� |D ��}t|d�du}|D �] }|�tj�D �] } t | jtjtjf�s�q�| j} t |tj �r�t| �r� dS t | jtj ��r dS t | tj��r�t |j tj �r�t |j j �dk s�| j!|j j d j!ks�|| j� � k�rdq�t |tj ��r�| �"| j!�d d j#|j#k�r�q�|�r�|�$| |j j d � � d �� n | j%d | |j j d � � fd � q�t | tj�r�t |j tj&�r�t | jtj�r�|j j!| jj!ks�|| j� � k�r q�t |tj ��rR| j�"| jj!�d d j#|j#k�rRq�t�| j�}t |tj'�r�|jdk�rxq�|�r�|�$| d �(| � � j)d dd��d �� q�| j%d | d �(| � � j)d dd��fd � q�q�|D ] } | j%d | d | d fd � �q�dS )z7Add message when accessing dict values by index lookup.r[ Nc s s | ]}|� tjtjf�V qd S r �r� r rO r� r/ r& r& r' r( s zJRefactoringChecker._check_unnecessary_dict_index_lookup.<locals>.<genexpr>r� r r9 rY )r$ �variabler� r� �1�0)�maxsplitr$ r� )*r! r� r r` rb ra r r ra rR rS r� r rO r, r@ rW r� rH �chain� from_iterabler� r� r r� r� r rk �Deleterh ri r� r8 rT �lookupr\ rd r� r� r� rF �rsplit) rs r$ r_ �iterating_object_name�messagesr� � nested_loops�has_nested_loopsr0 � subscriptr� r� r& r& r' r� Z s� �� � � � � � ��� � ����� � �� � ��� ��� �� �z7RefactoringChecker._check_unnecessary_dict_index_lookupc C s� t |jtj�r,t |jjtj�r,|jjjdks0d S t}ztj |jddd�}W n( tj yr tj |jdd�}t }Y n0 t |tj�s�d S t |j tj�r�t|j j�dk r�d S t |j jd tj�s�d S | �|�\}}|r�d S |t kr�|n|}|j}|j jd }g }t |tj��r|jn t|j�� �} tj�dd � | D ��} t| d �d u} tj�d d � | D ��} t| d �d u} | D �].}|� tj �D �]}t |tj��r�t |��r� d S t |jtj ��r� d S |j }t |tj��rz|j|j jd jk�sz||j!�"� k�r��qzt |tj��r&|�#|j�d d j$|j$k�r&�qzt |tj��rV|�#|j�d d j$|j$k�rV�qz| �rh|�%|� n*| �rt�qzn | j&d ||j jd jf|d � �qz�qh|D ]$}| j&d ||j jd jf|d � �q�d S )Nr; r �iterable)�positionr� )r� r� r9 c s s | ]}|� tjtjf�V qd S r r� r/ r& r& r' r( ) s zJRefactoringChecker._check_unnecessary_list_index_lookup.<locals>.<genexpr>c s s | ]}|� tj�V qd S r )r� r r� r/ r& r& r' r( 2 s rY r� r� )'r! r� r r` rb r� rT r r Zget_argument_from_callZNoSuchArgumentErrorZinfer_kwarg_from_callr rh ri r� r8 r� �_enumerate_with_startrO r, r@ rW r� rH r� r� r� r� r rk r� r r� r r� r\ rd r� )rs r$ Zpreliminary_confidenceZ iterable_argZ has_start_argr� r� Zvalue_variableZ bad_nodesr� r� r� Z if_statementsZhas_if_statementsr0 r� r8 r& r& r' r� � s� �� �� �� � � � � �� � �� ��� ��z7RefactoringChecker._check_unnecessary_list_index_lookupztuple[bool, Confidence]c C s� t }t|jj�dkrL|jjd }| �|�\}}|du r>d|fS |dk |fS |jjD ]D}|jdkrT| �|j�\}}|du r�d|f S |dk |f S qTd|fS )a# Check presence of `start` kwarg or second argument to enumerate. For example: `enumerate([1,2,3], start=1)` `enumerate([1,2,3], 1)` If `start` is assigned to `0`, the default value, this is equivalent to not calling `enumerate` with start. r9 NFr rJ )r r� r� r� �_get_start_valuerE r\ r� )rs r$ r� Z start_arg� start_valr� r& r& r' r� t s z(RefactoringChecker._enumerate_with_startz tuple[int | None, Confidence]c C s� t |tjtjtjf�s6t |tj�r^t |jtjtjf�r^t�|�}t |tj �rR|j nd }|t fS t |tj�rv|jj t fS t |tj �r�|j t fS d t fS r ) r! r r� r` ra �UnaryOpr� r ra r� r� r r )rs r$ r_ r� r& r& r' r� � s � �� z#RefactoringChecker._get_start_value)[r{ r| r} r~ rT Zmsgs�optionsr� r� r� r r� � staticmethodr� r� r� r� r Zonly_required_for_messagesr� r� Z visit_whiler� r� r� r� r� r� r� r r r r r r r r! r r& r' r) r( r0 r< rG rN rS rX rI rJ rH r� r# r� rp rs r r� r� r� r� r� r� r� r� r� r� rK rL rM r� r� r� r� r� r� r� r� r� r$ r� r� r� r� r� r% r� r� r� r� � __classcell__r& r& r� r' r� � s� � � � � �� �� ���% F0 ��! � Q�"$� / ).8 ���.! �Q %2 "r� );� __future__r rk r� rH r> �collections.abcr � functoolsr r �rer �typingr r r r r rR r r Z astroid.utilr Zpylintr Zpylint.checkersr Z(pylint.checkers.base.basic_error_checkerr Zpylint.checkers.utilsr Zpylint.interfacesr r r Z pylint.lintr r� r� rO r� rb r^ r_ rY r� r� r- r4 rL rU rX r^ rd rk rm ZBaseTokenCheckerr� r& r& r& r' �<module> sJ � � +
| ver. 1.1 | |
.
| PHP 8.3.30 | Ð“ÐµÐ½ÐµÑ€Ð°Ñ†Ð¸Ñ Ñтраницы: 0 |
proxy
|
phpinfo
|
ÐаÑтройка