HEX

File: //usr/local/lib/python3.9/site-packages/future/tests/__pycache__/base.cpython-39.pyc
a

q�dg�M�@s�ddlmZmZddlZddlZddlZddlZddlZddlZddl	Z	ddl
mZddlm
Z
mZmZmZmZddlmZmZmZer�ddlZdd�Zdd	�ZGd
d�de�ZGdd
�d
e�ZGdd�de�ZGdd�dej�Ze�ed�Zdd�Z dd�Z!dd�Z"dd�Z#e$ejd��s(ejj%ej_&d$dd�Z'e$ejd��sNe
ejde'�Gdd�de(�Z)Gd d!�d!e)�Z*d%d"d#�Z+e$ejd#��s�e
ejd#e+�dS)&�)�print_function�absolute_importN)�dedent)�bind_method�PY26�PY3�PY2�PY27)�check_output�STDOUT�CalledProcessErrorcCs|�d�r|dd�}t|�S)z,
    Removes any leading 
 and dedents.
    �
�N)�
startswithr)�code�r�;/usr/local/lib/python3.9/site-packages/future/tests/base.py�
reformat_codes
rcsd|�d��dd�t��D�}dd�t��D�}dd�t��D�}|��|ksTJd��dd�}d	d
�}||�||�ks|Jd��t�fdd�|D��}tt||��}t�fd
d�|D��}tt||��}	t�fdd�|D��}
tt||
��}g}tt���D]`}
|
|v�r|�||
�q�|
|v�r0|�|	|
�q�|
|v�rJ|�||
�q�|��|
�q�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
cSsg|]\}}|�d�r|�qS)�from __future__ import �r��.0�i�linerrr�
<listcomp>*s
�z&order_future_lines.<locals>.<listcomp>cSs(g|] \}}|�d�s |�d�r|�qS)zfrom futurez	from pastrrrrrr-s

�cSsg|]\}}|�d�r|�qS)z
from builtinsrrrrrr1s
�zIinternal usage error: dedent the code before calling order_future_lines()cSst|�dkrt|�SdS)Nr)�len�max�Znumbersrrr�mymax7sz!order_future_lines.<locals>.mymaxcSst|�dkrt|�Std�S)Nr�inf)r�min�floatrrrr�mymin:sz!order_future_lines.<locals>.myminz2the __future__ and future imports are out of ordercsg|]}�|�qSrr�rr��linesrrrC�csg|]}�|�qSrrr#r$rrrFr&csg|]}�|�qSrrr#r$rrrIr&)
�split�	enumerate�lstrip�sorted�dict�zip�ranger�append�join)rZuufuture_line_numbersZfuture_line_numbersZbuiltins_line_numbersrr"ZuulZsorted_uufuture_lines�flZsorted_future_lines�blZsorted_builtins_lines�	new_linesrrr$r�order_future_liness4
�


r3c@s"eZdZdZddd�Zdd�ZdS)�VerboseCalledProcessErrorz�
    Like CalledProcessError, but it displays more information (message and
    script output) for diagnosing test failures etc.
    NcCs||_||_||_||_dS�N)�msg�
returncode�cmd�output)�selfr6r7r8r9rrr�__init__`sz"VerboseCalledProcessError.__init__cCsd|j|j|j|jfS)Nz>Command '%s' failed with exit status %d
Message: %s
Output: %s)r8r7r6r9)r:rrr�__str__fs�z!VerboseCalledProcessError.__str__)N)�__name__�
__module__�__qualname__�__doc__r;r<rrrrr4[s
r4c@seZdZdS)�
FuturizeErrorN�r=r>r?rrrrrAjsrAc@seZdZdS)�PasteurizeErrorNrBrrrrrCmsrCc@steZdZdZdd�Zddd�Zdd	d
�Zdd�Zdd
d�Zdd�Z	ddd�Z
ddd�Zd dd�Zde
jfdd�ZdS)!�CodeHandlerzt
    Handy mixin for test classes for writing / reading / futurizing /
    running .py files in the test suite.
    cCsjtd�|_td�|_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 *
        �
PYTHONPATHN)r�headers1�headers2�sys�
executable�interpreters�tempfile�mkdtemp�os�path�sep�tempdir�getenv�getcwd�pathsep�env)r:Zpypathrrr�setUpvs

	

zCodeHandler.setUp�r�FTcCsP|rt|�}|�|�|j||||d�|��}|rL|jD]}	|j|	d�}
q:|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_scriptrJ�_run_test_script)r:rrXrYrZZreformat�runr[r9r\�_rrr�convert�s
�
zCodeHandler.convertcCsp|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.
        �utf-8N)�strip_future_imports�
isinstance�bytes�decode�assertEqualr3�rstrip)r:r9�expected�ignore_importsrrr�compare�s



�zCodeHandler.comparecCs`g}|�d�D]F}|�d�s|�d�s|�d�sd|vsd|vs|�d�s|�|�qd�|�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
rzfrom future zfrom builtins zinstall_hooks()zinstall_aliases()zfrom future.)r'rr.r/)r:rr9rrrrre�s
�����z CodeHandler.strip_future_importsc	Cs`|j||||||d�}	|r0d|vr(|jn|j}
nd}
t|�}|
|vrHd}
|j|	|
||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.
        )rXrYrZrar[rW�)rlN)rcrGrFrrm)r:�beforerkrXrYrlrZrar[r9�headersZreformattedrrr�
convert_check�s
��zCodeHandler.convert_checkcKs|j||fi|��dS)ze
        Convenience method to ensure the code is unchanged by the
        futurize process.
        N)rq)r:r�kwargsrrr�	unchangedszCodeHandler.unchanged�mytestscript.pycCs\t|t�r|�d�}tj|j|ddd��}|�t|��Wd�n1sN0YdS)z�
        Dedents the given code (a multiline string) and writes it out to
        a file in a temporary folder like /tmp/tmpUDCn7x/mytestscript.py.
        rd�wt��encodingN)rfrgrh�io�openrP�writer)r:r�filename�frrrr]!s

