intellecton/venv/lib/python3.12/site-packages/pyparsing/__pycache__/results.cpython-312.pyc

Ë
vRjÓkã
ó
—Udd
lm
Z

ddlZddlmZmZmZmZmZ
ddl	Z	ddl
mZ
ddlm
Z
mZmZ
eefZded<ed	„d
D««
Zed«
Zded<Gd
„d«ZGd„d«Zej4e«

ej4e«

y)é)
ÚannotationsN)ÚMutableMappingÚMappingÚMutableSequenceÚIteratorÚIterable)
ÚAnyé
)Údeprecate_argumentÚ_is_iterableÚ_flattenztuple[type, ...]Ústr_typec
#
ó K
—|]}
|
–
—

Œy­w
©
N©)Ú.0Ú
_s  úT/home/antigravity/intellecton/venv/lib/python3.12/site-packages/pyparsing/results.pyú	<genexpr>rsèø€’˜aœ
‘ùs‚
rÚsliceÚ
NULL_SLICEc
ó8—eZ
dZUd
ed<dg
Zdd„Zd„Zd„Zd„Zy)	Ú_ParseResultsWithOffsetztuple[ParseResults, int]Útupc
ó—|
|f|_yr©
r)ÚselfÚp1Úp2s   rÚ__init__z _ParseResultsWithOffset.__init__s
€Ø.0°"¨Xˆ�óc
ó —|j|
Srr©rÚ
is  rÚ__getitem__z#_ParseResultsWithOffset.__getitem__s€Ø�x‰x˜
‰{Ðr!c


ó—|jSrr©
rs
 rÚ__getstate__z$_ParseResultsWithOffset.__getstate__"s€Ø�x‰xˆr!c

ó—|
d
|_y©Nrr)rÚargss  rÚ__setstate__z$_ParseResultsWithOffset.__setstate__%s
€Ø˜
‘7ˆ�r!N)rÚParseResultsrÚintÚreturnÚNone)	Ú__name__Ú
__module__Ú__qualname__Ú__annotations__Ú	__slots__r r%r(r,rr!rrrs#…Ø	!Ó!Ø�€Ió
6ò
ò
ó
r!rc
óÈ
—eZ
dZUd
ZdgdfZded<ded<ded<d	ed
<ded<d
ed<ded<dZGd„de«Zd>d„
Z	dddde
f	d?d„Zd„Ze
f
d„
Z
d„Zd@d„ZdAd„Zd@d„ZdBd„ZdBd„Zd„Zd „Zd!„Zd@d"„Zd#„ZdCd$„
Zd%„Zd&„Zd'„Zd(„Zd)„ZdDd*„ZdDd+„Z dEd,„Z!dFd-„Z"dFd.„Z#dGd/„
Z$d0d1œ
dHd2„Z%dId3„Z&dEd4„Z'dEd5„Z(dJd6„Z)dKdFd7„Z*d8„Z+d9„Z,d:„Z-d;„Z.d<„Z/e0dCdEd=„«Z1e%Z2	e&Z3	e)Z4y)Lr-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'

    Nrztuple[Any, ...]Ú_null_valuesÚstrÚ_nameÚ_parentzset[str]Ú
_all_namesÚboolÚ_modalz	list[Any]Ú_toklistzdict[str, Any]Ú_tokdict)r9r:r;r=r>r?c
ó—eZ
dZd
Zdd„
Zy)úParseResults.Lista9
        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
ó®—|
€g}
t
|
t«s-t|j›d
t	|
«
j›�«
‚
tj|«
S)Nz* may only be constructed with a list, not )Ú
isinstanceÚlistÚ	TypeErrorr1ÚtypeÚ__new__)ÚclsÚ	containeds  rrGzParseResults.List.__new__«sT€ØÐ Ø�	ä˜i¬Ô.ÜØ—|‘|�nÐ$NÌtÐT]Ë×OgÑOgÐNhÐióðô—<‘< Ó$Ð$r!r)r1r2r3Ú__doc__rGrr!rÚListrAos
„ñ9	ôv
		%r!rKc
