3
db                 @   s   U d dl mZmZmZmZ d dlZd dlmZ d dl	m
Z
mZ eefZe
edf edd f D ZG dd	 d	ZG d
d dZeje eje dS )    )MutableMappingMappingMutableSequenceIteratorN)ref)TupleAny.c             c   s   | ]
}|V  qd S )N ).0_r	   r	   6/tmp/pip-build-7vycvbft/pyparsing/pyparsing/results.py	<genexpr>   s    r   c               @   s2   e Zd ZdgZdd Zdd Zdd Zdd	 Zd
S )_ParseResultsWithOffsettupc             C   s   ||f| _ d S )N)r   )selfp1p2r	   r	   r   __init__   s    z _ParseResultsWithOffset.__init__c             C   s
   | j | S )N)r   )r   ir	   r	   r   __getitem__   s    z#_ParseResultsWithOffset.__getitem__c             C   s   | j S )N)r   )r   r	   r	   r   __getstate__   s    z$_ParseResultsWithOffset.__getstate__c             G   s   |d | _ d S )Nr   )r   )r   argsr	   r	   r   __setstate__   s    z$_ParseResultsWithOffset.__setstate__N)__name__
__module____qualname__	__slots__r   r   r   r   r	   r	   r	   r   r      s
   r   c               @   s  e Zd ZU dZdg df fZeedf ddddd	d
dgZG dd deZ	d]ddZ
ddddefddZdd ZefddZdd ZedddZedddZedddZedd d!Zedd"d#Zd$d% Zd&d' Zd(d) Zedd*d+Zd,d- Zd^d.d/Zd0d1 Zd2d3 Zd4d5 Z d6d7 Z!d8d9 Z"d dd:d;Z#d dd<d=Z$d dd>d?Z%e&dd@dAZ'e&ddBdCZ(d_dDdEZ)eddFdGZ*e+ddHdIZ,d ddJdKZ-dLdM Z.d`e&ddOdPZ/dQdR Z0dSdT Z1dUdV Z2dWdX Z3dYdZ Z4e5dad dd[d\Z6e*Z7e,Z8e.Z9dS )bParseResultsa  Structured parse results, to provide multiple means of access to
    the parsed data:

    - as a list (``len(results)``)
    - by list index (``results[0], results[1]``, etc.)
    - by attribute (``results.<results_name>`` - see :class:`ParserElement.set_results_name`)

    Example::

        integer = Word(nums)
        date_str = (integer.set_results_name("year") + '/'
                    + integer.set_results_name("month") + '/'
                    + integer.set_results_name("day"))
        # equivalent form:
        # date_str = (integer("year") + '/'
        #             + integer("month") + '/'
        #             + integer("day"))

        # parse_string returns a ParseResults object
        result = date_str.parse_string("1999/12/31")

        def test(s, fn=repr):
            print("{} -> {}".format(s, fn(eval(s))))
        test("list(result)")
        test("result[0]")
        test("result['month']")
        test("result.day")
        test("'month' in result")
        test("'minutes' in result")
        test("result.dump()", str)

    prints::

        list(result) -> ['1999', '/', '12', '/', '31']
        result[0] -> '1999'
        result['month'] -> '12'
        result.day -> '31'
        'month' in result -> True
        'minutes' in result -> False
        result.dump() -> ['1999', '/', '12', '/', '31']
        - day: '31'
        - month: '12'
        - year: '1999'
    N ._name_parent
