mrhavens/intellecton
1
0 Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
ea2bf214f7126b8697b016bcc72147a897d3575b
intellecton/venv/lib/python3.12/site-packages/pyparsing/__pycache__/results.cpython-312.pyc
T

488 lines
35 KiB
Plaintext
Raw Normal View History

feat: rigorous physics revision for Paper 1 based on adversarial review
2026-06-01 22:22:35 +00:00
Ë
vRjÓkãó—UddlmZddlZddlmZmZmZmZmZddl Z ddl
m Z ddl m
Z
mZmZeefZded<ed „d
D««Zed«Zd ed <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—eZdZUded<dgZdd„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óÈ—eZdZUdZdgdfZded<ded<ded<d ed
<d ed <d
ed<ded<dZGd„de«Zd>d„Z dddde
f d?d„Z d„Z e
fd„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ó—eZdZdZdd„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›dt |«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|ddgn
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|ddd¬«}|xr|}|||_|�|dk(ry||t«r t|«}|s|h|_||_||j vry||ttf«r|g}|rV||t«r#tt|j«d«||<ntt|d«d«||<|||_y |d||<y#tttf$r||ur|||<Yy||_YywxYw)NÚasListTÚaslist)Únew_nameÚr)r r=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||jvr|j
|ddSt
|j
|D�cgc]}|d‘Œ c}«Scc}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««|gz|j|<|d}n^||tt
f«r||j |<|}n9|jj|g«t|d«gz|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|dkr||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__2s€Ø�D—M‘MÐ!Ð!r!có,—t|j«Sr)rfr>r's rÚ__len__zParseResults.__len__5s€Ü�4—=‘=Ó!Ð!r!có:—|jxs |j Sr)r>r?r's rÚ__bool__zParseResults.__bool__8s€ØŸ
™
Ò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.keysAr~r!có6‡—ˆfd„‰j«D«S)Nc3ó(•K—|] }‰|–—Œ y­wrr©rrars €rrz&ParseResults.values.<locals>.<genexpr>Esøèø€Ò-˜A��Q•Ñ-ùsƒ©r‚r's`rrjzParseResults.valuesDsø€Û- §¡£Ô-Ð-r!có6‡—ˆfd„‰j«D«S)Nc3ó,•K—|] }|‰|f–—Œ
y­wrrr…s €rrz%ParseResults.items.<locals>.<genexpr>Hsøèø€Ò2 ��D˜‘G” Ñ2ùsƒr†r's`rÚitemszParseResults.itemsGsø€Û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.haskeysJs€ð—}‘}Ð$Ð$Ð$r!cóì—|sdg}|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.popPs¢€ñ\Ø�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—|jdd…=|jj«y)z7
Clear all elements and results names.
N)r>r?rer's rrezParseResults.clears €ð
�M‰Mš!Ð Ø �
‰
×ÑÕr!cód— ||S#t$r|jd«r t|«‚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«Šˆfd„}|jj«}|D���cgc]&\}}|D]}|t |d||d««f‘ŒŒ(}}}}|D](\}}|||<t |dt «sŒ||d_Œ*|xj|jz
c_|xj|jzc_|Scc}}}w)Ncó•—|dkr‰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|dk(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
ó²—ddj|jD�cgc](}t|t«r t |«n
t |«‘Œ*c}«zdzScc}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}Scc}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‡—ˆfd„Štˆfd„|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|Scc}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à�
ùò<UsA
c3ó8•K—|]\}}|‰|«f–—Œy­wrr)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|_|xj
|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
c3ó`K—|]&}t|t«r|j«n|–—Œ(y­wr)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 ˆfd„|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
c3óD•K—|]\}}|D]
\}}|‰ur|–—ŒŒy­wrr)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««znd«|sdj|«S|j «rÈt d„|j
«D««}|D]£\}} |r|j|«|j|›d|z›d|›d�«t| t«s|jt| ««Œ`| s|jt| ««Œ}|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")
Reference in new issue Copy Permalink