ó^
—t
|
t«r|
Stj|«
}d|_d|_t
«|_|
€g|_nOt
|
ttf«r1t
|
tj«r|
ddg
n
t|
«
|_n|
g
|_t«|_
|Sr)rCr-ÚobjectrGr9r:Úsetr;r>rDÚ_generator_typerKÚdictr?)rHÚtoklistÚnameÚkwargsrs     rrGzParseResults.__new__¶s•€Ü�gœ|Ô,؈NÜ�~‰~˜cÓ"ˆØˆŒ
؈ŒÜ›%ˆŒàˆ?؈D�MÜ
˜¤$¬Ð!8Ô
9ô˜g¤|×'8Ñ'8Ô9ð™�‘ä˜'“]ð
�Mð%˜IˆDŒMÜ›ˆŒ
؈r!Tc
ó—t
|d
dd¬«}|x
r
|}|
||_
|�|dk(r
y||t«rt|«
}|s|h
|_||_|
|jvr
y||
ttf«r|
g
}
|rV||
t«r#tt|
j«
d«||<ntt|
d«
d«||<|||_y	|
d||<y#tttf$r
|
|u
r|
||<Yy||_YywxYw
)NÚasListTÚaslist)
Únew_nameÚr)rr=r.r8r;r9r7rrFr-rr>ÚKeyErrorrEÚ
IndexError)rrQrRrVÚmodalrCrSrUs        rr zParseResults.__init__Ís
€ô$ F¨H°dÀXÔNˆàÒ"˜FˆÙ؈Œàˆ<˜4 2š:Øá�dœCÔ Ü�t“9ˆDáØ#˜fˆDŒOàˆŒ
à�d×'Ñ'Ñ'Øá�g¤¬$Ð/Ô0Ø�iˆGáÙ˜'¤<Ô0Ü4´\À'×BRÑBRÓ5SÐUVÓW��T’
ä4´\À'È!Á*Ó5MÈqÓQ��T‘
Ø#ˆD�‰JÔØð	"Ø  ™ˆD�ŠJøÜœ)¤ZÐ0ò	"ؘdÑ"Ø$��T“
à!�–
ð		"úsÃCÃDÃ6DÃ?
Dc
óî—t
|
ttf«r|j|
S|
|jv
r|j
|
d
dSt
|j
|
D�cgc]}|d‘Œ	c}«
Sc
c}w)Néÿÿÿÿr)rCr.rr>r;r?r-)rr$Ú
vs   rr%zParseResults.__getitem__ýsj€Ü�aœ#œu˜Ô&Ø—=‘= Ñ#Ð#à�D—O‘OÑ#Ø—=‘= Ñ# BÑ'¨
Ñ*Ð*ä¨4¯=©=¸Ñ+;Ö< a˜Q˜q›TÒ<Ó=Ð=ùÒ<sÁA2c
óz
—||t«r;|jj|
t««|g
z|j|
<|d
}n^||
tt
f«r||j|
<|}n9|jj|
g«t
|d
«g
z|j|
<|}||t«r||_yyr*)	rr?ÚgetrDr.rr>r-r:)rÚ
kr^rCÚsubs     rÚ__setitem__zParseResults.__setitem__
s¯€Ù�aÔ0Ô1Ø#Ÿ}™}×0Ñ0°´D³FÓ;¸q¸cÑAˆD�M‰M˜!ÑØ�A‘$‰CÙ
˜
œC¤˜<Ô
(Ø ˆD�M‰M˜!Ñ؉Cà#Ÿ}™}×0Ñ0°°BÓ7Ü'¨
¨1Ó-ð;ñ ˆD�M‰M˜!ÑðˆCÙ�cœ<Ô(؈C�Kð)r!c	
ó,—t
|
ttf«s|j|
=y|
tk(r|j
j
«
yt|j
«
}|j
|
=t
|
t«r|
d
kr|
|z
}
t|
|
dz«}
tt|
j|«
Ž«
}|j«
|jj«D]4}|D]-}t|«
D]\}\}}t||||kDz
«||<ŒŒ/Œ6y)Nrr
)rCr.rr?rr>ÚclearÚlenrDÚrangeÚindicesÚreverseÚvaluesÚ	enumerater)	rr$ÚmylenÚremovedÚoccurrencesÚ
jraÚvalueÚpositions	         rÚ__delitem__zParseResults.__delitem__
s
€Ü˜!œc¤5˜\Ô*Ø—
‘
˜aÐ Øð
”
Š?Ø�M‰M×ÑÔ!Øä�D—M‘MÓ"ˆØ�M‰M˜!Ðô�aœÔØ�1ŠuØ�U‘
�
Ü�a˜˜Q™“ˆAä”u˜aŸi™i¨Ó.Ð/Ó0ˆØ�‰ÔàŸ=™=×/Ñ/Ó1ò	ˆKØò
�
Ü,5°kÓ,BòÑ(�AÑ(˜˜xÜ%<ؘx¨8°a©<Ñ8ó&�K 
’Nññ
ñ	r!c
ó—|
|jvSr©
r?)rras  rÚ__contains__zParseResults.__contains__2
s€Ø�D—M‘MÐ!Ð!r!c

ó,—t
|j«
Sr)rfr>r's
 rÚ__len__zParseResults.__len__5
