U
ʗReZ4 @ sB d dl mZ d dlZddlmZmZmZmZmZ G dd dZ dS ) )contextmanagerN )
ParserElementParseExceptionKeyword__diag__
__compat__c @ sf e Zd ZdZG dd dZG dd dZed eej e
ej e
e eej e ej e ed d
d 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_contextself r /builddir/build/BUILDROOT/alt-python38-pip-22.2.1-2.el8.x86_64/opt/alt/python38/lib/python3.8/site-packages/pip/_vendor/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 jrRt jj | jd< n
d | jd< t j
| jd< t j | jd< d d
t j
D | jd < d tji| jd
< | S )Ndefault_whitespacedefault_keyword_charsliteral_string_classverbose_stacktracepackrat_enabledpackrat_cache_size
packrat_parserecursion_enabledc S s i | ]}|t t|qS r )getattrr ).0namer r r
F s z?pyparsing_test.reset_pyparsing_context.save..r collect_all_And_tokensr )r DEFAULT_WHITE_CHARSr r DEFAULT_KEYWORD_CHARS_literalStringClassr _packratEnabled
packrat_cachesize_parse_left_recursion_enabledr
_all_namesr r r r r r save0 s4
z+pyparsing_test.reset_pyparsing_context.savec C s t j| jd kr t | jd | jd t _| jd t_t | jd | jd D ] \}}|rht j
nt j | qVdt _ | jd rt
| 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 inlineLiteralsUsingitemsr enabledisabler! enable_packratr$ r% r r )r
r valuer r r restoreP s.
z.pyparsing_test.reset_pyparsing_context.restorec C s t | }|j| j |S r
)typer update)r
retr r r copyq s
z+pyparsing_test.reset_pyparsing_context.copyc C s | S r
)r' r r r r __enter__v s z0pyparsing_test.reset_pyparsing_context.__enter__c G s | d S r
)r/ )r
argsr r r __exit__y 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 @ sJ e Zd ZdZdddZdddZddd Zdd
d Zee dfd d
Z
dS )z&pyparsing_test.TestParseResultsAssertszk
A mixin class to add parse results assertion methods to normal unittest.TestCase classes.
Nc C s< |dk r | j || |d |dk r8| j || |d 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``.
Nmsg) assertEqualas_listas_dict)r
result
expected_list
expected_dictr= r r r assertParseResultsEquals s z?pyparsing_test.TestParseResultsAsserts.assertParseResultsEqualsTc C s@ |j |dd}|r t| n t| | 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_stringprintdumpr? rD )r
expr test_stringrB r= verboserA r r r assertParseAndCheckList s
z>pyparsing_test.TestParseResultsAsserts.assertParseAndCheckListc C s@ |j |dd}|r t| n t| | j|||d dS )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= NrF )r
rJ rK rC r= rL rA r r r assertParseAndCheckDict s
z>pyparsing_test.TestParseResultsAsserts.assertParseAndCheckDictc
C s
|\}}|dk rdd t ||D }|D ]\}}} tdd | D d}
tdd | D d} | dk r| j| |
pn|d t|tr|W 5 Q R X q(tdd | D d} td d | D d}
| |
fd
kr| j|| |
|
p|d q(td | q(| j||dk r|nd
d 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)]
Nc S s g | ]\}}||fqS r r )r rptexpectedr r r
s zOpyparsing_test.TestParseResultsAsserts.assertRunTestResults..c s s | ]}t |tr|V qd S r
)
isinstancestrr expr r r s
zNpyparsing_test.TestParseResultsAsserts.assertRunTestResults..c s s& | ] }t |trt|tr|V qd S r
)rS r0
issubclass ExceptionrU r r r rW s
)expected_exceptionr= c s s | ]}t |tr|V qd S r
)rS listrU r r r rW s
c s s | ]}t |tr|V qd S r
)rS dictrU r r r rW s
)NN)rB rC r= zno validation for {!r}zfailed runTestsr< ) zipnext assertRaisesrS rY rD rH format
assertTrue)r
run_tests_reportexpected_parse_resultsr= run_test_successrun_test_resultsmergedrK rA rQ fail_msgrZ rB rC r r r assertRunTestResults sV
z;pyparsing_test.TestParseResultsAsserts.assertRunTestResultsc c s$ | j ||d d V W 5 Q R X d S )Nr< )r_ )r
exc_typer= r r r assertRaisesParseException s zApyparsing_test.TestParseResultsAsserts.assertRaisesParseException)NNN)NT)NT)NN) r7 r8 r9 r: rD rM rO rh r r rj r r r r TestParseResultsAsserts| s
?rk NT|)s
start_lineend_line expand_tabseol_mark mark_spaces mark_controlreturnc s |r | } dk rdkrPtdd ttddtddD d d
iB }d n(tfd dttdd
d g D }| |} |dk r|dkr|dkrtddd}| |} n | d|} |dkrd}|dkrt| }t |t| }t t
d||}dkr | |d | }n dd | d|d | D }|sFd S tt|t
dd |D } dd }
| dkr|
d
dd tt
| d dD d } nd } | |
d
d d t| d D d } |
d | d d }
| |
d
fd dt||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.)
: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
:return: str - input string with leading line numbers and column number headers
Nunicodec S s i | ]\}}||qS r r )r cur r r r s z4pyparsing_test.with_line_numbers..r ! i $ i3$ i!$ c s i | ]
}| qS r r )r rv )rs r r r s i $ i#$ ) r{ r c S s g | ] }|d qS ) ␊r r liner r r rR ' s z4pyparsing_test.with_line_numbers..r~ c s s | ]}t |V qd S r
)lenr r r r rW , s z3pyparsing_test.with_line_numbers..c c s s" | ]}d d|d d V qdS )z{}{}zc r d Nr` r ir r r rW 1 s r
c s s | ]}d |d d V qdS )z {}r
Nr r r r r rW < s r
1234567890c 3 s" | ]\}}d || V qdS )z {:{}d}:{}{}Nr )r r r )rq lineno_widthr r rW F s )start)
expandtabsrT maketransr] ranger[ translatereplacer minmax
splitlinessplitjoin enumerate)rm rn ro rp rq rr rs tbls_lines max_line_lenleadheader0header1header2r )rq r rs r with_line_numbers s
z pyparsing_test.with_line_numbers)NNTrl NN)
r7 r8 r9 r: r; rk staticmethodrT typingOptionalintboolr r r r r r s( hq r )
contextlibr r corer r r r r r r r r r s