_all_names_modal_toklist_tokdict__weakref__c               @   s   e Zd ZdZdddZdS )zParseResults.Lista  
        Simple wrapper class to distinguish parsed list results that should be preserved
        as actual Python lists, instead of being converted to :class:`ParseResults`:

            LBRACK, RBRACK = map(pp.Suppress, "[]")
            element = pp.Forward()
            item = ppc.integer
            element_list = LBRACK + pp.delimited_list(element) + RBRACK

            # add parse actions to convert from ParseResults to actual Python collection types
            def as_python_list(t):
                return pp.ParseResults.List(t.as_list())
            element_list.add_parse_action(as_python_list)

            element <<= item | element_list

            element.run_tests('''
                100
                [2,3,4]
                [[2, 1],3,4]
                [(2, 1),3,4]
                (2,3,4)
                ''', post_parse=lambda s, r: (r[0], type(r[0])))

        prints:

            100
            (100, <class 'int'>)

            [2,3,4]
            ([2, 3, 4], <class 'list'>)

            [[2, 1],3,4]
            ([[2, 1], 3, 4], <class 'list'>)

        (Used internally by :class:`Group` when `aslist=True`.)
        Nc             C   s8   |d krg }t |ts.tdj| jt|jtj| S )Nz.{} may only be constructed with a list, not {})
isinstancelist	TypeErrorformatr   type__new__)clsZ	containedr	   r	   r   r+   |   s    
zParseResults.List.__new__)N)r   r   r   __doc__r+   r	   r	   r	   r   ListU   s   %r.   c             K   s   t |tr|S tj| }d |_d |_t |_|d kr<g |_n<t |t	t
frpt |tjrd|d d  gnt	||_n|g|_t |_|S )N)r&   r   objectr+   r   r    setr!   r#   r'   _generator_typer.   dictr$   )r,   toklistnamekwargsr   r	   r	   r   r+      s    

zParseResults.__new__Tc             C   s   || _ |d k	r|dkr||tr(t|}|s4|h| _|| _|| jkr||ttfrX|g}|r||tr|t	t|j
d| |< nt	t|d d| |< || | _nDy|d | |< W n2 tttfk
r   || k	r|| |< n|| _Y nX d S )Nr   r   )r"   intstrr!   r   _null_valuesstr_typer*   r   r   r#   KeyErrorr(   
IndexError)r   r3   r4   asListmodalr&   r	   r	   r   r      s.    



zParseResults.__init__c             C   sP   t |ttfr| j| S || jkr4| j| d d S tdd | j| D S d S )N   r   c             S   s   g | ]}|d  qS )r   r	   )r
   vr	   r	   r   
<listcomp>   s    z,ParseResults.__getitem__.<locals>.<listcomp>)r&   r6   slicer#   r!   r$   r   )r   r   r	   r	   r   r      s
    

zParseResults.__getitem__c             C   s   ||t r0| jj|t |g | j|< |d }nD||ttfrN|| j|< |}n&| jj|t t |dg | j|< |}||trt| |_	d S )Nr   )
r   r$   getr'   r6   rB   r#   r   wkrefr    )r   kr?   r&   subr	   r	   r   __setitem__   s    



zParseResults.__setitem__c       
      C   s   t |ttfrt| j}| j|= t |trH|dk r:||7 }t||d }tt|j| }|j  x^| j	j
 D ]F\}}x<|D ]4}x.t|D ]"\}\}}	t||	|	|k ||< qW q|W qnW n| j	|= d S )Nr   r>   )r&   r6   rB   lenr#   r'   rangeindicesreverser$   items	enumerater   )
r   r   mylenremovedr4   occurrencesjrE   valuepositionr	   r	   r   __delitem__   s    


"zParseResults.__delitem__)returnc             C   s
   || j kS )N)r$   )r   rE   r	   r	   r   __contains__   s    zParseResults.__contains__c             C   s
   t | jS )N)rH   r#   )r   r	   r	   r   __len__   s    zParseResults.__len__c             C   s   | j p
| j  S )N)r#   r$   )r   r	   r	   r   __bool__   s    zParseResults.__bool__c             C   s
   t | jS )N)iterr#   )r   r	   r	   r   __iter__   s    zParseResults.__iter__c             C   s   t | jd d d S )Nr>   rA   )rY   r#   )r   r	   r	   r   __reversed__   s    zParseResults.__reversed__c             C   s
   t | jS )N)rY   r$   )r   r	   r	   r   keys   s    zParseResults.keysc                s    fdd j  D S )Nc             3   s   | ]} | V  qd S )Nr	   )r
   rE   )r   r	   r   r     s    z&ParseResults.values.<locals>.<genexpr>)r\   )r   r	   )r   r   values   s    zParseResults.valuesc                s    fdd j  D S )Nc             3   s   | ]}| | fV  qd S )Nr	   )r
   rE   )r   r	   r   r     s    z%ParseResults.items.<locals>.<genexpr>)r\   )r   r	   )r   r   rL     s    zParseResults.itemsc             C   s
   t | jS )z
        Since ``keys()`` returns an iterator, this method is helpful in bypassing
        code that looks for the existence of any defined results names.)boolr$   )r   r	   r	   r   haskeys  s    zParseResults.haskeysc             O   s   |s