s€Ü�4—=‘=Ó!Ð!r!c

ó:—|jx
s
|jSr)r>r?r's
 rÚ__bool__zParseResults.__bool__8
s€ØŸ
™
Ò6¨¯©Ð7Ð7Ð7r!c

ó,—t
|j«
Sr©Úiterr>r's
 rÚ__iter__zParseResults.__iter__;
ó€Ü�D—M‘MÓ"Ð"r!c

ó8—t
|jddd
…«
S)Nr]r{r's
 rÚ__reversed__zParseResults.__reversed__>
s€Ü�D—M‘M¡$ B $Ñ'Ó(Ð(r!c

ó,—t
|j«
Sr)r|r?r's
 rÚkeyszParseResults.keysA
r~r!c

ó6‡—ˆf
d
„‰j
«D«S)Nc
3
ó(•
K
—|]	}
‰|
–
—

Œy­w
rr©rrars  €rrz&ParseResults.values.<locals>.<genexpr>E
søèø€Ò-˜A��Q•Ñ-ùsƒ
©
r‚r's
`rrjzParseResults.valuesD
sø€Û- §¡£Ô-Ð-r!c

ó6‡—ˆf
d
„‰j
«D«S)Nc
3
ó,•
K
—|]}
|
‰|
f–
—

Œ
y­w
rrr…s  €rrz%ParseResults.items.<locals>.<genexpr>H
søèø€Ò2 ��D˜‘G”Ñ2ùsƒ
r†r's
`rÚitemszParseResults.itemsG
sø€Û2 d§i¡i£kÔ2Ð2r!c


ó—|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.rtr's
 rÚhaskeyszParseResults.haskeysJ
s€ð—}‘}Ð$Ð$Ð$r!c

