ó
    jñ:iÉl  ã                  óö   • % S SK Jr  S SKrS SKJrJrJrJrJr  S SK	r	S SK
Jr  SSKJr  \\4rS\S'   \" S	 S
 5       5      r " S S5      r " S S5      r\R,                  " \5        \R,                  " \5        g)é    )ÚannotationsN)ÚMutableMappingÚMappingÚMutableSequenceÚIteratorÚIterable)ÚAnyé   )Úreplaced_by_pep8ztuple[type, ...]Ústr_typec              #  ó$   #   • U  H  ov •  M     g 7f©N© )Ú.0Ú_s     ÚT/srv/projetos/modelo_ml_acdoc/venv/lib/python3.13/site-packages/pyparsing/results.pyÚ	<genexpr>r      s   é € �¢2˜aœ¢2ùs   ‚r   c                  óB   • \ rS rSr% S\S'   S/rS
S jrS rS rS r	Sr
g	)Ú_ParseResultsWithOffseté   ztuple[ParseResults, int]Útupc                ó   • X4U l         g r   ©r   )ÚselfÚp1Úp2s      r   Ú__init__Ú _ParseResultsWithOffset.__init__   s   € Ø.0¨Xˆ�ó    c                ó    • U R                   U   $ r   r   ©r   Úis     r   Ú__getitem__Ú#_ParseResultsWithOffset.__getitem__   s   € Ø�x‰x˜‰{Ðr   c                ó   • U R                   $ r   r   ©r   s    r   Ú__getstate__Ú$_ParseResultsWithOffset.__getstate__!   s   € Ø�x‰xˆr   c                ó   • US   U l         g ©Nr   r   )r   Úargss     r   Ú__setstate__Ú$_ParseResultsWithOffset.__setstate__$   s   € Ø˜‘7ˆ�r   r   N)r   ÚParseResultsr   ÚintÚreturnÚNone)Ú__name__Ú
__module__Ú__qualname__Ú__firstlineno__Ú__annotations__Ú	__slots__r   r#   r'   r,   Ú__static_attributes__r   r   r   r   r      s#   ‡ Ø	!Ó!Ø�€Iô6òòõr   r   c                  ó  • \ rS rSr% SrS/ S4rS\S'   S\S'   S \S	'   S
\S'   S\S'   S\S'   S\S'   Sr " S S\5      r	S@S jr
SSSS\4 SAS jjrS r\4S jrS rSBS jrSCS jrSBS jrSDS jrSDS jrS  rS! rS" rSBS# jrS$ rSES% jrS& rS' rS( rS) rS* rSFS+ jr SFS, jr!SGS- jr"SHS. jr#SHS/ jr$SIS0 jr%S1S2.SJS3 jjr&SKS4 jr'SGS5 jr(SGS6 jr)SLS7 jr*SMSHS8 jjr+S9 r,S: r-S; r.S< r/S= r0\1SESGS> jj5       r2\&r3 \'r4 \*r5S?r6g)Nr.   é(   aî  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:

.. testcode::

   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(f"{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:

.. testoutput::

   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'

Nr   ztuple[Any, ...]Ú_null_valuesÚstrÚ_nameÚ_parentzset[str]Ú
_all_namesÚboolÚ_modalz	list[Any]Ú_toklistzdict[str, Any]Ú_tokdict)r=   r>   r?   rA   rB   rC   c                  ó"   • \ rS rSrSrSS jrSrg)ÚParseResults.Listén   aé  
Simple wrapper class to distinguish parsed list results that should be preserved
as actual Python lists, instead of being converted to :class:`ParseResults`:

.. testcode::

   import pyparsing as pp
   ppc = pp.common

   LBRACK, RBRACK, LPAR, RPAR = pp.Suppress.using_each("[]()")
   element = pp.Forward()
   item = ppc.integer
   item_list = pp.DelimitedList(element)
   element_list = LBRACK + item_list + RBRACK | LPAR + item_list + RPAR
   element <<= item | element_list

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

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

prints:

.. testoutput::
   :options: +NORMALIZE_WHITESPACE


   100
   (100, <class 'int'>)

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

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

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

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

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