dg}x8|j  D ],\}}|dkr2|d |f}qtdj|qW t|d tsjt|dksj|d | kr|d }| | }| |= |S |d }|S dS )a  
        Removes and returns item at specified index (default= ``last``).
        Supports both ``list`` and ``dict`` semantics for ``pop()``. If
        passed no argument or an integer argument, it will use ``list``
        semantics and pop tokens from the list of parsed tokens. If passed
        a non-integer argument (most likely a string), it will use ``dict``
        semantics and pop the corresponding value from any defined results
        names. A second default return value argument is supported, just as in
        ``dict.pop()``.

        Example::

            numlist = Word(nums)[...]
            print(numlist.parse_string("0 123 321")) # -> ['0', '123', '321']

            def remove_first(tokens):
                tokens.pop(0)
            numlist.add_parse_action(remove_first)
            print(numlist.parse_string("0 123 321")) # -> ['123', '321']

            label = Word(alphas)
            patt = label("LABEL") + Word(nums)[1, ...]
            print(patt.parse_string("AAB 123 321").dump())

            # Use pop() in a parse action to remove named result (note that corresponding value is not
            # removed from list form of results)
            def remove_LABEL(tokens):
                tokens.pop("LABEL")
                return tokens
            patt.add_parse_action(remove_LABEL)
            print(patt.parse_string("AAB 123 321").dump())

        prints::

            ['AAB', '123', '321']
            - LABEL: 'AAB'

            ['AAB', '123', '321']
        r>   defaultr   z-pop() got an unexpected keyword argument {!r}NrA   )rL   r(   r)   r&   r6   rH   )r   r   r5   rE   r?   indexretdefaultvaluer	   r	   r   pop  s    (&zParseResults.popc             C   s   || kr| | S |S dS )a^  
        Returns named result matching the given key, or if there is no
        such name, then returns the given ``default_value`` or ``None`` if no
        ``default_value`` is specified.

        Similar to ``dict.get()``.

        Example::

            integer = Word(nums)
            date_str = integer("year") + '/' + integer("month") + '/' + integer("day")

            result = date_str.parse_string("1999/12/31")
            print(result.get("year")) # -> '1999'
            print(result.get("hour", "not specified")) # -> 'not specified'
            print(result.get("hour")) # -> None
        Nr	   )r   keydefault_valuer	   r	   r   rC   F  s    zParseResults.getc             C   sZ   | j j|| xF| jj D ]8\}}x.t|D ]"\}\}}t||||k ||< q,W qW dS )a;  
        Inserts new element at location index in the list of parsed tokens.

        Similar to ``list.insert()``.

        Example::

            numlist = Word(nums)[...]
            print(numlist.parse_string("0 123 321")) # -> ['0', '123', '321']

            # use a parse action to insert the parse location in the front of the parsed results
            def insert_locn(locn, tokens):
                tokens.insert(0, locn)
            numlist.add_parse_action(insert_locn)
            print(numlist.parse_string("0 123 321")) # -> [0, '0', '123', '321']
        N)r#   insertr$   rL   rM   r   )r   ra   Z