óì—|
sd
g
}
|j
«D]\}}|dk(r|
d|f}
Œtd|›�«
‚
t|
dt«st	|
«
dk(s|
d|vr|
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:

        .. 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']

        r]Údefaultrz)pop() got an unexpected keyword argument r
)r‰rErCr.rf)rr+rSrar^ÚindexÚretÚdefaultvalues        rÚpopzParseResults.popP
s¢€ñ\
Ø�4ˆDØ—L‘L“Nò	S
‰DˆAˆqØ�IŠ~ؘQ™ �|‘äÐ"KÈAÈ5Ð QÓRÐRð		S
ô
�d˜1‘gœsÔ#¤s¨4£y°A¢~¸¸a¹ÀD¹Ø˜‘GˆEØ�u‘+ˆCØ�U�؈Jà 
™7ˆLØÐr!c
ó—|
|vr||
S|S)
as
        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   rr`zParseResults.getŽ
s€ð.�$‰;ؘ‘9Ðà Ð r!c
óЗ|jj|
|«
|jj«D]-}t	|«
D]\}\}}t||||
kDz«||<ŒŒ/y
)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)r>Úinsertr?rjrkr)rrŽÚ
ins_stringrnrarprqs       rr–zParseResults.insertª
so€ð2	
�
‰
×јU JÔ/àŸ=™=×/Ñ/Ó1ò	ˆKÜ(1°+Ó(>ò
Ñ$�
Ñ$�E˜8Ü!8ؘ8 x°%Ñ'7Ñ8ó"�˜A’ñ
ñ	r!c
ó:—|jj|
«

y
)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)r>Úappend)rÚitems  rr™zParseResults.appendË
s€ð,	
�
‰
×јTÕ"r!c
ó~—t
|
t«r|j|
«

y
|jj	|
«

y
)as
        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)rCr-Ú__iadd__r>Úextend)rÚitemseqs  rr�zParseResults.extendã
s,€ô2�gœ|Ô,Ø�M‰M˜'Õ"à�M‰M× Ñ  Õ)r!c

óV—|jd
d
…=|jj«
y
)z7
        Clear all elements and results names.
        N)r>r?rer's
 rrezParseResults.clear
s €ð
�M‰Mš!ÐØ�
‰
×ÑÕr!c
ód—	||
S#t$r
|
jd
«
rt|
«
‚
YywxYw
)NÚ__rX)rYÚ
startswithÚAttributeError)rrRs  rÚ__getattr__zParseResults.__getattr__s:€ð	ؘ‘:ÐøÜò	Ø�‰˜tÔ$Ü$ TÓ*Ð*Ùð	ús‚‡%/®
/c
ó0—|j
«}||
z
}|Sr)
Úcopy)rÚotherr�s   rÚ__add__zParseResults.__add__s€Ø�i‰i‹kˆØˆu‰ˆØˆ
r!c
óÞ
‡—|
s|S|
jr–t|j«
Šˆf
d
„}|
jj«}|D���cgc]&\}}|D]}|t	|d||d«
«f‘ŒŒ(}}}}|D](\}}|||<t|dt«s
Œ||d_Œ*|x
j|
jz
c_|x
j|
jzc_|Sc
c}}}w)Nc

ó•
—|d
kr‰
S|‰
zSr*r)Ú
aÚoffsets €rú<lambda>z'ParseResults.__iadd__.<locals>.<lambda>sø€¨A°
ªE &€°q¸6±z€r!rr
)	r?rfr>r‰rrCr-r:r;)	rr§Ú	addoffsetÚ
otheritemsraÚvlistr^Úotherdictitemsr¬s	        @rrœzParseResults.__iadd__söø€Ù؈Kà�>Š>ܘŸ™Ó'ˆFÛAˆIØŸ™×-Ñ-Ó/ˆJð!+÷ðá�A�uØòððÔ+¨A¨a©D±)¸A¸a¹D³/ÓBÒCðØCðˆNòð
'ò
(‘�
�1Ø��Q‘ܘa 
™d¤LÕ1Ø#'�A�a‘D•Lð
(ð
	
�
Š
˜Ÿ™Ñ'�
Ø�Š˜5×+Ñ+Ñ+�؈ùôsÁ+C(c
óV—t
|
t«r|
d
k(r|j«S|
|zSr*)rCr.r¦)rr§s  rÚ__radd__zParseResults.__radd__+s*€Ü�eœSÔ! e¨q¢jà—9‘9“;Ðð˜4‘<Ðr!c

ón—t
|«
j›d
|j›d|j«›d�S)Nú
(ú, ú
))rFr1r>Úas_dictr's
 rÚ__repr__zParseResults.__repr__3s2€Ü�t“*×%Ñ%Ð& a¨¯
©
Ð'8¸¸4¿<¹<»>Ð:JÈ!ÐLÐLr!c


ó²—d
dj
|jD�
cgc](}
t|
t«rt	|
«
n
t|
«
‘Œ*c}
«
zdzSc
c}
w)Nú
[r¶ú
])Újoinr>rCr-r8Úreprr#s  rÚ__str__zParseResults.__str__6s\€àØ�i‰ið"Ÿ]™]öàô)¨¬LÔ9”C˜
”F¼tÀA»wÑFòóñ
ðñ
ð		
ùòs›-A
c
óÒ—g}|jD]U}|r|
r|j|
«

t|t«r||j	«z
}Œ<|jt|«
«

ŒW|Sr)r>r™rCr-Ú
_asStringListr8)rÚsepÚoutršs    rrÁzParseResults._asStringListBs^€ØˆØ—M‘Mò	&ˆDÙ‘sØ—
‘
˜3”ܘ$¤Ô-Ø�t×)Ñ)Ó+Ñ+‘à—
‘
œ3˜t›9Õ%ð
	&ðˆ
r!F)
Úflattenc


óž—|
r
gt
|«
¢
S|jD�cgc]$}t|t«r|j	«n
|‘Œ&c}Sc
c}w)
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.
        )r
r>rCr-Úas_list)rrÄÚress   rrÆzParseResults.as_listMsP€ñ>Ø$”X˜d“^Ð$Ð$ð Ÿ=™=öàô",¨C´Ô!>�—‘”
ÀCÑGòð
ùòsž)A
c

óR‡
—ˆ
f
d
„Š
t
ˆ
f
d„|j«D««
S)ac
        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

óž•
—t
|t«r6|j«r|j«S|D�
cgc]
}
‰|
«
‘Œc}
S|Sc
c}
wr)rCr-r‹r¸)Úobjr^Úto_items  €rrËz%ParseResults.as_dict.<locals>.to_item•sAø€Ü˜#œ|Ô,Ø(+¯©¬
�s—{‘{“}ÐTÐPSÖ;TÈ1¹GÀA½JÒ;TÐTà�
ùò<U
s¶A
c
3
ó8•
K
—|]\}
}|
‰|«
f–
—

Œy­w
rr)rrar^rËs   €rrz'ParseResults.as_dict.<locals>.<genexpr>›søèø€Ò=©¨
¨1�Q™ 
›
”OÑ=ùsƒ
)rPr‰)rrËs @rr¸zParseResults.as_dictts"ø€ôB
	ôÓ=°·
±
³Ô=Ó=Ð=r!c

óð—t
|j«
}
|jj«|
_|j|
_|
x
j
|j
zc_|j|
_|
S)
a

        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-r>r?r¦r:r;r9)rr�s  rr¦zParseResults.copy�sS€ô˜4Ÿ=™=Ó)ˆØ—}‘}×)Ñ)Ó+ˆŒØ—l‘lˆŒØ�Š˜$Ÿ/™/Ñ)�Ø—J‘JˆŒ	؈
r!c

ó0—|j
«}
t|j«
D]í\}}t|t«r|j«|
j|<Œ4t|ttf«r
ŒKt|t«r]t|«
«x
|
j|<}|j«D]*\}}t|t«r|j«n
|||<Œ,Œ¸t|t«s
ŒÉt|«
d
„|D««
|
j|<Ε|
S)zm
        Returns a new deep copy of a :class:`ParseResults` object.

        .. versionadded:: 3.1.0
        c
3
ó`K
—|]&}
t
|
t«r|
j«n
|
–
—