zCodeHandler._write_test_scriptcCsBtj|j|ddd��}|��}Wd�n1s40Y|S)N�rtrdrv)rxryrP�read)r:r{r|Z	newsourcerrrr_,s&zCodeHandler._read_test_scriptcCsXg}t|�}|r|�d�|r$d}nNd}|dgkr>|�d�n&|dgkrT|�d�n|ddgksdJ�|rr|�d�|j|}tj|g|d	|g}	zt|	t|jd
�}
Wn�t�yR}z�t	|��4}dd�
|	�d
|j|d|��f}
Wd�n1s�0Yd|v�rtnt
}t|d��s(d|_||
|j|j|jd��WYd}~n
d}~00|
S)Nz
--all-importsz
pasteurize.pyzfuturize.pyrz--stage1rWz--stage2z--conservativez-w)�stderrrT�8Error running the command %s
%s
Contents of file %s:

%s� �env=%s�----
%s
----Zfuturizer9�r9)�listr.rPrHrIr
rrTrryr/r~rArC�hasattrr9r7r8)r:r{rXrYrZr[�params�script�fnZ	call_argsr9�er|r6Z
ErrorClassrrrr^1s@






��",z!CodeHandler._futurize_test_scriptcCs�|j|}zt||g|jtd�}Wn�ty�}z�t|��8}dd�||g�d|j|d|��f}Wd�n1sx0Yt|d�s�d|_	t
||j|j|j	d��WYd}~n
d}~00|S)N)rTrr�r�r�r�r9r�)
rPr
rTrrryr/r~r�r9r4r7r8)r:r{r\r�r9r�r|r6rrrr``s$
�


��"
,zCodeHandler._run_test_scriptN)rVFFTTF)T)rVFTFTF)rt)rt)rtrVFFF)r=r>r?r@rUrcrmrerqrsr]r_r^rHrIr`rrrrrDqs*+�

"�
#

�
/�rDz#this test is known to fail on Py2.6cCsts|St�|�Sr5)r�unittest�expectedFailure��funcrrr�expectedFailurePY3sr�cCsts|St�|�Sr5)rr�r�r�rrr�expectedFailurePY26�sr�cCsts|St�|�Sr5)r	r�r�r�rrr�expectedFailurePY27�sr�cCsts|St�|�Sr5)rr�r�r�rrr�expectedFailurePY2�sr��assertRaisesRegexcCsTt|ttf�r$|sJd��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)rf�str�unicode�re�compile�search�pattern�failureException)r:�text�expected_regexr6rrr�assertRegex�s

r�c@s&eZdZddd�Zdd�Zdd�ZdS)	�_AssertRaisesBaseContextNcCsn||_||_|dur@z|j|_WqFty<t|�|_YqF0nd|_t|ttf�r^t�	|�}||_
d|_dSr5)rk�	test_caser=�obj_name�AttributeErrorr�rfrgr�r�r�r6)r:rkr��callable_objr�rrrr;�s
z!_AssertRaisesBaseContext.__init__cCs |j�|j|�}|j�|��dSr5)r�Z_formatMessager6r�)r:ZstandardMsgr6rrr�
_raiseFailure�sz&_AssertRaisesBaseContext._raiseFailurecCsP|dur|�dd�|_|S|�||i|��Wd�n1sB0YdS)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.
        Nr6)�popr6)r:�namer��argsrrrrr�handle�s
z_AssertRaisesBaseContext.handle)NN)r=r>r?r;r�r�rrrrr��s
�
r�c@s eZdZdZdd�Zdd�ZdS)�_AssertWarnsContextzBA context manager used to implement TestCase.assertWarns* methods.cCsNtj��D]}t|dd�r
i|_q
tjdd�|_|j��|_t�	d|j
�|S)N�__warningregistry__T)�record�always)rH�modules�values�getattrr��warnings�catch_warnings�warnings_manager�	__enter__�simplefilterrk)r:�vrrrr��sz_AssertWarnsContext.__enter__cCs�|j�|||�|durdSz|jj}WntyDt|j�}Yn0d}|jD]Z}|j}t||j�shqP|durt|}|j	dur�|j	�
t|��s�qP||_|j|_|j
|_
dS|dur�|�d�|j	jt|���|jr�|�d�||j��n|�d�|��dS)Nz"{}" does not match "{}"z{} not triggered by {}z{} not triggered)r��__exit__rkr=r�r�r��messagerfr�r��warningr{�linenor��formatr�r�)r:�exc_type�	exc_value�tbZexc_nameZfirst_matching�m�wrrrr��s>

��
�z_AssertWarnsContext.__exit__N)r=r>r?r@r�r�rrrrr��sr�cOst|||�}|�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�)r:Zexpected_warningr�r�rr�contextrrrr��sr�)N)N),�
__future__rrrMrKr�rHr�r�rx�textwraprZfuture.utilsrrrrr	Zfuture.moves.subprocessr
rrZ	unittest2rr3r4rArCZTestCaserDZskipIfZskip26r�r�r�r�r�ZassertRaisesRegexpr�r��objectr�r�r�rrrr�<module>sF	@


"1