ins_stringr4   rP   rE   rR   rS   r	   r	   r   rg   ]  s
    zParseResults.insertc             C   s   | j j| dS )a  
        Add single element to end of ``ParseResults`` list of elements.

        Example::

            numlist = Word(nums)[...]
            print(numlist.parse_string("0 123 321")) # -> ['0', '123', '321']

            # use a parse action to compute the sum of the parsed integers, and add it to the end
            def append_sum(tokens):
                tokens.append(sum(map(int, tokens)))
            numlist.add_parse_action(append_sum)
            print(numlist.parse_string("0 123 321")) # -> ['0', '123', '321', 444]
        N)r#   append)r   itemr	   r	   r   rh   v  s    zParseResults.appendc             C   s&   t |tr| j| n| jj| dS )a  
        Add sequence of elements to end of ``ParseResults`` list of elements.

        Example::

            patt = Word(alphas)[1, ...]

            # use a parse action to append the reverse of the matched strings, to make a palindrome
            def make_palindrome(tokens):
                tokens.extend(reversed([t[::-1] for t in tokens]))
                return ''.join(tokens)
            patt.add_parse_action(make_palindrome)
            print(patt.parse_string("lskdj sdlkjf lksd")) # -> 'lskdjsdlkjflksddsklfjkldsjdksl'
        N)r&   r   __iadd__r#   extend)r   itemseqr	   r	   r   rk     s    
zParseResults.extendc             C   s   | j dd= | jj  dS )z7
        Clear all elements and results names.
        N)r#   r$   clear)r   r	   r	   r   rm     s    zParseResults.clearc             C   s4   y| | S  t k
r.   |jdr*t|dS X d S )N__r   )r:   
startswithAttributeError)r   r4   r	   r	   r   __getattr__  s    
zParseResults.__getattr__c             C   s   | j  }||7 }|S )N)copy)r   otherrb   r	   r	   r   __add__  s    zParseResults.__add__c                s   |j rnt| jfdd |j j } fdd|D }x4|D ],\}}|| |< t|d tr>t| |d _q>W |  j|j7  _|  j|jO  _| S )Nc                s   | dk r S |   S )Nr   r	   )a)offsetr	   r   <lambda>  s    z'ParseResults.__iadd__.<locals>.<lambda>c          	      s4   g | ],\}}|D ]}|t |d   |d fqqS )r   r>   )r   )r
   rE   vlistr?   )	addoffsetr	   r   r@     s   z)ParseResults.__iadd__.<locals>.<listcomp>r   )	r$   rH   r#   rL   r&   r   rD   r    r!   )r   rs   
otheritemsotherdictitemsrE   r?   r	   )ry   rv   r   rj     s    


zParseResults.__iadd__c             C   s&   t |tr|dkr| j S ||  S d S )Nr   )r&   r6   rr   )r   rs   r	   r	   r   __radd__  s    zParseResults.__radd__c             C   s   dj t| j| j| j S )Nz{}({!r}, {}))r)   r*   r   r#   as_dict)r   r	   r	   r   __repr__  s    zParseResults.__repr__c             C   s   ddj dd | jD  d S )N[z, c             S   s&   g | ]}t |trt|nt|qS r	   )r&   r   r7   repr)r
   r   r	   r	   r   r@     s   z(ParseResults.__str__.<locals>.<listcomp>])joinr#   )r   r	   r	   r   __str__  s    	zParseResults.__str__c             C   sP   g }xF| j D ]<}|r"|r"|j| t|tr:||j 7 }q|jt| qW |S )N)r#   rh   r&   r   _asStringListr7   )r   sepoutri   r	   r	   r   r     s    

