a
    .PÎj\<  ã                   @   s^   d dl mZ d dlZd dlZd dlZddlmZmZmZm	Z	m
Z
 ddlmZ G dd„ dƒZdS )é    )ÚcontextmanagerNé   )ÚParserElementÚParseExceptionÚKeywordÚ__diag__Ú
__compat__)Úcore_builtin_exprsc                   @   s€   e Zd ZdZG dd„ dƒZG dd„ dejƒZedd	dd
œe	e
je e
je ee	e
je	 e
je	 e
je	ef ee	dœ
dd„ƒZdS )Úpyparsing_testzB
    namespace class for classes useful in writing unit tests
    c                   @   s@   e Zd ZdZdd„ Zdd„ Zdd„ Zdd	„ Zd
d„ Zdd„ Z	dS )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:

        .. testcode::

            ppt = pyparsing.pyparsing_test

            class MyTestClass(ppt.TestParseResultsAsserts):
                def test_literal(self):
                    with ppt.reset_pyparsing_context():
                        # test that literals used to construct
                        # a grammar are automatically suppressed
                        ParserElement.inline_literals_using(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   úa/mounts/lovelace/software/anaconda3/envs/metadmg/lib/python3.9/site-packages/pyparsing/testing.pyÚ__init__>   s    z/pyparsing_test.reset_pyparsing_context.__init__c                 C   sž   t j| jd< tj| jd< t j| jd< t j| jd< t j| jd< t jrRt jj	| jd< n
d | jd< t j
| jd< t j| jd< d	d
„ tjD ƒ| jd< dtji| jd< | 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|ƒ“qS r   )Úgetattrr   )Ú.0Únamer   r   r   Ú
<dictcomp>W   s   z?pyparsing_test.reset_pyparsing_context.save.<locals>.<dictcomp>r   Úcollect_all_And_tokensr   )r   ÚDEFAULT_WHITE_CHARSr   r   ÚDEFAULT_KEYWORD_CHARSZ_literalStringClassr   Ú_packratEnabledZpackrat_cacheÚsizeÚ_parseÚ_left_recursion_enabledr   Z
_all_namesr   r   r   r   r   r   ÚsaveA   s&    ÿÿ

ÿÿÿ
z+pyparsing_test.reset_pyparsing_context.savec                 C   sÒ   t j| jd kr t  | jd ¡ | jd t _| jd t_t  | jd ¡ | jd  ¡ D ]\}}|rht	j
nt	j|ƒ qVdt _| jd r–t  | jd ¡ n| jd	 t _| jd
 t _tD ]}| d¡ q²| jd t_| S )Nr   r   r   r   r   Fr   r   r   r   r   )r   r   r   Zset_default_whitespace_charsr   r   r    Zinline_literals_usingÚitemsr   ÚenableÚdisabler!   Zenable_packratr#   r$   r	   Z	set_debugr   r   )r   r   ÚvalueÚexprr   r   r   Úrestorea   s2    ÿÿÿÿ
ÿz.pyparsing_test.reset_pyparsing_context.restorec                 C   s   t | ƒƒ }|j | j¡ |S r   )Útyper   Úupdate)r   Úretr   r   r   Úcopy†   s    
z+pyparsing_test.reset_pyparsing_context.copyc                 C   s   |   ¡ S r   )r%   r   r   r   r   Ú	__enter__‹   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+   r/   r0   r2   r   r   r   r   Úreset_pyparsing_context   s   % %r7   c                   @   sL   e Zd ZdZddd„Zddd„Zddd	„Zdd
d„Zee	ddfdd„ƒZ
dS )z&pyparsing_test.TestParseResultsAssertszk
        A mixin class to add parse results assertion methods to normal unittest.TestCase classes.
        Nc                 C   s<   |dur| j || ¡ |d� |dur8| j || ¡ |d� dS )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)ZassertEqualÚas_listÚas_dict)r   ÚresultÚexpected_listÚexpected_dictr9   r   r   r   ÚassertParseResultsEquals–   s    z?pyparsing_test.TestParseResultsAsserts.assertParseResultsEqualsTc                 C   s@   |j |dd�}|r t| ¡ ƒ nt| ¡ ƒ | j|||d� dS )zÉ
            Convenience wrapper assert to test a parser element and input string, and assert that
            the resulting :meth:`ParseResults.as_list` is equal to the ``expected_list``.
            T©Z	parse_all)r=   r9   N©Úparse_stringÚprintÚdumpr:   r?   )r   r*   Útest_stringr=   r9   Úverboser<   r   r   r   ÚassertParseAndCheckList¢   s
    z>pyparsing_test.TestParseResultsAsserts.assertParseAndCheckListc                 C   s@   |j |dd�}|r t| ¡ ƒ nt| ¡ ƒ | j|||d� dS )zÉ
            Convenience wrapper assert to test a parser element and input string, and assert that
            the resulting :meth:`ParseResults.as_dict` is equal to the ``expected_dict``.
            Tr@   )r>   r9   NrA   )r   r*   rE   r>   r9   rF   r<   r   r   r   ÚassertParseAndCheckDict°   s
    z>pyparsing_test.TestParseResultsAsserts.assertParseAndCheckDictc              	   C   sB  |\}}|du r.| j ||dur"|ndd� dS dd„ t||ƒD ƒ}|D ]Ú\}}}	tdd„ |	D ƒdƒ}
