Operation   : Linux premium131.web-hosting.com 4.18.0-553.44.1.lve.el8.x86_64 #1 SMP Thu Mar 13 14:29:12 UTC 2025 x86_64
Software     : Apache
Server IP    : 162.0.232.56 | Your IP: 216.73.216.111
Domains      : 1034 Domain(s)
Permission   : [ 0755 ]

B

� fk�@s
dZd
Z
ddlZddlZddlZddlZddlZddlZddlZddl	m
Z

ddlmZm
Z
mZ
ddlmZ
ddlmZmZ
dd	lmZ
d!dd�
ZGd
d�de�Zdd�Zdd�Zdd�Zdd�Zdd�ZGdd�de�ZGdd�de�Z Gdd�de�Z!Gdd �d e �Z"dS)"z�Refactoring framework.

Used as a main program, this can refactor any number of files and/or
recursively descend down directories.  Imported as a module, this
provides infrastructure to write your own refactoring tool.
z#Guido van Rossum <guido@python.org>�N)
�chain�
)�driver�tokenize�token)
�	find_root)�pytree�pygram)
�btm_matcherTcCsXt|ggd
g
�}g}x>t
�|j�
D].\}}}|�d�
r"|
rF|dd�}|�|�

q"W|S)zEReturn a sorted list of all available fix names in the given package.�
*�fix_�N)�
__import__�pkgutilZiter_modules�__path__�
startswith�append)Z	fixer_pkgZ
remove_prefixZpkgZ	fix_names�finder�nameZispkg�r�5/opt/alt/python37/lib64/python3.7/lib2to3/refactor.py�get_all_fix_namess







rc
@seZ
dZd
S)�
_EveryNodeN)�__name__�
__module__�__qualname__rrrrr+s
rc
Cs�t|t
jt
jf�r(|jd
kr t�
|jh
St|t
j�rH|jrDt|j�
St�
t|t
j	�r�t
�}
x*|jD] }x|D]}|
�t|�
�

qlWqbW|
Std|�
�
d
S)zf Accepts a pytree Pattern Node and returns a set
        of the pattern types which will match first. Nz$Oh no! I don't understand pattern %s)
�
isinstancerZNodePatternZLeafPattern�typerZNegatedPatternZcontent�_get_head_typesZWildcardPattern�set�update�	Exception)Zpat�
r�
p�
xrrrr/s











rc
	Cs�t�
t�
}
g}x�|D]|}|jrjyt|j�
}Wntk
rJ


|�|�

Yq�XxB|D]}|
|�|�

qRWq|jd
k	r�|
|j�|�

q|�|�

qWx,tt	j
j��t	j
j
�D]}|
|�|�

q�Wt|
�
S)z^ Accepts a list of fixers and returns a dictionary
        of head node type --> fixer list.  N)�collections�defaultdict�list�patternrrrZ_accept_typerr	�python_grammarZ
symbol2number�values�tokens�extend�dict)Z
fixer_listZ
head_nodesZevery�fixerZheadsZ	node_typerrr�_get_headnode_dictKs"
















r/c

s�f
d
d�t�d�D�
S)zN
    Return the fully qualified names for fixers in the package pkg_name.
    c
sg|]}
�d|
�qS)
�
.r)�.0�fix_name)
�pkg_namerr�
<listcomp>hs
z+get_fixers_from_package.<locals>.<listcomp>F)
r)
r3r)
r3r�get_fixers_from_packageds

r5c


Cs|S)
Nr)
�objrrr�	_identityks
r7c
sV
d
}
t�
t�|�
j�
��f
dd�}ttjtjtj	h�
}t
�}y�x�|�\}}||krVq@q@|tjkrl|
rfPd}
q@|tjk�
r.|dk�
r.|�\}}|tjks�|dkr�P|�\}}|tjks�|dkr�P|�\}}|tj
kr�|dkr�|�\}}xJ|tjk�
r*|�|�

|�\}}|tj
k�
s|d	k�
rP|�\}}q�Wq@Pq@WWntk
�
rL


YnXt|�
S)
NFc
st��
}|d
|dfS)Nr
r)
�next)
�tok)
�genrr�advancers