zParseResults._asStringListc             C   s   dd | j D S )ax  
        Returns the parse results as a nested list of matching tokens, all converted to strings.

        Example::

            patt = Word(alphas)[1, ...]
            result = patt.parse_string("sldkj lsdkj sldkj")
            # even though the result prints in string-like form, it is actually a pyparsing ParseResults
            print(type(result), result) # -> <class 'pyparsing.ParseResults'> ['sldkj', 'lsdkj', 'sldkj']

            # Use as_list() to create an actual list
            result_list = result.as_list()
            print(type(result_list), result_list) # -> <class 'list'> ['sldkj', 'lsdkj', 'sldkj']
        c             S   s"   g | ]}t |tr|j n|qS r	   )r&   r   as_list)r
   resr	   r	   r   r@     s   z(ParseResults.as_list.<locals>.<listcomp>)r#   )r   r	   r	   r   r     s    zParseResults.as_listc                s&    fdd t  fdd| j D S )a  
        Returns the named parse results as a nested dictionary.

        Example::

            integer = Word(nums)
            date_str = integer("year") + '/' + integer("month") + '/' + integer("day")

            result = date_str.parse_string('12/31/1999')
            print(type(result), repr(result)) # -> <class 'pyparsing.ParseResults'> (['12', '/', '31', '/', '1999'], {'day': [('1999', 4)], 'year': [('12', 0)], 'month': [('31', 2)]})

            result_dict = result.as_dict()
            print(type(result_dict), repr(result_dict)) # -> <class 'dict'> {'day': '1999', 'year': '12', 'month': '31'}

            # even though a ParseResults supports dict-like access, sometime you just need to have a dict
            import json
            print(json.dumps(result)) # -> Exception: TypeError: ... is not JSON serializable
            print(json.dumps(result.as_dict())) # -> {"month": "31", "day": "1999", "year": "12"}
        c                s4   t | tr,| j r| j S  fdd| D S | S d S )Nc                s   g | ]} |qS r	   r	   )r
   r?   )to_itemr	   r   r@     s    z9ParseResults.as_dict.<locals>.to_item.<locals>.<listcomp>)r&   r   r_   r}   )obj)r   r	   r   r     s    
"z%ParseResults.as_dict.<locals>.to_itemc             3   s   | ]\}}| |fV  qd S )Nr	   )r
   rE   r?   )r   r	   r   r     s    z'ParseResults.as_dict.<locals>.<genexpr>)r2   rL   )r   r	   )r   r   r}     s    zParseResults.as_dictc             C   s:   t | j}| jj |_| j|_| j| jO  _| j|_|S )zG
        Returns a new copy of a :class:`ParseResults` object.
        )r   r#   r$   rr   r    r!   r   )r   rb   r	   r	   r   rr     s    
zParseResults.copyc                s   | j r| j S | jr6| j   fdd} r2|| S dS t| dkrt| jdkrtt| jj d d dkrtt| jj S dS dS )a  
        Returns the results name for this token expression. Useful when several
        different expressions might match at a particular location.

        Example::

            integer = Word(nums)
            ssn_expr = Regex(r"\d\d\d-\d\d-\d\d\d\d")
            house_number_expr = Suppress('#') + Word(nums, alphanums)
            user_data = (Group(house_number_expr)("house_number")
                        | Group(ssn_expr)("ssn")
                        | Group(integer)("age"))
            user_info = user_data[1, ...]

            result = user_info.parse_string("22 111-22-3333 #221B")
            for item in result:
                print(item.get_name(), ':', item[0])

        prints::

            age : 22
            ssn : 111-22-3333
            house_number : 221B
        c                s   t  fddjj D d S )Nc             3   s,   | ]$\}}|D ]\}} |kr|V  qqd S )Nr	   )r
   rE   rx   r?   loc)rF   r	   r   r   A  s   z@ParseResults.get_name.<locals>.find_in_parent.<locals>.<genexpr>)nextr$   rL   )rF   )par)rF   r   find_in_parent>  s    
z-ParseResults.get_name.<locals>.find_in_parentNr>   r   rA   )r   rA   )r   r    rH   r$   r   rY   r]   r\   )r   r   r	   )r   r   get_name   s    zParseResults.get_namer   c             C   st  g }d}|j |r |t| j  nd |rj| j rtdd | j D }x|D ]x\}}	|rf|j | |j dj|d| | t|	tr|	r|j |	j	||||d d q|j t|	 qP|j t
|	 qPW td	d | D rj| }	xt|	D ]x\}
}t|tr<|j d
j|d| |
|d|d  |j	||||d d q|j d|d| |
|d|d  t|f  qW dj|S )aM  
        Diagnostic method for listing out the contents of
        a :class:`ParseResults`. Accepts an optional ``indent`` argument so
        that this string can be embedded in a nested display of other data.

        Example::

            integer = Word(nums)
            date_str = integer("year") + '/' + integer("month") + '/' + integer("day")

            result = date_str.parse_string('1999/12/31')
            print(result.dump())

        prints::

            ['1999', '/', '12', '/', '31']
            - day: '31'
            - month: '12'
            - year: '1999'
        