tdd„ |	D ƒdƒ}|durÂ| j||
pŒ|d	�� t|tƒr¢|‚W d  ƒ n1 s¶0    Y  qFtd
d„ |	D ƒdƒ}tdd„ |	D ƒdƒ}||fdk�r| j||||
�p
|d� qFtd|›�ƒ qF| j ||du�r6|ndd� dS )a2  
            Unit test assertion to evaluate output of
            :meth:`~ParserElement.run_tests`.

            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 ``run_tests()``
            and evaluated using :meth:`assertParseResultsEquals`.
            Finally, asserts that the overall
            `:meth:~ParserElement.run_tests` success value is ``True``.

            :param run_tests_report: the return value from :meth:`ParserElement.run_tests`
            :type run_tests_report: tuple[bool, list[tuple[str, ParseResults | Exception]]]
            :param expected_parse_results: (optional)
            :type expected_parse_results: list[tuple[str | list | dict | Exception, ...]]
            Nzfailed runTestsr8   c                 S   s   g | ]\}}g |¢|‘R ‘qS r   r   )r   ZrptÚexpectedr   r   r   Ú
<listcomp>Ù   s   ÿzOpyparsing_test.TestParseResultsAsserts.assertRunTestResults.<locals>.<listcomp>c                 s   s   | ]}t |tƒr|V  qd S r   )Ú
isinstanceÚstr©r   Úexpr   r   r   Ú	<genexpr>á   ó    zNpyparsing_test.TestParseResultsAsserts.assertRunTestResults.<locals>.<genexpr>c                 s   s&   | ]}t |tƒrt|tƒr|V  qd S r   )rK   r,   Ú
issubclassÚ	ExceptionrM   r   r   r   rO   ã   s   þ)Úexpected_exceptionr9   c                 s   s   | ]}t |tƒr|V  qd S r   )rK   ÚlistrM   r   r   r   rO   ò   rP   c                 s   s   | ]}t |tƒr|V  qd S r   )rK   ÚdictrM   r   r   r   rO   õ   rP   )NN)r=   r>   r9   zno validation for )Z
assertTrueÚzipÚnextÚassertRaisesrK   rR   r?   rC   )r   Zrun_tests_reportZexpected_parse_resultsr9   Zrun_test_successZrun_test_resultsZmergedrE   r<   rI   Zfail_msgrS   r=   r>   r   r   r   ÚassertRunTestResults¾   sP    ÿþþúÿ
$ÿÿüÿz;pyparsing_test.TestParseResultsAsserts.assertRunTestResultsc                 c   sŒ   |d urTt |tƒrt |¡}| j|||d��}|V  W d   ƒ qˆ1 sH0    Y  n4| j||d��}|V  W d   ƒ n1 s~0    Y  d S )Nr8   )rK   rL   ÚreÚescapeÚassertRaisesRegexrX   )r   Úexc_typeZexpected_msgr9   Úctxr   r   r   ÚassertRaisesParseException  s    

&zApyparsing_test.TestParseResultsAsserts.assertRaisesParseException)NNN)NT)NT)NN)r3   r4   r5   r6   r?   rG   rH   rY   r   r   r_   r   r   r   r   ÚTestParseResultsAsserts‘   s    ÿ
 ÿ
 ÿ
 ÿ