z(_detect_future_features.<locals>.advanceT�fromZ
__future__�import�
(�
,)r�generate_tokens�io�StringIO�readline�	frozensetr�NEWLINE�NL�COMMENTr�STRING�NAME�OP�add�
StopIteration)�sourceZhave_docstringr;�ignore�features�tp�valuer)
r:r�_detect_future_featuresosD








































rRc
@seZ
dZd
ZdS)�
FixerErrorzA fixer could not be loaded.N)rrr�__doc__rrrrrS�s
rSc@s�eZ
dZd
d
d�ZdZdZd4dd�
Zdd	�Zd
d�Zdd
�Z	dd�Z
dd�Zd5dd�
Zd6dd�
Z
dd�Zd7dd�
Zdd�Zd8dd�
Zdd�Zd d!�Zd9d"d#�
Zd:d$d%�
Zd&Zd'Zd(d)�Zd*d+�Zd,d-�Zd.d/�Zd0d1�Zd2d3�ZdS);�RefactoringToolF)�print_function�write_unchanged_filesZFixrNcCs2
|
|_|pg|_
|j��|_|d
k	r0|j�|�

|jdrDtj|_ntj	|_|j�
d�
|_g|_t
�d�
|_g|_d|_tj|jtj|jd�|_|��\|_|_g|_t��|_g|_g|_xXt|j|j�D]F}|j r�|j�!|�

q�||jkr�|j�"|�

q�||jkr�|j�"|�

q�Wt#|j�
|_$t#|j�
|_%d
S)z�Initializer.

        Args:
            fixer_names: a list of fixers to import
            options: a dict with configuration.
            explicit: a list of fixers to run even if they are explicit.
        NrVrWrUF)�convert�logger)&�fixers�explicit�_default_options�copy�optionsr r	�!python_grammar_no_print_statement�grammarr)�getrW�errors�loggingZ	getLoggerrY�	fixer_log�wroterZDriverrrX�
get_fixers�	pre_order�
post_order�files�bmZ
BottomMatcher�BMZ
bmi_pre_orderZbmi_post_orderrZ
BM_compatibleZ	add_fixerrr/�bmi_pre_order_heads�bmi_post_order_heads)�selfZfixer_namesr^r[r.rrr�__init__�s<



























zRefactoringTool.__init__c
	Cs^
g}
g}�
x(|jD�
]}t
|iid
g
�}|�dd�d}|�|j�
rV|t|j�
d�}|�d�
}|jd�dd	�|D�
�
}yt	||�}Wn&t
k
r�


td
||f�
d�YnX||j|j
�}	|	jr�|jdk	r�||jkr�|�d|�
q|�d
|�
|	jdk�
r
|
�|	�

q|	jdk�
r"|�|	�

qtd|	j�
�
qWt�d�
}
|
j|
d�

|j|
d�

|
|fS)a
Inspects the options to load the requested patterns and handlers.

        Returns:
          (pre_order, post_order), where pre_order is the list of fixers that
          want a pre-order AST traversal, and post_order is the list that want
          post-order traversal.
        rr0r���N�
_�c
Ssg|]}
|
���qSr)
�title)r1r#rrrr4�sz.RefactoringTool.get_fixers.<locals>.<listcomp>zCan't find %s.%sTzSkipping optional fixer: %szAdding transformation: %sZpreZpostzIllegal fixer order: %rZ	run_order)
�key)rZr�rsplitr�FILE_PREFIX�len�split�CLASS_PREFIX�join�getattr�AttributeErrorrSr^rdr[�log_message�	log_debug�orderr�operator�
attrgetter�sort)rnZpre_order_fixersZpost_order_fixersZfix_mod_path�modr2�parts�
class_nameZ	fix_classr.Zkey_funcrrrrf�s8


























zRefactoringTool.get_fixerscOs�d
S)zCalled when an error occurs.Nr)rn�msg�args�kwdsrrr�	log_error�szRefactoringTool.log_errorcGs|r|
|}
|j�
|
�

d
S)zHook to log a message.N)rY�info)rnr�r�rrrr}
s

zRefactoringTool.log_messagecGs|r|
|}
|j�
|
�

dS)
N)rY�debug)rnr�r�rrrr~	
s


zRefactoringTool.log_debugc
Csd
S)zTCalled with the old version, new version, and filename of a
        refactored file.Nr)rn�old_text�new_text�filename�equalrrr�print_output
