9L, | d dl mZmZ d dlZd dlZd dlZd dlZd dlZd dlZd dl Z d dl
m Z d dl m
Z
mZmZmZmZ d dlmZmZmZ erd dlZd Zd Z G d d e Z G d
d e Z G d d
e Z G d dej Z ej ed Z d Z d Z!d Z"d Z# e$ej d sej j% ej _& d dZ' e$ej d s e
ej de' G d de( Z) G d de) Z*d d Z+ e$ej d s e
ej d e+ dS dS ) )print_functionabsolute_importN)dedent) bind_methodPY26PY3PY2PY27) check_outputSTDOUTCalledProcessErrorc ^ | d r
| dd } t | S )z,
Removes any leading
and dedents.
N)
startswithr )codes c/builddir/build/BUILD/cloudlinux-venv-1.0.10/venv/lib/python3.11/site-packages/future/tests/base.py
reformat_coder s1 t ABBx $<< c
| d d t D }d t D }d t D }| | k s
J d d }d } || || k s
J d t fd |D }t t || }t fd
|D }t t || } t fd |D }
t t ||
} g } t
t D ]}}
|
|v r | ||
"|
|v r | | |
B|
|v r | | |
b| |
~d | S ) a
Returns the code block with any ``__future__`` import lines sorted, and
then any ``future`` import lines sorted, then any ``builtins`` import lines
sorted.
This only sorts the lines within the expected blocks.
See test_order_future_lines() for an example.
r c B g | ] \ }}| d | S )from __future__ import r .0ilines r
z&order_future_lines..* sD N N N71d"&//2K"L"L NQ N N Nr c l g | ]1\ }}| d s| d /|2S )z from futurez from pastr r s r r z&order_future_lines..- sP > > >D $
> >> $ < <>1 > > >r c B g | ] \ }}| d | S )z
from builtinsr r s r r z&order_future_lines..1 sC B B B71d $ @ @ BQ B B Br zIinternal usage error: dedent the code before calling order_future_lines()c J t | dk rt | ndS )Nr )lenmaxnumberss r mymaxz!order_future_lines..mymax7 s" "7||a / /s7|||Q6r c d t | dk rt | nt d S )Nr inf)r" minfloatr$ s r myminz!order_future_lines..mymin: s( "7||a / /s7|||U5\\Ar z2the __future__ and future imports are out of orderc g | ]
}| S r- r r liness r r z&order_future_lines..C s :::q%(:::r c g | ]
}| S r- r- r. s r r z&order_future_lines..F s 777aq777r c g | ]
}| S r- r- r. s r r z&order_future_lines..I s 999aq999r )
split enumeratelstripsorteddictzipranger" appendjoin)r uufuture_line_numbersfuture_line_numbersbuiltins_line_numbersr& r+ uulsorted_uufuture_linesflsorted_future_linesblsorted_builtins_lines new_linesr r/ s @r order_future_linesrE s
JJt E N Ni.>.> N N N> >Ie,<,< > > > B Bi.>.> B B B ;;==D $B 7 7 7B B B 5& ' '551D+E+E E E E @ F E E ::::$9:::
;
;C %:C!@!@ A A 7777#6777 8 8B s#6 ; ;<< 9999#8999 : :B %:B!?!? @ @ I
3u::
' ' % % % 21 5 6 6 6 6
%
%
% 0 3 4 4 4 4
'
'
' 21 5 6 6 6 6 U1X & & & & 99Y r c e Zd ZdZddZd ZdS )VerboseCalledProcessErrorz
Like CalledProcessError, but it displays more information (message and
script output) for diagnosing test failures etc.
Nc > || _ || _ || _ || _ d S N)msg
returncodecmdoutput)selfrJ rK rL rM s r __init__z"VerboseCalledProcessError.__init__` s" $ r c < d| j | j | j | j fz S )Nz>Command '%s' failed with exit status %d
Message: %s
Output: %s)rL rK rJ rM )rN s r __str__z!VerboseCalledProcessError.__str__f s% R8T_dh DE Fr rI )__name__
__module__ __qualname____doc__rO rQ r- r r rG rG [ sF F F F F Fr rG c e Zd ZdS )
FuturizeErrorNrR rS rT r- r r rW rW j Dr rW c e Zd ZdS )PasteurizeErrorNrX r- r r r[ r[ m rY r r[ c z e Zd ZdZd Z ddZddZd Z dd Zd
Z dd Z
dd
Z ddZ d e
j fdZdS ) CodeHandlerzt
Handy mixin for test classes for writing / reading / futurizing /
running .py files in the test suite.
c t d | _ t d | _ t j g| _ t
j t j j
z | _ t j d }|r,dt j
t j z |z i| _ dS dt j
i| _ dS )zi
The outputs from the various futurize stages should have the
following headers:
z
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
a4
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
from __future__ import unicode_literals
from future import standard_library
standard_library.install_aliases()
from builtins import *
PYTHONPATHN)r headers1headers2sys
executable interpreterstempfilemkdtempospathseptempdirgetenvgetcwdpathsepenv)rN pypaths r setUpzCodeHandler.setUpv s & '
& '
!^ , '))BGK7 <(( 3$bikkBJ&>&GHDHHH$bikk2DHHHr r FTc |rt | }| | | |||| | }|r | j D ]} | | }
|S )a
Converts the code block using ``futurize`` and returns the
resulting code.
Passing stages=[1] or stages=[2] passes the flag ``--stage1`` or
``stage2`` to ``futurize``. Passing both stages runs ``futurize``
with both stages by default.
If from3 is False, runs ``futurize``, converting from Python 2 to
both 2 and 3. If from3 is True, runs ``pasteurize`` to convert
from Python 3 to both 2 and 3.
Optionally reformats the code block first using the reformat() function.
If run is True, runs the resulting code under all Python
interpreters in self.interpreters.
)stages all_importsfrom3 conservative) interpreter)r _write_test_script_futurize_test_script_read_test_scriptrd _run_test_script) rN r rt ru rv reformatrunrw rM rx _s r convertzCodeHandler.convert s & ' &&D %%% ""&k).\ # K K K'')) C # 0
C
C ))k)BB
r c |r*| | }| | }t |t r*t |t s| d }t |t r*t |t s| d }| t | | dS )a
Compares whether the code blocks are equal. If not, raises an
exception so the test fails. Ignores any trailing whitespace like
blank lines.
If ignore_imports is True, passes the code blocks into the
strip_future_imports method.
If one code block is a unicode string and the other a
byte-string, it assumes the byte-string is encoded as utf-8.
utf-8N)strip_future_imports
isinstancebytesdecode assertEqualrE rstrip)rN rM expectedignore_importss r comparezCodeHandler.compare s ;..v66F00::H fe $ $ ,Z%-H-H ,]]7++F h & & 0z&%/H/H 0 w//H +FMMOO<<! ** , , , , ,r c B g }| d D ]s}| d s\| d sG| d s2d|v s.d|v s*| d s| | td | S )a
Strips any of these import lines:
from __future__ import
from future
from future.
from builtins
or any line containing:
install_hooks()
or:
install_aliases()
Limitation: doesn't handle imports split across multiple lines like
this:
from __future__ import (absolute_import, division, print_function,
unicode_literals)
r r z from future zfrom builtins zinstall_hooks()zinstall_aliases()z from future.)r2 r r9 r: )rN r rM r s r r z CodeHandler.strip_future_imports s ( JJt$$ $ $DOO$=>>
$~66
$'788
$ )D00*d22~66 3
d###yy r c | |||||| } |rd|v r| j n| j }
nd}
t | } |
| v rd}
| | |
| z | dS )a<
Convenience method that calls convert() and compare().
Reformats the code blocks automatically using the reformat_code()
function.
If all_imports is passed, we add the appropriate import headers
for the stage(s) selected to the ``expected`` code-block, so they
needn't appear repeatedly in the test code.
If ignore_imports is True, ignores the presence of any lines
beginning:
from __future__ import ...
from future import ...
for the purpose of the comparison.
)rt ru rv r~ rw rr )r N)r ra r` r r ) rN beforer rt ru r rv r~ rw rM headers reformatteds r
convert_checkzCodeHandler.convert_check s * fV$)s O O '(F{{dmm
GGG#H-- k ! !G VW{ 2$2 4 4 4 4 4r c $ | j ||fi | dS )ze
Convenience method to ensure the code is unchanged by the
futurize process.
N)r )rN r kwargss r unchangedzCodeHandler.unchanged s'
40000000r mytestscript.pyc t |t r| d }t j | j |z dd 5 }| t | ddd dS # 1 swxY w Y dS )z
Dedents the given code (a multiline string) and writes it out to
a file in a temporary folder like /tmp/tmpUDCn7x/mytestscript.py.
r wtencodingN)r r r ioopenrj writer )rN r filenamefs r ry z CodeHandler._write_test_script! s
dE " " (;;w''D
WT\H,dW
E
E
E "
GGF4LL ! ! ! " " " " " " " " " " " " " " " " " "s
#A::A>A>c t j | j |z dd 5 }| }d d d n # 1 swxY w Y |S )Nrtr r )r r rj read)rN r r newsources r r{ z CodeHandler._read_test_script, s
WT\H,dW
E
E
E !I ! ! ! ! ! ! ! ! ! ! ! ! ! ! !s AAAc g }t | }|r| d |rd}n]d}|dgk r| d n'|dgk r| d n
|ddgk sJ |r| d | j |z }t j |g|z d |gz } t | t | j
}
n# t $ r} t | 5 } d d
| d
d| j z d|dd| z }
d d d n # 1 swxY w Y d|v rt nt }t | d sd | _ ||
| j | j | j d } ~ ww xY w|
S )Nz
--all-importsz
pasteurize.pyz futurize.pyr z--stage1rr z--stage2z--conservativez-w)stderrrn Error running the command r env=%s
Contents of file :
----
%s
----futurizerM rM )listr9 rj rb rc r r rn r
r r: r rW r[ hasattrrM rK rL )rN r rt ru rv rw paramsscriptfn call_argsrM er rJ
ErrorClasss r rz z!CodeHandler._futurize_test_script1 s f + MM/ * * * 0$FF"F!}}
j))))A3
j)))) !Q''''
0
./// \H
$^V,v5r
B H!)FIIIFF! H H Hb
QQ ++++ 48+++(1668833
,6+?+?--_J1h''
*S!,ahGGG G% H&
s= , C
FE?"?D-! E?-D1 1E?4D1 5A
E??Fc | j |z } t ||g| j t }n# t $ r}t | 5 }dd ||g dd| j z d|dd| z }d d d n # 1 swxY w Y t |d sd |_ t ||j |j |j
d }~ww xY w|S ) N)rn r r r r r r r r rM r )
rj r rn r r
r r: r r rM rG rK rL )rN r rx r rM r r rJ s r r| z CodeHandler._run_test_script` sI \H
$ W!;"3&*hv? ? ?FF! W W Wb
QQ +r!23333 48+++(1668833
1h''
+C quQXVVV V! W"
s9 +
CCAB CB CB >x?C} N N
O
O
O
O
O
1 8 8 B B C C C C Cs / AAN)rR rS rT rU r r r- r r r r s= LL D D D D Dr r c T t || | }| d||| S )a Fail unless a warning of class warnClass is triggered
by callable_obj when invoked with arguments args and keyword
arguments kwargs. If a different type of warning is
triggered, it will not be handled: depending on the other
warning filtering rules in effect, it might be silenced, printed
out, or raised as an exception.
If called with callable_obj omitted or None, will return a
context object used like this::
with self.assertWarns(SomeWarning):
do_something()
An optional keyword argument 'msg' can be provided when assertWarns
is used as a context object.
The context manager keeps a reference to the first matching
warning as the 'warning' attribute; similarly, the 'filename'
and 'lineno' attributes give you information about the line
of Python code from which the warning was triggered.
This allows you to inspect the warning after the assertion::
with self.assertWarns(SomeWarning) as cm:
do_something()
the_warning = cm.warning
self.assertEqual(the_warning.some_attribute, 147)
assertWarns)r r )rN expected_warningr r r contexts r r r s. 8 ""2D,GGG >>- tV D DDr r rI ),
__future__r r rg re r rb r r r textwrapr future.utilsr r r r r
future.moves.subprocessr r r
unittest2r rE rG rW r[ TestCaser] skipIfskip26r r r r r assertRaisesRegexpr r objectr r r r- r r r s! 6 6 6 6 6 6 6 6
: : : : : : : : : : : : : : L L L L L L L L L L ! = = = @
F
F
F
F
F 2
F
F
F - / G G G G G(# G G GV
D E E* * *
* * * * * * * * * wx "566 O*2*;*NH') ) ) ) wx -00 ?K!=+>>> * * * * *v * * *D.D .D .D .D .D2 .D .D .Db E E E E> wx -00 ?K!=+>>>>>? ?r