Iÿr`   NTú|Ú )ÚindentÚbase_1)
ÚsÚ
start_lineÚend_lineÚexpand_tabsÚeol_markÚmark_spacesÚmark_controlrc   rd   Úreturnc                   s¢  |r|   ¡ } tˆtƒrdˆ ‰ˆ  ¡ ‰|dur´t t|¡}|dkrzdd„ ttddƒtdd	ƒƒD ƒ}	d
|	d< t |	¡}
d‰ n0t	|ƒ‰t ‡fdd„t
tddƒƒdg D ƒ¡}
|  |
¡} |durô|dkrô|dkrèt dddœ¡}
|  |
¡} n|  d|¡} |du �rd}|du �rt|  ¡ ƒ}t|t|  ¡ ƒƒ}ttd|ƒ|ƒ}|dk�r`|  ¡ t|| dƒ|… }n&dd„ |  d¡t|| dƒ|… D ƒ}|�s�dS tt|ƒƒ‰tdd„ |D ƒƒ}ˆ› dˆd  › �}|dk�r||�rØdnd d dd„ tt|d dƒƒD ƒ¡ d }nd}|�rdnd| d dd„ t| d  ƒD ƒ¡ d }d}||�rPdnd || d    d }|| | d ‡ ‡‡fd 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: string to be printed with line and column numbers
        :param start_line: starting line number in s to print (default=1)
        :param end_line: ending line number in s to print (default=len(s))
        :param expand_tabs: expand tabs to spaces, to match the pyparsing default
        :param eol_mark: string to mark the end of lines, helps visualize trailing spaces
        :param mark_spaces: special character to display in place of spaces
        :param mark_control: 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: string to indent with line and column numbers; if an int
                       is passed, converted to ``" " * indent``
        :param base_1: whether to label string using base 1; if False, string will be
                       labeled based at 0

        :returns: input string with leading line numbers and column number headers

        .. versionchanged:: 3.2.0
           New ``indent`` and ``base_1`` arguments.
        ú NÚunicodec                 S   s   i | ]\}}||“qS r   r   )r   ÚcÚur   r   r   r   G  s   z4pyparsing_test.with_line_numbers.<locals>.<dictcomp>r   é!   i $  i3$  i!$  é   rb   c                    s   i | ]
}|ˆ “qS r   r   )r   ro   )Úord_mark_controlr   r   r   P  rP   é    i	$  i#$  )é	   rt   c                 S   s   g | ]}|d  ‘qS )õ   â�Šr   ©r   Úliner   r   r   rJ   c  s   ÿz4pyparsing_test.with_line_numbers.<locals>.<listcomp>rv   c                 s   s   | ]}t |ƒV  qd S r   )Úlenrw   r   r   r   rO   k  rP   z3pyparsing_test.with_line_numbers.<locals>.<genexpr>r   éc   c                 s   s"   | ]}d › |d d › �V  qdS )zc                                                                                                   r   éd   Nr   ©r   Úir   r   r   rO   r  s   ÿr{   Ú
c                 s   s    | ]}d |d d › �V  qdS )z	         r   é
   Nr   r|   r   r   r   rO   ~  rP   r   Z
1234567890Ú0c                 3   s0   | ](\}}ˆ› |ˆ› d �›d|› ˆ › �V  qdS )Údú:Nr   )r   r}   rx   )ri   rc   Úlineno_widthr   r   rO   ‰  s   ÿ)Ústart)Ú
expandtabsrK   ÚintÚtypingÚcastrL   rV   ÚrangeÚ	maketransÚordrT   Ú	translateÚreplacery   Ú
splitlinesÚminÚmaxÚsplitÚjoinÚ	enumerate)re   rf   rg   rh   ri   rj   rk   rc   rd   Ztranstable_mapZtblZs_linesZmax_line_lenZleadZheader0Zheader1ÚdigitsZheader2r   )ri   rc   rƒ   rs   r   Úwith_line_numbers  s–    *
ÿ
 ÿ



þ
ÿ
þþúÿ
ÿþýÿ$ÿÿþþýùÿz pyparsing_test.with_line_numbers)NNTra   NN)r3   r4   r5   r6   r7   ÚunittestZTestCaser`   ÚstaticmethodrL   r‡   ÚOptionalr†   ÚboolÚUnionr•   r   r   r   r   r
      s4   y       ù	öõr
   )Ú
contextlibr   rZ   r‡   r–   Úcorer   r   r   r   r   rb   r	   r
   r   r   r   r   Ú<module>   s   