szRefactoringTool.print_outputcCs<x6|
D].}tj
�|�
r&|�|||�
q|�|||�
qWd
S)z)Refactor a list of files and directories.N)�os�path�isdir�refactor_dir�
refactor_file)rn�items�write�
doctests_onlyZdir_or_filerrr�refactor
s


zRefactoringTool.refactorc
Cs�tj
d
}x�t�|
�
D]�\}}}|�d|�
|��
|��
xF|D]>}|�d�
sBtj�|�
d|krBtj�||�}	|�	|	||�
qBWdd�|D�
|dd�<qWdS)z�Descends down a directory and refactor every Python file found.

        Python files are assumed to have a .py extension.

        Files and subdirectories starting with '.' are skipped.
        �pyzDescending into %sr0rc
Ssg|]}
|
�d�
s|
�qS)
r0)
r)r1Zdnrrrr4.
sz0RefactoringTool.refactor_dir.<locals>.<listcomp>N)
r��extsep�walkr~r�rr��splitextrzr�)
rnZdir_namer�r�Zpy_ext�dirpathZdirnames�	filenamesr�fullnamerrrr�
s











zRefactoringTool.refactor_dirc
Cs�yt|
d
�}Wn0t
k
r>
}
z|�d|
|�
dSd}~XYnXzt�|j�
d}Wd|��
Xtj|
d|dd��}|��|fSQRXdS)	zG
        Do our best to decode a Python source file correctly.
        �rbzCan't open %s: %s)NNNr
r"rr)�encoding�newline)	�open�OSErrorr�r�detect_encodingrC�closerA�read)rnr��
f�errr�rrr�_read_python_source0
s








z#RefactoringTool._read_python_sourcecCs�|�|
�
\}}|d
krd
S|d7}|rn|�
d|
�
|�||
�}|jsL||kr`|�||
|||�
q�|�
d|
�
nH|�||
�}|js�|r�|jr�|jt|�
d
d�|
||d�
n|�
d|
�
d
S)zRefactors a file.N�

zRefactoring doctests in %szNo doctest changes in %srp)r�r�zNo changes in %s)r�r~�refactor_docstringrW�processed_file�refactor_string�was_changed�str)rnr�r�r��inputr��output�treerrrr�@
s








zRefactoringTool.refactor_filec
Cs�t|
�
}d
|krt
j|j_zLy|j�|
�
}Wn6tk
rb
}
z|�d||jj	|�
dSd}~XYnXWd|j|j_X||_
|�d|�
|�||�
|S)aF
Refactor a given input string.

        Args:
            data: a string holding the code to be refactored.
            name: a human-readable name for use in error/log messages.

        Returns:
            An AST corresponding to the refactored input stream; None if
            there were errors during the parse.
        rVzCan't parse %s: %s: %sNzRefactoring %s)
rRr	r_rr`Zparse_stringr!r��	__class__r�future_featuresr~�
refactor_tree)rn�datarrOr�r�rrrr�W
s












zRefactoringTool.refactor_stringcCs�tj
��}|
rN|�d
�

|�|d�}|js2||krB|�|d|�
q�|�d�

n:|�|d�}|jsj|r~|jr~|�t	|�
d|�
n
|�d�

dS)NzRefactoring doctests in stdinz<stdin>zNo doctest changes in stdinzNo changes in stdin)
�sys�stdinr�r~r�rWr�r�r�r�)rnr�r�r�r�rrr�refactor_stdinr
s









zRefactoringTool.refactor_stdinc

Cs�
x"t|j
|j�D]}|�|
|�
qW|�|j|
�
��
|�|j|
���
|j�|
�	��
}�
xtt
|���
�
rΐ
x^|jjD�
]P}||krv||rv||j
tjjd
d�
|jr�||j
tjjd�

�
xt||�
D]�}|||kr�||�|�

yt|�

Wntk
�
r


w�YnX|j�
r&||jk�
r&q�|�|�
}|r�|�||�}|dk	r�|�|�

x,|��D] }|j�
sng|_|j�|�

�
q\W|j�|�	��
}x2|D]*}	|	|k�
r�g||	<||	�||	�

�
q�Wq�WqvWq\Wx$t|j
|j�D]}|�|
|�
�
q�W|
jS)a�
Refactors a parse tree (modifying the tree in place).

        For compatible patterns the bottom matcher module is
        used. Otherwise the tree is traversed node-to-node for
        matches.

        Args:
            tree: a pytree.Node instance representing the root of the tree
                  to be refactored.
            name: a human-readable name for this tree.

        Returns:
            True if the tree was modified, False otherwise.
        T)rt�reverse)