r   c             s   s   | ]\}}t ||fV  qd S )N)r7   )r
   rE   r?   r	   r	   r   r   n  s    z$ParseResults.dump.<locals>.<genexpr>z
{}{}- {}: z  r>   )indentfullinclude_list_depthc             s   s   | ]}t |tV  qd S )N)r&   r   )r
   vvr	   r	   r   r     s    z
{}{}[{}]:
{}{}{}z
%s%s[%d]:
%s%s%s)rh   r7   r   r_   sortedrL   r)   r&   r   dumpr   anyrM   r   )r   r   r   r   r   r   NLrL   rE   r?   r   r   r	   r	   r   r   S  sZ    



zParseResults.dumpc             O   s   t j | j f|| dS )a%  
        Pretty-printer for parsed results as a list, using the
        `pprint <https://docs.python.org/3/library/pprint.html>`_ module.
        Accepts additional positional or keyword args as defined for
        `pprint.pprint <https://docs.python.org/3/library/pprint.html#pprint.pprint>`_ .

        Example::

            ident = Word(alphas, alphanums)
            num = Word(nums)
            func = Forward()
            term = ident | num | Group('(' + func + ')')
            func <<= ident + Group(Optional(delimited_list(term)))
            result = func.parse_string("fna a,b,(fnb c,d,200),100")
            result.pprint(width=40)

        prints::

            ['fna',
             ['a',
              'b',
              ['(', 'fnb', ['c', 'd', '200'], ')'],
              '100']]
        N)pprintr   )r   r   r5   r	   r	   r   r     s    zParseResults.pprintc             C   s.   | j | jj | jd k	r| j p d | j| jffS )N)r#   r$   rr   r    r!   r   )r   r	   r	   r   r     s
    zParseResults.__getstate__c             C   s>   |\| _ \| _}}| _t|| _|d k	r4t|| _nd | _d S )N)r#   r$   r   r0   r!   rD   r    )r   stater   inAccumNamesr	   r	   r   r     s
    
zParseResults.__setstate__c             C   s   | j | jfS )N)r#   r   )r   r	   r	   r   __getnewargs__  s    zParseResults.__getnewargs__c             C   s   t t| t| j  S )N)dirr*   r'   r\   )r   r	   r	   r   __dir__  s    zParseResults.__dir__c             C   sv   dd }| g }xJ|j  D ]>\}}t|tr@|| j||d7 }q|| |g|||d7 }qW |dk	rr| |g|d}|S )z
        Helper classmethod to construct a ``ParseResults`` from a ``dict``, preserving the
        name-value relations as results names. If an optional ``name`` argument is
        given, a nested ``ParseResults`` will be returned.
        c             S   s2   yt |  W n tk
r    dS X t| t S d S )NF)rY   	Exceptionr&   r9   )r   r	   r	   r   is_iterable  s
    z+ParseResults.from_dict.<locals>.is_iterable)r4   )r4   r<   N)rL   r&   r   	from_dict)r,   rs   r4   r   rb   rE   r?   r	   r	   r   r     s    
zParseResults.from_dict)NN)N)r   )r   TTr   )N):r   r   r   r-   r8   r   r   r   r'   r.   r+   r&   r   r   rG   rT   r^   rV   r6   rW   rX   r   rZ   r[   r\   r]   rL   r_   rd   rC   rg   rh   rk   rm   rq   rt   rj   r|   r7   r~   r   r   r   r2   r}   rr   r   r   r   r   r   r   r   classmethodr   r<   asDictgetNamer	   r	   r	   r   r      sh   
,3
	:

3Pr   )collections.abcr   r   r   r   r   weakrefr   rD   typingr   r   r7   bytesr9   r*   r1   r   r   registerr	   r	   r	   r   <module>   s         a