(Used internally by :class:`Group` when `aslist=True`.)
Nc                óº   • Uc  / n[        U[        5      (       d-  [        U R                   S[	        U5      R                   35      e[        R                  U 5      $ )Nz* may only be constructed with a list, not )Ú
isinstanceÚlistÚ	TypeErrorr2   ÚtypeÚ__new__)ÚclsÚ	containeds     r   rL   ÚParseResults.List.__new__ª   sW   € ØÑ Ø�	ä˜i¬×.Ñ.ÜØ—|‘|�nÐ$NÌtÐT]Ë×OgÑOgÐNhÐióð ô —<‘< Ó$Ð$r   r   r   )r2   r3   r4   r5   Ú__doc__rL   r8   r   r   r   ÚListrE   n   s   † ñ9	÷v		%r   rQ   c                ó~  • [        U[        5      (       a  U$ [        R                  U 5      nS Ul        S Ul        [        5       Ul        Uc  / Ul        OY[        U[        [        45      (       a6  [        U[        R                  5      (       a  US S  /O
[        U5      Ul        OU/Ul        [        5       Ul        U$ r   )rH   r.   ÚobjectrL   r=   r>   Úsetr?   rB   rI   Ú_generator_typerQ   ÚdictrC   )rM   ÚtoklistÚnameÚkwargsr   s        r   rL   ÚParseResults.__new__µ   sž   € Ü�gœ|×,Ñ,ØˆNÜ�~‰~˜cÓ"ˆØˆŒ
ØˆŒÜ›%ˆŒà‰?ØˆD�MÜ˜¤$¬Ð!8×9Ñ9ô ˜g¤|×'8Ñ'8×9Ñ9ð ™�‘ä˜'“]ð �Mð %˜IˆDŒMÜ›ˆŒØˆr   Tc                ó  • U   X@l         Ub  US:X  a  g U" U[        5      (       a  [        U5      nU(       d  U1U l        X l        XR
                  ;   a  g U" U[        [        45      (       a  U/nU(       aX  U" U[        5      (       a"  [        [        UR                  5      S5      X'   O[        [        US   5      S5      X'   X U   l        g  US   X'   g ! [        [        [        4 a    XLa  XU'    g X l         g f = f)NÚ r   )rA   r/   r<   r?   r=   r;   r   rK   r.   r   rB   ÚKeyErrorrJ   Ú
IndexError)r   rW   rX   ÚasListÚmodalrH   s         r   r   ÚParseResults.__init__Ì   sï   € ñ 	ØŒà‰<˜4 2›:Øá�dœC× Ñ Ü�t“9ˆDæØ#˜fˆDŒOàŒ
à×'Ñ'Ó'Øá�g¤¬$Ð/×0Ñ0Ø�iˆGæÙ˜'¤<×0Ñ0Ü4´\À'×BRÑBRÓ5SÐUVÓW�’
ä4´\À'È!Á*Ó5MÈqÓQ�‘
Ø#�‰JÔØð	"Ø  ™ˆDŠJøÜœ)¤ZÐ0ó 	"ØÒ"Ø$�T“
à!–
ð		"ús   ÃC ÃD Ã7D Ã?D c                óþ   • [        U[        [        45      (       a  U R                  U   $ XR                  ;  a  U R
                  U   S   S   $ [        U R
                  U    Vs/ s H  o"S   PM	     sn5      $ s  snf )Néÿÿÿÿr   )rH   r/   ÚslicerB   r?   rC   r.   )r   r"   Úvs      r   r#   ÚParseResults.__getitem__ó   so   € Ü�aœ#œu˜×&Ñ&Ø—=‘= Ñ#Ð#à—O‘OÓ#Ø—=‘= Ñ# BÑ'¨Ñ*Ð*ä¨4¯=©=¸Ò+;Ó<Ò+; a˜qœTÑ+;Ñ<Ó=Ð=ùÒ<s   Á%A:c                ó”  • U" U[         5      (       a;  U R                  R                  U[        5       5      U/-   U R                  U'   US   nObU" U[        [
        45      (       a  X R                  U'   UnO9U R                  R                  U/ 5      [        US5      /-   U R                  U'   UnU" U[        5      (       a  Xl        g g r*   )	r   rC   ÚgetrI   r/   rd   rB   r.   r>   )r   Úkre   rH   Úsubs        r   Ú__setitem__ÚParseResults.__setitem__ü   s´   € Ù�aÔ0×1Ñ1Ø#Ÿ}™}×0Ñ0°´D³FÓ;¸q¸cÑAˆD�M‰M˜!ÑØ�A‘$‰CÙ˜œC¤˜<×(Ñ(Ø �M‰M˜!ÑØ‰Cà#Ÿ}™}×0Ñ0°°BÓ7Ü'¨¨1Ó-ð;ñ  ˆD�M‰M˜!Ñð ˆCÙ�cœ<×(Ñ(Ø�Kð )r   c           	     óú  • [        U[        [        45      (       d  U R                  U	 g [	        U R
                  5      nU R
                  U	 [        U[        5      (       a  US:  a  X-  n[        XS-   5      n[        [        UR                  U5      6 5      nUR                  5         U R                  R                  5        H5  nU H,  n[        U5       H  u  nu  px[        XxX…:„  -
  5      XF'   M     M.     M7     g )Nr   r
   )rH   r/   rd   rC   ÚlenrB   rI   ÚrangeÚindicesÚreverseÚvaluesÚ	enumerater   )	r   r"   ÚmylenÚremovedÚoccurrencesÚjri   ÚvalueÚpositions	            r   Ú__delitem__ÚParseResults.__delitem__  s×   € Ü˜!œc¤5˜\×*Ñ*Ø—‘˜aÐ Øä�D—M‘MÓ"ˆØ�M‰M˜!Ðô �aœ×ÑØ�1‹uØ‘
�Ü�a˜Q™“ˆAä”u˜aŸi™i¨Ó.Ð/Ó0ˆØ�‰ÔàŸ=™=×/Ñ/Ö1ˆKÛ�Ü,5°kÖ,BÑ(�AÑ(˜Ü%<Ø¨8©<Ñ8ó&�K“Nó -Có ò 2r   c                ó   • XR                   ;   $ r   ©rC   )r   ri   s     r   Ú__contains__ÚParseResults.__contains__#  s   € Ø—M‘MÑ!Ð!r   c                ó,   • [        U R                  5      $ r   )rn   rB   r&   s    r   Ú__len__ÚParseResults.__len__&  s   € Ü�4—=‘=Ó!Ð!r   c                óH   • U R                   =(       d    U R                  (       $ r   )rB   rC   r&   s    r   Ú__bool__ÚParseResults.__bool__)  s   € ØŸ™×6¨¯©Ó7Ð7r   c                ó,   • [        U R                  5      $ r   ©ÚiterrB   r&   s    r   Ú__iter__ÚParseResults.__iter__,  ó   € Ü�D—M‘MÓ"Ð"r   c                ó8   • [        U R                  S S S2   5      $ ©Nrc   r‡   r&   s    r   Ú__reversed__ÚParseResults.__reversed__/  s   € Ü�D—M‘M¡$ B $Ñ'Ó(Ð(r   c                ó,   • [        U R                  5      $ r   )rˆ   rC   r&   s    r   ÚkeysÚParseResults.keys2  r‹   r   c                ó8   ^ • U 4S jT R                  5        5       $ )Nc              3  ó.   >#   • U  H
  nTU   v •  M     g 7fr   r   ©r   ri   r   s     €r   r   Ú&ParseResults.values.<locals>.<genexpr>6  s   øé € Ð-¢˜A��Q–¢ùs   ƒ©r‘   r&   s   `r   rr   ÚParseResults.values5  s   ø€ Ü- §¡¤Ó-Ð-r   c                ó8   ^ • U 4S jT R                  5        5       $ )Nc              3  ó0   >#   • U  H  oTU   4v •  M     g 7fr   r   r•   s     €r   r   Ú%ParseResults.items.<locals>.<genexpr>9  s   øé € Ð2¢k �D˜‘G•¢kùs   ƒr—   r&   s   `r   ÚitemsÚParseResults.items8  s   ø€ Ü2 d§i¡i¤kÓ2Ð2r   c                ó"   • U R                   (       $ )zŠ
Since ``keys()`` returns an iterator, this method is helpful in bypassing
code that looks for the existence of any defined results names.r}   r&   s    r   ÚhaskeysÚParseResults.haskeys;  s   € ð —}‘}Ó$Ð$r   c                ó  • U(       d  S/nUR                  5        H!  u  p4US:X  a	  US   U4nM  [        SU< 35      e   [        US   [        5      (       d  [	        U5      S:X  d	  US   U ;   a  US   nX   nX	 U$ US   nU$ )af  
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:

.. doctest::

   >>> 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)
   [W:(0-9)]...
   >>> 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())
   ['AAB', '123', '321']
   - LABEL: 'AAB'

   >>> # 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)
   {W:(A-Za-z) {W:(0-9)}...}
   >>> print(patt.parse_string("AAB 123 321").dump())
   ['AAB', '123', '321']

rc   Údefaultr   z)pop() got an unexpected keyword argument r
   )rœ   rJ   rH   r/   rn   )r   r+   rY   ri   re   ÚindexÚretÚdefaultvalues           r   ÚpopÚParseResults.popA  s˜   € ö\ Ø�4ˆDØ—L‘L–N‰DˆAØ�I‹~Ø˜Q™ �|’äÐ"KÈAÉ5Ð QÓRÐRñ	 #ô
 �d˜1‘gœs×#Ñ#¤s¨4£y°A£~¸¸a¹ÀD»Ø˜‘GˆEØ‘+ˆCØ�ØˆJà ™7ˆLØÐr   c                ó   • X;   a  X   $ U$ )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:

.. doctest::

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

   >>> result = date_str.parse_string("1999/12/31")
   >>> result.get("year")
   '1999'
   >>> result.get("hour", "not specified")
   'not specified'
   >>> result.get("hour")

r   )r   ÚkeyÚdefault_values      r   rh   ÚParseResults.get  s   € ð. ‹;Ø‘9Ðà Ð r   c                óÎ   • U R                   R                  X5        U R                  R                  5        H,  n[	        U5       H  u  nu  pV[        XVXa:„  -   5      X4'   M     M.     g)a"  
Inserts new element at location index in the list of parsed tokens.

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

Example:

.. doctest::

   >>> 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)
   [W:(0-9)]...
   >>> print(numlist.parse_string("0 123 321"))
   [0, '0', '123', '321']

N)rB   ÚinsertrC   rr   rs   r   )r   r£   Ú
ins_stringrv   ri   rx   ry   s          r   r­   ÚParseResults.insert›  s[   € ð2 	�‰×Ñ˜UÔ/àŸ=™=×/Ñ/Ö1ˆKÜ(1°+Ö(>Ñ$�Ñ$�EÜ!8Ø xÑ'7Ñ8ó"�“ó )?ò 2r   c                ó:   • U R                   R                  U5        g)a  
Add single element to end of ``ParseResults`` list of elements.

Example:

.. doctest::

   >>> 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)
   [W:(0-9)]...
   >>> print(numlist.parse_string("0 123 321"))
   ['0', '123', '321', 444]
N)rB   Úappend)r   Úitems     r   r±   ÚParseResults.append¼  s   € ð, 	�‰×Ñ˜TÕ"r   c                óˆ   • [        U[        5      (       a  U R                  U5        gU R                  R	                  U5        g)aû  
Add sequence of elements to end of :class:`ParseResults` list of elements.

Example:

.. testcode::

   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"))

prints:

.. testoutput::

   ['lskdjsdlkjflksddsklfjkldsjdksl']
N)rH   r.   Ú__iadd__rB   Úextend)r   Úitemseqs     r   r¶   ÚParseResults.extendÔ  s/   € ô2 �gœ|×,Ñ,Ø�M‰M˜'Õ"à�M‰M× Ñ  Õ)r   c                óV   • U R                   SS2	 U R                  R                  5         g)z'
Clear all elements and results names.
N)rB   rC   Úclearr&   s    r   rº   ÚParseResults.clearò  s    € ð �M‰Mš!ÐØ�‰×ÑÕr   c                ón   •  X   $ ! [          a$    UR                  S5      (       a  [        U5      e gf = f)NÚ__r\   )r]   Ú
startswithÚAttributeError)r   rX   s     r   Ú__getattr__ÚParseResults.__getattr__ù  s;   € ð	Ø‘:ÐøÜó 	Ø�‰˜t×$Ñ$Ü$ TÓ*Ð*Ùð	ús   ‚ †+4³4c                ó.   • U R                  5       nX!-  nU$ r   )Úcopy)r   Úotherr¤   s      r   Ú__add__ÚParseResults.__add__  s   € Ø�i‰i‹kˆØ‰ˆØˆ
r   c                ó  ^• U(       d  U $ UR                   (       a¡  [        U R                  5      mU4S jnUR                   R                  5       nU VVVs/ s H)  u  pEU  H  nU[	        US   U" US   5      5      4PM     M+     nnnnU H,  u  pFX`U'   [        US   [        5      (       d  M#  XS   l        M.     U =R                  UR                  -  sl        U =R                  UR                  -  sl        U $ s  snnnf )Nc                ó   >• U S:  a  T$ U T-   $ r*   r   )ÚaÚoffsets    €r   Ú<lambda>Ú'ParseResults.__iadd__.<locals>.<lambda>  s   ø€ ¨A°«E &Ð"A°q¸6±zÐ"Ar   r   r
   )	rC   rn   rB   rœ   r   rH   r.   r>   r?   )	r   rÄ   Ú	addoffsetÚ
otheritemsri   Úvlistre   ÚotherdictitemsrÊ   s	           @r   rµ   ÚParseResults.__iadd__  sã   ø€ ÞØˆKà�>�>Ü˜Ÿ™Ó'ˆFÜAˆIØŸ™×-Ñ-Ó/ˆJñ !+õâ *‘H�AÜ�Að Ô+¨A¨a©D±)¸A¸a¹D³/ÓBÓCáñ DÙ *ð ò ó
 '‘�Ø�Q‘Ü˜a ™d¤L×1Ó1Ø#'�a‘D–Lñ 'ð
 	�Š˜Ÿ™Ñ'�Ø�Š˜5×+Ñ+Ñ+�Øˆùôs   Á0C=c                ó`   • [        U[        5      (       a  US:X  a  U R                  5       $ X-   $ r*   )rH   r/   rÃ   )r   rÄ   s     r   Ú__radd__ÚParseResults.__radd__  s+   € Ü�eœS×!Ñ! e¨q£jà—9‘9“;Ðð ‘<Ðr   c                óp   • [        U 5      R                   SU R                  < SU R                  5        S3$ )NÚ(ú, Ú))rK   r2   rB   Úas_dictr&   s    r   Ú__repr__ÚParseResults.__repr__$  s2   € Ü�t“*×%Ñ%Ð& a¨¯©Ñ'8¸¸4¿<¹<»>Ð:JÈ!ÐLÐLr   c           
     óÂ   • SSR                  U R                   Vs/ s H.  n[        U[        5      (       a  [	        U5      O
[        U5      PM0     sn5      -   S-   $ s  snf )NÚ[r×   Ú])ÚjoinrB   rH   r.   r<   Úreprr!   s     r   Ú__str__ÚParseResults.__str__'  sd   € àØ�i‰ið "Ÿ]š]óâ*˜ô )¨¬L×9Ñ9”C˜”F¼tÀA»wÒFÙ*ñóñð ñð		
ùòs   ›5A
c                óô   • / nU R                    He  nU(       a  U(       a  UR                  U5        [        U[        5      (       a  X#R	                  5       -  nMK  UR                  [        U5      5        Mg     U$ r   )rB   r±   rH   r.   Ú_asStringListr<   )r   ÚsepÚoutr²   s       r   rä   ÚParseResults._asStringList3  sZ   € ØˆØ—M”MˆDÞ–sØ—
‘
˜3”Ü˜$¤×-Ñ-Ø×)Ñ)Ó+Ñ+’à—
‘
œ3˜t›9Ö%ñ "ð ˆ
r   F)Úflattenc               óÀ   ^ • U 4S jnU(       a
  / U" T 5      Q$ T R                    Vs/ s H*  n[        U[        5      (       a  UR                  5       OUPM,     sn$ s  snf )a  
Returns the parse results as a nested list of matching tokens, all converted to strings.
If ``flatten`` is True, all the nesting levels in the returned list are collapsed.

Example:

.. doctest::

   >>> 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
   >>> type(result)
   <class 'pyparsing.results.ParseResults'>
   >>> print(result)
   ['sldkj', 'lsdkj', 'sldkj']

.. doctest::

   >>> # Use as_list() to create an actual list
   >>> result_list = result.as_list()
   >>> type(result_list)
   <class 'list'>
   >>> print(result_list)
   ['sldkj', 'lsdkj', 'sldkj']

.. versionchanged:: 3.2.0
   New ``flatten`` argument.
c              3  óâ   >#   • [         R                  " / TQ5      nU(       aK  UR                  5       n[        U[        5      (       a  UR                  US S S2   5        OUv •  U(       a  MJ  g g 7fr�   )ÚcollectionsÚdequeÚpopleftrH   r.   Ú
extendleft)ÚprÚto_visitÚto_dor   s      €r   Ú	flattenedÚ'ParseResults.as_list.<locals>.flattened]  sZ   øé € Ü"×(Ò(¨¨4¨Ó1ˆHÞØ ×(Ñ(Ó*�Ü˜e¤\×2Ñ2Ø×'Ñ'¨©d°¨d©Õ4à’K÷ ’(ùs   ƒA(A/Á-A/)rB   rH   r.   Úas_list)r   rè   rò   Úress   `   r   rô   ÚParseResults.as_list>  s^   ø€ õ>	 ö Ø%‘Y˜t“_Ð%Ð%ð  Ÿ=š=óâ(�Cô ",¨C´×!>Ñ!>�—‘”ÀCÒGÙ(ñð ùò s   §1Ac                óV   ^• U4S jm[        U4S jU R                  5        5       5      $ )a£  
Returns the named parse results as a nested dictionary.

Example:

.. doctest::

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

   >>> result = date_str.parse_string('1999/12/31')
   >>> type(result)
   <class 'pyparsing.results.ParseResults'>
   >>> result
   ParseResults(['1999', '/', '12', '/', '31'], {'year': '1999', 'month': '12', 'day': '31'})

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

   >>> # even though a ParseResults supports dict-like access,
   >>> # sometime you just need to have a dict
   >>> import json
   >>> print(json.dumps(result))
   Traceback (most recent call last):
   TypeError: Object of type ParseResults is not JSON serializable
   >>> print(json.dumps(result.as_dict()))
   {"year": "1999", "month": "12", "day": "31"}
c                ó¸   >• [        U [        5      (       a>  U R                  5       (       a  U R                  5       $ U  Vs/ s H  nT" U5      PM     sn$ U $ s  snf r   )rH   r.   rŸ   rÙ   )Úobjre   Úto_items     €r   rú   Ú%ParseResults.as_dict.<locals>.to_item�  sL   ø€ Ü˜#œ|×,Ñ,Ø(+¯©¯©�s—{‘{“}ÐTÑPSÓ;TÒPSÈ1¹GÀA¾JÑPSÑ;TÐTà�
ùò <Us   Á Ac              3  ó<   >#   • U  H  u  pUT" U5      4v •  M     g 7fr   r   )r   ri   re   rú   s      €r   r   Ú'ParseResults.as_dict.<locals>.<genexpr>•  s   øé € Ð=²©¨�Q™ ›
•O²ùs   ƒ)rV   rœ   )r   rú   s    @r   rÙ   ÚParseResults.as_dictn  s"   ø€ õB	ô Ô=°·
±
´Ó=Ó=Ð=r   c                óð   • [        U R                  5      nU R                  R                  5       Ul        U R                  Ul        U=R
                  U R
                  -  sl        U R                  Ul        U$ )zê
Returns a new shallow copy of a :class:`ParseResults` object.
:class:`ParseResults` items contained within the source are
shared with the copy. Use :meth:`ParseResults.deepcopy` to
create a copy with its own separate content values.
)r.   rB   rC   rÃ   r>   r?   r=   )r   r¤   s     r   rÃ   ÚParseResults.copy—  sS   € ô ˜4Ÿ=™=Ó)ˆØ—}‘}×)Ñ)Ó+ˆŒØ—l‘lˆŒØ�Š˜$Ÿ/™/Ñ)�Ø—J‘JˆŒ	Øˆ
r   c                óp  • U R                  5       n[        U R                  5       GH  u  p#[        U[        5      (       a  UR                  5       UR                  U'   M:  [        U[        [        45      (       a  MW  [        U[        5      (       ac  [        U5      " 5       =UR                  U'   nUR                  5        H.  u  pV[        U[        5      (       a  UR                  5       OUXE'   M0     MÏ  [        U[        5      (       d  Mæ  [        U5      " S U 5       5      UR                  U'   GM     U$ )zU
Returns a new deep copy of a :class:`ParseResults` object.

.. versionadded:: 3.1.0
c              3  óp   #   • U  H,  n[        U[        5      (       a  UR                  5       OUv •  M.     g 7fr   )rH   r.   Údeepcopy)r   re   s     r   r   Ú(ParseResults.deepcopy.<locals>.<genexpr>·  s+   é € ð ,ÚPSÈ1¤J¨q´,×$?Ñ$?�A—J‘J”LÀQÔFÒPSùs   ‚46)rÃ   rs   rB   rH   r.   r  r<   Úbytesr   rK   rœ   r   )r   r¤   r"   rù   Údestri   re   s          r   r  ÚParseResults.deepcopy¥  sá   € ð �i‰i‹kˆä §¡×.‰FˆAÜ˜#œ|×,Ñ,Ø"%§,¡,£.�—‘˜Q“Ü˜C¤#¤u ×.Ñ.ÙÜ˜C¤×0Ñ0Ü)-¨c¬«Ð4�—‘˜Q‘ $ØŸI™IžK‘D�AÜ.8¸¼L×.IÑ.I˜aŸj™jœlÈq�D“Gó (ä˜C¤×*Ó*Ü"& s¤)ñ ,ÙPSó,ó #�—‘˜Q”ñ /ð ˆ
r   c                óî  ^ • T R                   (       a  T R                   $ T R                  (       a<  T R                  nUR                  R                  5       n[	        U 4S jU 5       S5      $ [        T 5      S:X  a{  [        T R                  5      S:X  ab  [	        [        T R                  R                  5       5      5      S   S   S;   a,  [	        [        T R                  R                  5       5      5      $ g)aŸ  
Returns the results name for this token expression.

Useful when several different expressions might match
at a particular location.

Example:

.. testcode::

   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:

.. testoutput::

   age : 22
   ssn : 111-22-3333
   house_number : 221B

c              3  óR   >#   • U  H  u  pU  H  u  p4UTL d  M  Uv •  M     M     g 7fr   r   )r   ri   rÏ   re   Úlocr   s        €r   r   Ú(ParseResults.get_name.<locals>.<genexpr>â  s2   øé € ð â$8™˜Ü"'™˜Ø˜D�y÷ ‘Aá"'ñ Ú$8ùs   ƒ'š'Nr
   r   )r   rc   )	r=   r>   rC   rœ   Únextrn   rˆ   rr   r‘   )r   ÚparÚparent_tokdict_itemss   `  r   Úget_nameÚParseResults.get_name¼  sÀ   ø€ ð@ �:�:Ø—:‘:ÐØ�\�\Ø $§¡ˆCØ#&§<¡<×#5Ñ#5Ó#7Ð Üôá$8óð óð ô �‹I˜‹NÜ�D—M‘MÓ" aÓ'Ü”T˜$Ÿ-™-×.Ñ.Ó0Ó1Ó2°1Ñ5°aÑ8¸GÓCäœ˜TŸ]™]×/Ñ/Ó1Ó2Ó3Ð3àr   c                ó   • / nSnUR                  U(       a  U[        U R                  5       5      -   OS5        U(       d  SR                  U5      $ U R	                  5       (       a×  [        S U R                  5        5       5      nU H±  u  p‰U(       a  UR                  U5        UR                  U SU-   SU S35        [        U	[        5      (       d  UR                  [        U	5      5        Mj  U	(       d  UR                  [        U	5      5        M�  UR                  U	R                  UUUUS-   S95        M³     [        S	 U  5       5      (       d  SR                  U5      $ U n	Sn
Sn[        U	5       H…  u  pÍ[        U[        5      (       aA  UR                  UUUUS-   S9nUR                  U U X¤-   S
U SU U X¤S-   -   U 3
5        M[  UR                  U U X¤-   S
U SU U X¤S-   -   U 3
5        M‡     SR                  U5      $ )aó  
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:

.. testcode::

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

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

prints:

.. testoutput::

   ['1999', '/', '12', '/', '31']
   - day: '31'
   - month: '12'
   - year: '1999'
Ú
r\   c              3  ó@   #   • U  H  u  p[        U5      U4v •  M     g 7fr   )r<   )r   ri   re   s      r   r   Ú$ParseResults.dump.<locals>.<genexpr>  s   é € Ð@²<©4¨1œC ›F A�;²<ùs   ‚z  z- z: r
   )ÚindentÚfullÚinclude_listÚ_depthc              3  óB   #   • U  H  n[        U[        5      v •  M     g 7fr   )rH   r.   )r   Úvvs     r   r   r  )  s   é € Ð?º$°B”:˜b¤,×/Ð/º$ùs   ‚rÝ   z]:)r±   r<   rô   rß   rŸ   Úsortedrœ   rH   r.   rà   ÚdumpÚanyrs   )r   r  r  r  r  ræ   ÚNLrœ   ri   re   ÚincrÚnlr"   r  Úvv_dumps                  r   r  ÚParseResults.dumpó  s  € ð2 ˆØˆØ�
‰
¶<�6œC §¡£Ó/Ò/ÀRÔHæØ—7‘7˜3“<Ðà�<‰<�>‰>ÜÑ@°4·:±:´<Ó@Ó@ˆEÛ‘�ÞØ—J‘J˜r”NØ—
‘
˜f˜X t¨f¡}Ð%6°b¸¸¸2Ð>Ô?Ü! !¤\×2Ñ2Ø—J‘Jœt A›wÔ'ÙæØ—J‘Jœs 1›vÔ&Ùà—
‘
Ø—F‘FØ%Ø!Ø%1Ø%¨™zð	 ð öñ ô( Ñ?¹$Ó?×?Ñ?Ø—7‘7˜3“<ÐàˆØˆØˆÜ˜q–\‰EˆAÜ˜"œl×+Ñ+ØŸ'™'Ø!ØØ!-Ø! A™:ð	 "ð �ð —
‘
Ø�d˜6˜( 4¡= /°°1°#°R¸°t¸F¸8ÀDÐUVÉJÑDWÐCXÐY`ÐXaÐböð —
‘
Ø�d˜6˜( 4¡= /°°1°#°R¸°t¸F¸8ÀDÐUVÉJÑDWÐCXÐY[ÐX\Ð]öñ "ð  �w‰w�s‹|Ðr   c                óT   • [         R                   " U R                  5       /UQ70 UD6  g)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:

.. testcode::

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

prints:

.. testoutput::

   ['fna',
    ['a',
     'b',
     ['(', 'fnb', ['c', 'd', '200'], ')'],
     '100']]
N)Úpprintrô   )r   r+   rY   s      r   r$  ÚParseResults.pprintA  s    € ô: 	�Š�d—l‘l“nÐ6 tÒ6¨vÓ6r   c                ó~   • U R                   U R                  R                  5       S U R                  U R                  44$ r   )rB   rC   rÃ   r?   r=   r&   s    r   r'   ÚParseResults.__getstate__a  s9   € à�M‰Mà—‘×"Ñ"Ó$ØØ—‘Ø—
‘
ð	ð
ð 	
r   c                ób   • Uu  U l         u  U l        p#U l        [        U5      U l        S U l        g r   )rB   rC   r=   rT   r?   r>   )r   Ústater  ÚinAccumNamess       r   r,   ÚParseResults.__setstate__l  s,   € ØHMÑEˆŒÑE˜œ s¸$¼*Ü˜lÓ+ˆŒØˆ�r   c                ó2   • U R                   U R                  4$ r   )rB   r=   r&   s    r   Ú__getnewargs__ÚParseResults.__getnewargs__q  s   € Ø�}‰}˜dŸj™jÐ(Ð(r   c                ó^   • [        [        U 5      5      [        U R                  5       5      -   $ r   )ÚdirrK   rI   r‘   r&   s    r   Ú__dir__ÚParseResults.__dir__t  s    € Ü”4˜“:‹¤ d§i¡i£kÓ!2Ñ2Ð2r   c           	     óÔ   • S nU " / 5      nUR                  5        H=  u  pV[        U[        5      (       a  X@R                  XeS9-  nM-  X@" U/XS" U5      S9-  nM?     Ub  U " U/US9nU$ )zÜ
Helper classmethod to construct a :class:`ParseResults` from a ``dict``, preserving the
name-value relations as results names. If an optional ``name`` argument is
given, a nested :class:`ParseResults` will be returned.
c                ód   •  [        U 5        [        U [        5      (       + $ ! [         a     gf = f)NF)rˆ   rH   r   Ú	Exception)rù   s    r   Úis_iterableÚ+ParseResults.from_dict.<locals>.is_iterable  s4   € ð5Ü�S”	ô
 & c¬8Ó4Ô4Ð4øô	 ó Ùðús   ‚" ¢
/®/)rX   )rX   r_   )rœ   rH   r   Ú	from_dict)rM   rÄ   rX   r6  r¤   ri   re   s          r   r8  ÚParseResults.from_dictw  sx   € ò	5ñ �"‹gˆØ—K‘K–M‰DˆAÜ˜!œW×%Ñ%Ø—}‘} Q�}Ð/Ñ/’à�s˜A˜3 Q¨{¸1«~Ñ>Ñ>’ñ	 "ð
 ÑÙ�s�e $Ñ'ˆCØˆ
r   )r?   rA   r=   r>   rC   rB   )NN)r0   r1   )r0   r@   )r0   r/   )r0   r   r   )rÄ   r.   r0   r.   )r0   r.   )r0   r<   )r\   )rè   r@   r0   rI   )r0   rV   )r0   z
str | None)r\   TTr   )7r2   r3   r4   r5   rP   r;   r6   r7   rI   rQ   rL   rH   r   r#   rk   rz   r~   r�   r„   r‰   rŽ   r‘   rr   rœ   rŸ   r¦   rh   r­   r±   r¶   rº   rÀ   rÅ   rµ   rÓ   rÚ   rá   rä   rô   rÙ   rÃ   r  r  r  r$  r'   r,   r-  r1  Úclassmethodr8  r_   ÚasDictÚgetNamer8   r   r   r   r.   r.   (   sq  ‡ ñ1ðf &*¨2¨r N€L�/Ó2àƒJØÓØÓØƒLØÓØÓð€IôE%ˆtô E%ôNð0  ¨d¸$È:ð%"à	õ%"òN>ð ,6ô òô0"ô"ô8ô#ô)ò#ò.ò3ô%ò< ô|!ò8òB#ò0*ò<òôô
ô, ôMô

ô	ð */÷ .ô`'>ôRôô.5önLò\7ò@	
òò
)ò3ð õó ðð4 €Fðð €Fðð €Gòr   r.   )Ú
__future__r   rë   Úcollections.abcr   r   r   r   r   r$  Útypingr	   Úutilr   r<   r  r   r6   rK   rU   r   r.   Úregisterr   r   r   Ú<module>rB     sv   ðö #ã ÷õ ó Ý å "ð " 5˜\€Ð
Ó )Ù‘¡2“Ó'€÷ñ ÷"xñ xðv × Ò ˜Ô %Ø × Ò ˜Õ &r   