rtN)rrgrhZ
start_tree�traverse_byrlrmrk�runZleaves�anyr*rZr�rZBaseZdepthZkeep_line_orderZ
get_linenor'�remover�
ValueErrorZfixers_applied�match�	transform�replacerr,Zfinish_treer�)
rnr�rr.Z	match_set�node�results�newZnew_matchesZfxrrrrr��
sJ



















$

zRefactoringTool.refactor_treecCs^|
sd
SxP|D]H}xB|
|jD]4}|�
|�
}|r|�||�}|d
k	r|�|�

|}qWqWd
S)a
Traverse an AST, applying a set of fixers to each node.

        This is a helper method for refactor_tree().

        Args:
            fixers: a list of fixer instances.
            traversal: a generator that yields AST nodes.

        Returns:
            None
        N)rr�r�r�)rnrZZ	traversalr�r.r�r�rrrr��
s











zRefactoringTool.traverse_bycCs�|j�
|�

|d
kr.|�|�
d}|d
kr.d
S||
k}|�||
||�
|r`|�d|�
|js`d
S|rv|�|
|||�
n|�d|�
d
S)zR
        Called when a file has been refactored and there may be changes.
        Nr
zNo changes to %szNot writing changes to %s)rirr�r�r~rW�
write_file)rnr�r�r�r�r�r�rrrr��
s











zRefactoringTool.processed_filecCs�ytj
|d
|dd�}Wn0tk
rF
}
z|�d||�
dSd}~XYnX|�F
y|�|
�

Wn0tk
r�
}
z|�d||�
Wdd}~XYnXWdQRX|�d|�
d|_dS)	z�Writes a string to a file.

        It first shows a unified diff between the old text and the new text, and
        then rewrites the file; the latter is only done if the write option is
        set.
        �
wrr)r�r�zCan't create %s: %sNzCan't write %s: %szWrote changes to %sT)rAr�r�r�r�r~re)rnr�r�r�r��fpr�rrrr��
s







*

zRefactoringTool.write_filez>>> z... c
	Cs
g}d
}d
}d
}d}x�|
jdd�
D]�}|d7}|�
��|j�
r�|d
k	r\|�|�||||��

|}|g
}|�|j�
}	|d
|	�}q"|d
k	r�|�||j�
s�|||j��dkr�|�	|�

q"|d
k	r�|�|�||||��

d
}d
}|�	|�

q"W|d
k	�
r|�|�||||��

d�
|�
S)a�
Refactors a docstring, looking for doctests.

        This returns a modified version of the input string.  It looks
        for doctests, which start with a ">>>" prompt, and may be
        continued with "..." prompts, as long as the "..." is indented
        the same as the ">>>".

        (Unfortunately we can't use the doctest module's parser,
        since, like most parsers, it is not geared towards preserving
        the original source.)
        Nr
T)
�keependsrr�rr)�
splitlines�lstripr�PS1r,�refactor_doctest�find�PS2�rstriprrz)
rnr�r��result�blockZblock_lineno�indent�lineno�line�
irrrr�s:






























z"RefactoringTool.refactor_docstringc

s
y�
�|
|��}Wnft
k
rx
}
zH�
j�tj�
rRx|
D]}�
�d
|�d�
�
q8W�
�d|||j	j
|�
|
Sd}~XYnX�
�||��
rt|�
j
dd�
}|d|d�||dd�}	}|d�d�
s�|dd7<��
j|�d	�
g
}
|�
r|
��
fd
d�|D�
7}
|
S)z�Refactors one doctest.

        A doctest is given as a block of lines, the first of which starts
        with ">>>" (possibly indented), while the remaining lines start
        with "..." (identically indented).

        z
Source: %sr�z+Can't parse docstring in %s line %s: %s: %sNT)
r�rrpr
c
sg|]}
��
j|
�qSr)
r�)r1r�)r�rnrrr4Zsz4RefactoringTool.refactor_doctest.<locals>.<listcomp>)�parse_blockr!rYZisEnabledForrc�DEBUGr~r�r�r�rr�r�r��endswithr��pop)
rnr�r�r�r�r�r�r�r�Zclippedr)r�rnrr�@s$