Œ(y­w
r)rCr-Údeepcopy)rr^s  rrz(ParseResults.deepcopy.<locals>.<genexpr>½s)èø€ò,ØKL¤J¨q´,Ô$?�A—J‘J”LÀQÓFñ,ùs‚,.
)r¦rkr>rCr-rÐr8ÚbytesrrFr‰r)rr�r$rÊÚdestrar^s       rrÐzParseResults.deepcopy«sè€ð�i‰i‹kˆä §
¡
Ó.ò	‰FˆAˆsܘ#œ|Ô,Ø"%§,¡,£.�—‘˜Q’ܘC¤#¤u Ô.ØܘC¤Ô0Ø)2¬¨c««Ð4�—‘˜Q‘ $ØŸI™I›Kò
Q
‘D�A�qÜ.8¸¼LÔ.I˜aŸj™jœlÈq�D˜’Gñ
Q
ä˜C¤Õ*Ø"+¤$ s£)ñ,ØPSô,ó#�—‘˜Q’ð	ðˆ
r!c

óÐ
‡—‰jr‰jS‰jr;‰j}
|
jj«}t	ˆf
d
„|D«d«St‰«
dk(rxt‰j«
dk(r`t	t
‰jj««
«
dddvr,t	t
‰jj««
«
Sy)aG
        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
óD•
K
—|]\}
}|D]
\}}|‰ur|
–
—

ŒŒy­w
rr)rrar°r^Úlocrs     €rrz(ParseResults.get_name.<locals>.<genexpr>ès=øèø€òá ˜
˜5Ø"'òñ˜
˜3ؘD‘yôðØñùsƒ 
Nr
r)rr])	r9r:r?r‰Únextrfr|rjr‚)rÚparÚparent_tokdict_itemss`  rÚget_namezParseResults.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
óÚ—g}d
}|j
|r|
t|j««
zn
d«

|sdj|«
S|j	«rÈtd„|j
«D««
}|D]£\}}	|r|j
|«

|j
|
›d|z›d|›d�«

t|	t«s|j
t|	«
«

Œ`|	s|j
t|	«
«

Œ}|j
|	j|
|||dz¬««

Œ¥td	„|D««
sdj|«
S|}	d}
d
}t|	«
D]†\}}
t|
t«rE|
j|
|||dz¬«}|j
|›|
›|
|z›d
|›d|›|
›|
|dzz›|›�
«

Œ[|j
|›|
›|
|z›d
|›d|›|
›|
|dzz›|
›�
«

Œˆdj|«
S)as
        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")