File: //usr/local/CyberPanel/lib64/python3.10/site-packages/pyparsing/__pycache__/testing.cpython-310.pyc
o
��hZ9 � @ sJ d dl mZ d dlZd dlZddlmZmZmZmZm Z G dd� d�Z
dS )� )�contextmanagerN� )�
ParserElement�ParseException�Keyword�__diag__�
__compat__c @ s� e Zd ZdZG dd� d�ZG dd� d�Ze dd dd
�d ed ej e
d
ej e
de dedej e dej e dej ee
f de defdd��Z
dS )�pyparsing_testzB
namespace class for classes useful in writing unit tests
c @ s@ e Zd ZdZdd� Zdd� Zdd� Zdd � Zd
d � Zd d
� Z dS )z&pyparsing_test.reset_pyparsing_contexta�
Context manager to be used when writing unit tests that modify pyparsing config values:
- packrat parsing
- bounded recursion parsing
- default whitespace characters.
- default keyword characters
- literal string auto-conversion class
- __diag__ settings
Example::
with reset_pyparsing_context():
# test that literals used to construct a grammar are automatically suppressed
ParserElement.inlineLiteralsUsing(Suppress)
term = Word(alphas) | Word(nums)
group = Group('(' + term[...] + ')')
# assert that the '()' characters are not included in the parsed tokens
self.assertParseAndCheckList(group, "(abc 123 def)", ['abc', '123', 'def'])
# after exiting context manager, literals are converted to Literal expressions again
c C s
i | _ d S �N)�
_save_context��self� r �G/usr/local/CyberPanel/lib/python3.10/site-packages/pyparsing/testing.py�__init__/ s
z/pyparsing_test.reset_pyparsing_context.__init__c C s� t j| jd< tj| jd< t j| jd< t j| jd< t j| jd< t jr)t jj | jd< nd | jd< t j
| jd< t j | jd< d d
� t j
D �| jd < d tji| jd
< | S )N�default_whitespace�default_keyword_chars�literal_string_class�verbose_stacktrace�packrat_enabled�packrat_cache_size�
packrat_parse�recursion_enabledc S s i | ]}|t t|��qS r )�getattrr )�.0�namer r r �
<dictcomp>H s �z?pyparsing_test.reset_pyparsing_context.save.<locals>.<dictcomp>r �collect_all_And_tokensr )r �DEFAULT_WHITE_CHARSr r �DEFAULT_KEYWORD_CHARS�_literalStringClassr �_packratEnabled�
packrat_cache�size�_parse�_left_recursion_enabledr �
_all_namesr r r r r r �save2 s& �
�
� �
�z+pyparsing_test.reset_pyparsing_context.savec C s� t j| jd krt �| jd � | jd t _| jd t_t �| jd � | jd �� D ]\}}|r4t j
nt j |� q+dt _ | jd rKt �
| jd � n| jd t _| jd
t _| jd t_| S ) Nr r r r r Fr r r r r )r r r � set_default_whitespace_charsr r r �inlineLiteralsUsing�itemsr �enable�disabler! �enable_packratr$ r% r r )r
r �valuer r r �restoreR s, �� �
� z.pyparsing_test.reset_pyparsing_context.restorec C s t | �� }|j�| j� |S r
)�typer �update)r
�retr r r �copys s
z+pyparsing_test.reset_pyparsing_context.copyc C s | � � S r
)r' r r r r � __enter__x s z0pyparsing_test.reset_pyparsing_context.__enter__c G s | � � d S r
)r/ )r
�argsr r r �__exit__{ s z/pyparsing_test.reset_pyparsing_context.__exit__N)
�__name__�
__module__� __qualname__�__doc__r r' r/ r3 r4 r6 r r r r �reset_pyparsing_context s ! r; c @ sT e Zd ZdZ ddd�Z ddd�Z ddd �Z dd
d �Zee ddfd d
��Z
dS )z&pyparsing_test.TestParseResultsAssertszk
A mixin class to add parse results assertion methods to normal unittest.TestCase classes.
Nc C s@ |dur| j ||�� |d� |dur | j ||�� |d� dS dS )z�
Unit test assertion to compare a :class:`ParseResults` object with an optional ``expected_list``,
and compare any defined results names with an optional ``expected_dict``.
N��msg)� assertEqual�as_list�as_dict)r
�result�
expected_list�
expected_dictr= r r r �assertParseResultsEquals� s
�z?pyparsing_test.TestParseResultsAsserts.assertParseResultsEqualsTc C �@ |j |dd�}|rt|�� � nt|�� � | j|||d� dS )z�
Convenience wrapper assert to test a parser element and input string, and assert that
the resulting ``ParseResults.asList()`` is equal to the ``expected_list``.
T)� parse_all)rB r= N�� parse_string�print�dumpr? rD )r
�expr� test_stringrB r= �verboserA r r r �assertParseAndCheckList� �
z>pyparsing_test.TestParseResultsAsserts.assertParseAndCheckListc C rE )z�
Convenience wrapper assert to test a parser element and input string, and assert that
the resulting ``ParseResults.asDict()`` is equal to the ``expected_dict``.
T)�parseAll)rC r= NrG )r
rK rL rC r= rM rA r r r �assertParseAndCheckDict� rO z>pyparsing_test.TestParseResultsAsserts.assertParseAndCheckDictc C s< |\}}|du r| j ||dur|ndd� dS dd� t||�D �}|D ]k\}}} tdd� | D �d�}
tdd� | D �d�} | dura| j| |
pF|d �� t|t�rQ|�W d � n1 s[w Y q#td
d� | D �d�} td d� | D �d�}
| |
fd kr�| j|| |
|
p�|d
� q#td|��� q#| j ||dur�|ndd� dS )ah
Unit test assertion to evaluate output of ``ParserElement.runTests()``. If a list of
list-dict tuples is given as the ``expected_parse_results`` argument, then these are zipped
with the report tuples returned by ``runTests`` and evaluated using ``assertParseResultsEquals``.
Finally, asserts that the overall ``runTests()`` success value is ``True``.
:param run_tests_report: tuple(bool, [tuple(str, ParseResults or Exception)]) returned from runTests
:param expected_parse_results (optional): [tuple(str, list, dict, Exception)]
Nzfailed runTestsr< c S s g | ] \}}g |�|�R �qS r r )r �rpt�expectedr r r �
<listcomp>� s ��zOpyparsing_test.TestParseResultsAsserts.assertRunTestResults.<locals>.<listcomp>c s � � | ]
}t |t�r|V qd S r
)�
isinstance�str�r �expr r r � <genexpr>� � � zNpyparsing_test.TestParseResultsAsserts.assertRunTestResults.<locals>.<genexpr>c s s( � | ]}t |t�rt|t�r|V qd S r
)rV r0 �
issubclass� ExceptionrX r r r rZ � s � ��
�)�expected_exceptionr= c s rU r
)rV �listrX r r r rZ � r[ c s rU r
)rV �dictrX r r r rZ � r[ �NN)rB rC r= zno validation for )�
assertTrue�zip�next� assertRaisesrV r] rD rI )r
�run_tests_report�expected_parse_resultsr= �run_test_success�run_test_results�mergedrL rA rS �fail_msgr^ rB rC r r r �assertRunTestResults� sV �����
� ���� �
�z;pyparsing_test.TestParseResultsAsserts.assertRunTestResultsc c s� � |d ur-t |t�rt�|�}| j|||d�� }|V W d � d S 1 s&w Y d S | j||d�� }|V W d � d S 1 sCw Y d S )Nr< )rV rW �re�escape�assertRaisesRegexre )r
�exc_type� expected_msgr= �ctxr r r �assertRaisesParseException� s �
"�"�zApyparsing_test.TestParseResultsAsserts.assertRaisesParseException)NNN)NTra ) r7 r8 r9 r: rD rN rQ rl r r rs r r r r �TestParseResultsAsserts~ s
�
�
�
�B�rt NT�|� )�indent�base_1�s�
start_line�end_line� expand_tabs�eol_mark� mark_spaces� mark_controlrw rx �returnc s� |r| � � } t�t�rd� ��� � �|durZt�t|�}|dkr=dd� ttdd�tdd ��D �} d
| d < t�| �}
d � nt |��t��fd
d�t
tdd��d g D ��}
| � |
�} |durz|dkrz|dkrtt�ddd��}
| � |
�} n| � d|�} |du r�d}|du r�t
| �}t|t
| ��}ttd|�|�}|dkr�| �� || |� } ndd� | �d�|| |� D �} | s�d S t
t|���tdd� | D ��} �d�d }
| dkr�|
|r�d nd d �dd� t|r�dndt| d d��D �� d }nd }|r�d nd|
d �d d� t| d �D �� d }d }|
|�rd nd || d d }|| d�� ��fd d�t| || d!�D �� d S )"u�
Helpful method for debugging a parser - prints a string with line and column numbers.
(Line and column numbers are 1-based by default - if debugging a parse action,
pass base_1=False, to correspond to the loc value passed to the parse action.)
:param s: tuple(bool, str - string to be printed with line and column numbers
:param start_line: int - (optional) starting line number in s to print (default=1)
:param end_line: int - (optional) ending line number in s to print (default=len(s))
:param expand_tabs: bool - (optional) expand tabs to spaces, to match the pyparsing default
:param eol_mark: str - (optional) string to mark the end of lines, helps visualize trailing spaces (default="|")
:param mark_spaces: str - (optional) special character to display in place of spaces
:param mark_control: str - (optional) convert non-printing control characters to a placeholding
character; valid values:
- "unicode" - replaces control chars with Unicode symbols, such as "␍" and "␊"
- any single character string - replace control characters with given string
- None (default) - string is displayed as-is
:param indent: str | int - (optional) string to indent with line and column numbers; if an int
is passed, converted to " " * indent
:param base_1: bool - (optional) whether to label string using base 1; if False, string will be
labeled based at 0 (default=True)
:return: str - input string with leading line numbers and column number headers
� N�unicodec S s i | ]\}}||�qS r r )r �c�ur r r r ' s
�z4pyparsing_test.with_line_numbers.<locals>.<dictcomp>r �! i $ i3$ i!$ � rv c s i | ]}|� �qS r r )r r� )�ord_mark_controlr r r 0 s � i $ i#$ )� r� c S s g | ]}|d �qS )� ␊r �r �liner r r rT C s �z4pyparsing_test.with_line_numbers.<locals>.<listcomp>r� c s s � | ]}t |�V qd S r
)�lenr� r r r rZ J s � z3pyparsing_test.with_line_numbers.<locals>.<genexpr>r �c c s s$ � | ]
}d � |d d � �V qdS )zc r �d Nr �r �ir r r rZ P s
� �
�r� �
c s s" � | ] }d |d d � �V qdS )z r �
Nr r� r r r rZ [ s � r� �
1234567890�0c 3 s2 � | ]\}}�� |�� d ��d|� � � �V qdS )�d�:Nr )r r� r� )r} rw � lineno_widthr r rZ e s
� �
�)�start)�
expandtabsrV �int�typing�castrW rc �range� maketrans�ordr_ � translate�replacer� �min�max�
splitlines�split�join� enumerate)ry rz r{ r| r} r~ r rw rx �transtable_map�tbl�s_lines� max_line_len�lead�header0�header1�digits�header2r )r} rw r� r� r �with_line_numbers� s� $
�
�
�
�
����
� ���$������z pyparsing_test.with_line_numbers)NNTru NN)r7 r8 r9 r: r; rt � staticmethodrW r� �Optionalr� �bool�Unionr� r r r r r sF h}� �������� �
� �r ) �
contextlibr rm r� �corer r r r r r r r r r �<module> s