"




z RefactoringTool.refactor_doctestc
Cs�|jrd
}
nd}
|j
s$|�d|
�
n&|�d|
�
x|j
D]}|�|�

q8W|jrt|�d�

x|jD]}|�|�

qbW|jr�t|j�
dkr�|�d�

n|�dt|j�
�
x&|jD]\}}}|j|f
|�|�

q�WdS)	N�werez
need to bezNo files %s modified.zFiles that %s modified:z$Warnings/messages while refactoring:rzThere was 1 error:zThere were %d errors:)rerir}rdrbrw)rnr��file�messager�r�r�rrr�	summarize]s$















zRefactoringTool.summarizecCs"|j�
|�|
||��
}t�|_|S)
z�Parses a block into a tree.

        This is necessary to get correct line number / offset information
        in the parser diagnostics and embedded into the parse tree.
        )rZparse_tokens�	wrap_toksrDr�)rnr�r�r�r�rrrr�ts

zRefactoringTool.parse_blockccsht�
|�|
|�j�
}xN|D]F\}}\}}\}	}
}||d
7}|	|d
7}	||||f|	|
f|fV
qWdS)z;Wraps a tokenize stream to systematically modify start/end.rN)rr@�	gen_lines�__next__)rnr�r�r�r+rrQZline0Zcol0Zline1Zcol1Z	line_textrrrr�~s



zRefactoringTool.wrap_toksccs�||j}||j
}|}xV|
D]N}|�|�
r@|t|�
d
�V
n(||��dkrXdV
ntd||f�
�
|}qWx
dV
qrWd
S)z�Generates lines as expected by tokenize from a list of lines.

        This strips the first len(indent + self.PS1) characters off each line.
        Nr�zline=%r, prefix=%rrr)r�r�rrwr��AssertionError)rnr�r��prefix1Zprefix2�prefixr�rrrr��s













zRefactoringTool.gen_lines)NN)FF)FF)FF)
F)NFN)
N)rrrr\ryrvrorfr�r}r~r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�rrrrrU�s:


4(
	


O



+
rUc
@seZ
dZd
S)�MultiprocessingUnsupportedN)rrrrrrrr��s
r�csBeZ
dZ�f
d
d�Zd�f
dd�	Z�f
dd�Z�f
d	d
�Z�ZS)�MultiprocessRefactoringToolc
s"tt
|�j|
|�

d|_d|_dS)
N)�superr�ro�queue�output_lock)rnr��kwargs)
r�rrro�s


z$MultiprocessRefactoringTool.__init__Frc
s
|d
krtt
�
��|
||�Syddl�Wntk
r@


t�
YnX�
jdk	rTtd�
�
����
_��	��
_
��
fdd�t|�
D�
}z.x|D]}|��
q�Wtt
�
��|
||�
Wd�
j�
�
xt|�
D]}�
j�d�

q�Wx|D]}|��r�|�
�
q�Wd�
_XdS)Nrr
z already doing multiple processesc
sg|]}
�j�
j
d�
�qS)
)
�target)ZProcess�_child)r1r�)�multiprocessingrnrrr4�s
z8MultiprocessRefactoringTool.refactor.<locals>.<listcomp>)r�r�r�r��ImportErrorr�r��RuntimeErrorZ
JoinableQueueZLockr��range�startrz�putZis_alive)rnr�r�r�Z
num_processesZ	processesr#r�)
r�)r�rnrr��s2
































z$MultiprocessRefactoringTool.refactorc
sR|j�
�}
xB|
dk	rL|
\}}ztt|�j||�

Wd|j��
X|j�
�}
qWdS)
N)r�rar�r�r�Z	task_done)rnZtaskr�r�)
r�rrr��s









z"MultiprocessRefactoringTool._childc
s2|jdk	r|j�
|
|f�

ntt|�j|
|�
SdS)
N)r�r�r�r�r�)rnr�r�)
r�rrr��s




z)MultiprocessRefactoringTool.refactor_file)FFr)rrrror�r�r��
__classcell__rr)
r�rr��s

r�)
T)#rT�
__author__rAr�rr�rcr�r%�	itertoolsrZpgen2rrrZ
fixer_utilrrrrr	r
rjrr!rrr/r5r7rRrS�objectrUr�r�rrrr�<module>	s8










(