Current File : //opt/alt/python37/lib/python3.7/site-packages/future/tests/__pycache__/base.cpython-37.pyc
B
�A�[�L � @ s� d dl mZmZ d dlZd dlZd dlZd dlZd dlZd dlZd dl Z d dl
m Z d dl m
Z
mZmZmZmZ d dlmZmZmZ er�d dlZdd� Zdd � ZG d
d � d e�ZG d d
� d
e�ZG dd� de�ZG dd� dej �Z e� ed�Z dd� Z dd� Z!dd� Z"dd� Z#e$ej d��s(ej j%ej _&d$d d �Z'e$ej d ��sNe
ej d e'� G d d � d e(�Z)G d d!� d!e)�Z*d%d"d#�Z+e$ej d#��s�e
ej d#e+� dS )&� )�print_function�absolute_importN)�dedent)� bind_method�PY26�PY3�PY2�PY27)� check_output�STDOUT�CalledProcessErrorc C s | � d�r| dd� } t| �S )z,
Removes any leading
and dedents.
�
� N)�
startswithr )�code� r �B/opt/alt/python37/lib/python3.7/site-packages/future/tests/base.py�
reformat_code s
r c sh | � d�� dd� t� �D �}dd� t� �D �}dd� t� �D �}| �� | ksTtd��dd� }d d
� }||�||�ks|td ��t� fd d�|D ��}tt||��}t� fd
d�|D ��}tt||��} t� fdd�|D ��}
tt||
��} g } xptt� ��D ]`}
|
|k�r| � ||
� q�|
|k�r2| � | |
� q�|
|k�rL| � | |
� q�| � � |
� q�W 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 S s g | ]\}}|� d �r|�qS )zfrom __future__ import )r )�.0�i�liner r r �
<listcomp>* s z&order_future_lines.<locals>.<listcomp>c S s( g | ] \}}|� d �s |� d�r|�qS )z from futurez from past)r )r r r r r r r - s
c S s g | ]\}}|� d �r|�qS )z
from builtins)r )r r r r r r r 1 s zIinternal usage error: dedent the code before calling order_future_lines()c S s t | �dkrt| �S dS )Nr )�len�max)�numbersr r r �mymax7 s z!order_future_lines.<locals>.mymaxc S s t | �dkrt| �S td�S )Nr �inf)r �min�float)r r r r �mymin: s z!order_future_lines.<locals>.myminz2the __future__ and future imports are out of orderc s g | ] }� | �qS r r )r r )�linesr r r C s c s g | ] }� | �qS r r )r r )r r r r F s c s g | ] }� | �qS r r )r r )r r r r I s ) �split� enumerate�lstrip�AssertionError�sorted�dict�zip�ranger �append�join)r Zuufuture_line_numbersZfuture_line_numbersZbuiltins_line_numbersr r ZuulZsorted_uufuture_linesZflZsorted_future_linesZblZsorted_builtins_linesZ new_linesr r )r r �order_future_lines s2
r+ c @ s" e Zd ZdZddd�Zdd� ZdS )�VerboseCalledProcessErrorz�
Like CalledProcessError, but it displays more information (message and
script output) for diagnosing test failures etc.
Nc C s || _ || _|| _|| _d S )N)�msg�
returncode�cmd�output)�selfr- r. r/ r0 r r r �__init__` s z"VerboseCalledProcessError.__init__c C s d| j | j| j| jf S )Nz>Command '%s' failed with exit status %d
Message: %s
Output: %s)r/ r. r- r0 )r1 r r r �__str__f s z!VerboseCalledProcessError.__str__)N)�__name__�
__module__� __qualname__�__doc__r2 r3 r r r r r, [ s
r, c @ s e Zd ZdS )�
FuturizeErrorN)r4 r5 r6 r r r r r8 j s r8 c @ s e Zd ZdS )�PasteurizeErrorN)r4 r5 r6 r r r r r9 m s r9 c @ st e Zd ZdZdd� Zddd�Zd d d
�Zd d � Zd d
d�Zdd� Z d dd�Z
d dd�Z d dd�Z de
jfdd�ZdS )!� CodeHandlerzt
Handy mixin for test classes for writing / reading / futurizing /
running .py files in the test suite.
c C sj t d�| _t d�| _tjg| _t�� tj j
| _ t� d�}|rXdt�
� tj | i| _ndt�
� 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 *
Z
PYTHONPATHN)r �headers1�headers2�sys�
executable� interpreters�tempfileZmkdtemp�os�path�sep�tempdir�getenv�getcwd�pathsep�env)r1 Zpypathr r r �setUpv s
zCodeHandler.setUp�r � FTc C sT |r t |�}| �|� | j||||d� | �� }|rPx| jD ]} | j| d�}
q<W |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_imports�from3� conservative)� interpreter)r �_write_test_script�_futurize_test_script�_read_test_scriptr? �_run_test_script) r1 r rL rM rN Zreformat�runrO r0 rP �_r r r �convert� s
zCodeHandler.convertc C sp |r| � |�}| � |�}t|t�r6t|t�s6|�d�}t|t�rTt|t�sT|�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.
zutf-8N)�strip_future_imports�
isinstance�bytes�decodeZ assertEqualr+ �rstrip)r1 r0 �expected�ignore_importsr r r �compare� s
zCodeHandler.comparec C sd g }xT|� d�D ]F}|�d�s|�d�s|�d�sd|ksd|ks|�d�s|�|� qW d�|�S )a
Strips any of these import lines:
from __future__ import <anything>
from future <anything>
from future.<anything>
from builtins <anything>
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
zfrom __future__ import z from future zfrom builtins zinstall_hooks()zinstall_aliases()z from future.)r! r r) r* )r1 r r0 r r r r rX � s
z CodeHandler.strip_future_importsc C sP | j ||||||d�} |r0d|kr(| jn| j}
nd}
| j| |
t|� |d� 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.
)rL rM rN rU rO rK � )r^ N)rW r< r; r_ r ) r1 Zbeforer] rL rM r^ rN rU rO r0 Zheadersr r r �
convert_check� s
zCodeHandler.convert_checkc K s | j ||f|� dS )ze
Convenience method to ensure the code is unchanged by the
futurize process.
N)ra )r1 r �kwargsr r r � unchanged s zCodeHandler.unchanged�mytestscript.pyc C sH t |t�r|�d�}tj| j| ddd��}|�t|�� W dQ R X 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.
zutf-8Zwt)�encodingN)rY rZ r[ �io�openrD �writer )r1 r �filename�fr r r rQ s
z CodeHandler._write_test_scriptc C s. t j| j| ddd��}|�� }W d Q R X |S )NZrtzutf-8)re )rf rg rD �read)r1 ri rj Z newsourcer r r rS ( s z CodeHandler._read_test_scriptc C s. g }t |�}|r|�d� |r$d}nNd}|dgkr>|�d� n&|dgkrT|�d� n|ddgksdt�|rr|�d� | j| }tj|g| d |g } yt| t| jd
�}
W n� t k
�r( } zbt
|��*} d d � | �d
| j |d| � � f }
W d Q R X d|kr�t
nt}||
| j| j| jd��W d d } ~ X Y nX |
S )Nz
--all-importsz
pasteurize.pyz futurize.pyr z--stage1rK z--stage2z--conservativez-w)�stderrrH z8Error running the command %s
%s
Contents of file %s:
%s� zenv=%sz ----
%s
----Zfuturize)r0 )�listr) r$ rD r= r> r
r rH r rg r* rk r8 r9 r. r/ r0 )r1 ri rL rM rN rO ZparamsZscript�fn� call_argsr0 �erj r- Z
ErrorClassr r r rR - s8
(z!CodeHandler._futurize_test_scriptc C s� | j | }yt||g| jtd�}W n� tk
r� } zft|��.}dd�||g�d| j |d|�� f }W d Q R X t|d�s�d |_ t
||j |j |j d��W d d }~X Y nX |S )N)rH rl z8Error running the command %s
%s
Contents of file %s:
%srm zenv=%sz ----
%s
----r0 )r0 )
rD r
rH r r rg r* rk �hasattrr0 r, r. r/ )r1 ri rP ro r0 rq rj r- r r r rT X s
(z CodeHandler._run_test_scriptN)rJ FFTTF)T)rJ FTFTF)rd )rd )rd rJ FFF)r4 r5 r6 r7 rI rW r_ rX ra rc rQ rS rR r= r> rT r r r r r: q s" +
"
)r: z#this test is known to fail on Py2.6c C s t s| S t�| �S )N)r �unittest�expectedFailure)�funcr r r �expectedFailurePY3w s rv c C s t s| S t�| �S )N)r rs rt )ru r r r �expectedFailurePY26| s rw c C s t s| S t�| �S )N)r rs rt )ru r r r �expectedFailurePY27� s rx c C s t s| S t�| �S )N)r rs rt )ru r r r �expectedFailurePY2� s ry �assertRaisesRegexc C sT t |ttf�r$|std��t�|�}|�|�sP|p4d}d||j|f }| �|��dS )z=Fail the test unless the text matches the regular expression.z!expected_regex must not be empty.zRegex didn't matchz%s: %r not found in %rN) rY �strZunicoder$ �re�compile�search�pattern�failureException)r1 �text�expected_regexr- r r r � assertRegex� s
r� c @ s& e Zd Zddd�Zdd� Zdd� ZdS ) �_AssertRaisesBaseContextNc C sp || _ || _|d k rBy |j| _W qH tk
r> t|�| _Y qHX nd | _t|ttf�r`t� |�}|| _
d | _ d S )N) r] � test_caser4 �obj_name�AttributeErrorr{ rY rZ r| r} r� r- )r1 r] r� � callable_objr� r r r r2 � s
z!_AssertRaisesBaseContext.__init__c C s | j �| j|�}| j �|��d S )N)r� Z_formatMessager- r� )r1 Z standardMsgr- r r r �
_raiseFailure� s z&_AssertRaisesBaseContext._raiseFailurec C s8 |dkr|� dd�| _| S | � |||� W dQ R X dS )z�
If callable_obj is None, assertRaises/Warns is being used as a
context manager, so check for a 'msg' kwarg and return self.
If callable_obj is not None, call it passing args and kwargs.
Nr- )�popr- )r1 �namer� �argsrb r r r �handle� s
z _AssertRaisesBaseContext.handle)NN)r4 r5 r6 r2 r� r� r r r r r� � s
r� c @ s e Zd ZdZdd� Zdd� ZdS )�_AssertWarnsContextzBA context manager used to implement TestCase.assertWarns* methods.c C sR x$t j�� D ]}t|dd �r i |_q W tjdd�| _| j�� | _t� d| j
� | S )N�__warningregistry__T)�record�always) r= �modules�values�getattrr� �warnings�catch_warnings�warnings_manager� __enter__� simplefilterr] )r1 �vr r r r� � s
z _AssertWarnsContext.__enter__c C s | j �|||� |d k r d S y | jj}W n tk
rF t| j�}Y nX d }xb| jD ]X}|j}t|| j�slqT|d krx|}| j d k r�| j �
t|��s�qT|| _ |j | _ |j
| _
d S W |d k r�| �d�| j jt|��� | jr�| �d�|| j�� n| �d�|�� d S )Nz"{}" does not match "{}"z{} not triggered by {}z{} not triggered)r� �__exit__r] r4 r� r{ r� �messagerY r� r~ Zwarningri �linenor� �formatr r� )r1 �exc_type� exc_value�tbZexc_nameZfirst_matching�m�wr r r r� � s8
z _AssertWarnsContext.__exit__N)r4 r5 r6 r7 r� r� r r r r r� � s r� c O s 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� )r1 Zexpected_warningr� r� rb �contextr r r r� � s r� )N)N),Z
__future__r r rA r@ rs r= r| r� rf �textwrapr Z future.utilsr r r r r Zfuture.moves.subprocessr
r r Z unittest2r r+ r, r8 r9 ZTestCaser: ZskipIfZskip26rv rw rx ry rr ZassertRaisesRegexprz r� �objectr� r� r� r r r r �<module> sF @
"1
Mini Shell