2biDh % S SK JrJrJrJrJrJr S SKrS SKJ r J
r
J r J r J
r
\\4r\ \S4 \S' \" S S 5 5 r " S S 5 r " S
S 5 r\R, " \5 \R, " \5 g) )MutableMappingMappingMutableSequenceIteratorSequence ContainerN)TupleAnyDictSetList.str_typec # $ # U H ov M g 7fN ).0_s ڏ/builddir/build/BUILDROOT/alt-python313-pip-23.3.1-3.el8.x86_64/opt/alt/python313/lib/python3.13/site-packages/pip/_vendor/pyparsing/results.py r s 2a2s r c T \ rS rSr% \S\4 \S' S/rSSS\4S jrS r S r
S r S
r g ) _ParseResultsWithOffset ParseResultstupp1p2c X4U l g r r )selfr r s r __init__ _ParseResultsWithOffset.__init__ s .0X c U R U $ r r r is r __getitem__#_ParseResultsWithOffset.__getitem__ s xx{r" c U R $ r r r s r __getstate__$_ParseResultsWithOffset.__getstate__ s xxr" c US U l g Nr r )r argss r __setstate__$_ParseResultsWithOffset.__setstate__ s
7r" r N)
__name__
__module__ __qualname____firstlineno__r int__annotations__ __slots__r r& r* r/ __static_attributes__r r" r r r s; ~s" ##I6> 6s 6r" r c @ \ rS rSr% SrS/ S4r\\S4 \S' \ \S' S \S' \
\ \S ' \ \S
' \ \ \S ' \
\ \4 \S ' S
r " S S\5 r S:S jrSSSS\4S jrS r\4S jrS rS\ 4S jrS\4S jrS\ 4S jrS\4S jrS\4S jr S r S r S r S\ 4S jr S r!S;S! jr"S" r#S# r$S$ r%S% r&S& r'SS, jr-S\4S- jr.S\/4S. jr0S=S/ jr1S=S0 jr2S1 r3S?S\ 4S2 jjr4S3 r5S4 r6S5 r7S6 r8S7 r9\:S;S=S8 jj5 r;\.r< \0r= \3r>S9r?g)@r " 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.`` - 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(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::
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 . _null_values_name_parent
_all_names_modal_toklist_tokdict)r< r= r> r? r@ rA c " \ rS rSrSrSS jrSrg)zParseResults.Listb a
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.DelimitedList(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, )
[2,3,4]
([2, 3, 4], )
[[2, 1],3,4]
([[2, 1], 3, 4], )
(Used internally by :class:`Group` when `aslist=True`.)
Nc Uc / n[ U[ 5 ( d- [ U R S[ U5 R 35 e[ R U 5 $ )Nz* may only be constructed with a list, not )
isinstancelist TypeErrorr1 type__new__)cls containeds r rI ParseResults.List.__new__ sW i.. ||n$NtT]OgOgNhi <<$ $r" r r )r1 r2 r3 r4 __doc__rI r8 r r" r r
ParseResults.Listb s
$ L %r" r
c ~ [ U[ 5 ( a U$ [ R U 5 nS Ul S Ul [
5 Ul Uc / Ul OY[ U[ [ 45 ( a6 [ U[ R 5 ( a US S /O
[ U5 Ul OU/Ul [ 5 Ul
U$ r )rE r objectrI r< r= setr> r@ rF _generator_typer
dictrA )rJ toklistnamekwargsr s r rI ParseResults.__new__ s g| , ,N~~c"
% ? DM
$!8
9
9 g|'8'899 ']
M %IDM
r" Tc U X@l Ub US:w a U" U[ 5 ( a [ U5 nU( d U1U l X l XR
; a U" U[ [ 45 ( a U/nU( aX U" U[ 5 ( a" [ [ UR 5 S5 X' O[ [ US 5 S5 X' X U l g US X' g g g g ! [ [ [ 4 a XLa XU' g X l g f = f)N r )r? r5 strr> r< r; r rH r r r@ KeyErrorrG
IndexError)r rT rU asListmodalrE s r r ParseResults.__init__ s
$$$4y#'& J / // g$'788 &iG!'<88%< ()9)9 :A&
&= ( 4a&
(,J$.%,QZ
0
!+ , %i< .".)0J)-J .s C D8D Dc [ U[ [ 45 ( a U R U $ XR ; a U R
U S S $ [
U R
U Vs/ s H o"S PM sn5 $ s snf )Nr )rE r5 slicer@ r> rA r )r r% vs r r& ParseResults.__getitem__ so a#u & &==# #'}}Q'+A..#4==3C$D3CaqT3C$DEE$Ds %A:c U" U[ 5 ( a; U R R U[ 5 5 U/- U R U' US nOjU" U[ [
45 ( a X R U' UnOAU R R U[ 5 5 [ US5 /- U R U' UnU" U[ 5 ( a Xl g g r- ) r rA getrF r5 rb r@ r r= )r krc rE subs r __setitem__ParseResults.__setitem__ s a0 1 1 #}} 0 0DF ;qc ADMM! A$C
C<
(
( MM! C #}} 0 0DF ;'1-? DMM! C c< ( ( K )r" c [ U[ [ 45 ( a [ U R 5 nU R U [ U[ 5 ( a US: a X-
n[ XS- 5 n[ [
UR U5 6 5 nUR 5 U R R 5 H7 u pEU H, n[ U5 H u nu p[ XX: -
5 XW' M M. M9 g U R U g )Nr )
rE r5 rb lenr@ rF rangeindicesreverserA items enumerater )
r r% mylenremovedrU occurrencesjrg valuepositions
r __delitem__ParseResults.__delitem__ s a#u & &
&E
a !S!!q5JA!UO5!))E"234G OO %)]]%8%8%:! A09+0F,,E)@ !x|#<* 1G ! &;
a r" returnc XR ; $ r rA )r rg s r __contains__ParseResults.__contains__ s MM!!r" c , [ U R 5 $ r )rm r@ r) s r __len__ParseResults.__len__ s 4==!!r" c H U R =( d U R ( $ r )r@ rA r) s r __bool__ParseResults.__bool__ s
6 77r" c , [ U R 5 $ r iterr@ r) s r __iter__ParseResults.__iter__ DMM""r" c 8 [ U R S S S2 5 $ )Nra r r) s r __reversed__ParseResults.__reversed__ s DMM$B$'((r" c , [ U R 5 $ r )r rA r) s r keysParseResults.keys
r r" c 8 ^ U 4S jT R 5 5 $ )Nc 3 . ># U H
nTU v M g 7fr r r rg r s r r &ParseResults.values.. s -AQs r r) s `r valuesParseResults.values
s ---r" c 8 ^ U 4S jT R 5 5 $ )Nc 3 0 ># U H oTU 4v M
g 7fr r r s r r %ParseResults.items.. s 2kDG ks r r) s `r rq ParseResults.items s 2diik22r" 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 haskeysParseResults.haskeys s }}$$r" c U( d S/nUR 5 H! u p4US:X a US U4nM [ SU< 35 e [ US [ 5 ( d [ U5 S:X d US U ; a
US nX nX U$ US nU$ )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']
ra defaultr z)pop() got an unexpected keyword argument rl )rq rG rE r5 rm )r r. rV rg rc indexret defaultvalues r popParseResults.pop s P 4DLLNDAI~ Q| "KA5 QRR #
d1gs # #s4yA~aD GE+C J 7L 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::
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
r )r key
default_values r rf ParseResults.getQ s $ ;9 r" c U R R X5 U R R 5 H. u p4[ U5 H u nu pg[ XgXq: - 5 XE' M M0 g)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@ insertrA rq rr r )r r
ins_stringrU ru rg rw rx s r r ParseResults.inserth s^ "
U/!% !4!4!6 D(1+(>$$E!8x'78" )? "7r" c : U R R U5 g)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 items r r ParseResults.append s
T"r" c [ U[ 5 ( a U R U5 gU R R U5 g)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)rE r __iadd__r@ extend)r itemseqs r r ParseResults.extend s/ g| , , MM' " MM )r" c V U R SS2 U R R 5 g)z'
Clear all elements and results names.
N)r@ rA clearr) s r r ParseResults.clear s
MM!
r" c n X $ ! [ a$ UR S5 ( a [ U5 e gf = f)N__rY )r[
startswithAttributeError)r rU s r __getattr__ParseResults.__getattr__ s; : t$$$T** s +44c . U R 5 nX!-
nU$ r )copy)r otherr s r __add__ParseResults.__add__ s iik
r" c ^ U( d U $ UR ( a [ U R 5 mU4S jnUR R 5 nU VVVs/ s H) u pEU H nU[ US U" US 5 5 4PM M+ nnnnU H, u pFX`U' [ US [ 5 ( d M# XS l M. U =R UR -
sl U =R UR - sl U $ s snnnf )Nc > U S: a T$ U T- $ r- r )aoffsets r 'ParseResults.__iadd__.. s AE&"Aq6z"Ar" r rl ) rA rm r@ rq r rE r r= r> ) r r addoffset
otheritemsrg vlistrc otherdictitemsr s @r r ParseResults.__iadd__ s K >> 'FAI --/J !+ *HA A +AaD)AaD/BC D *
'Q adL11#'aDL '
'
5+++ s 0C=c ` [ U[ 5 ( a US:X a U R 5 $ X- $ r- )rE r5 r )r r s r __radd__ParseResults.__radd__ s+ eS ! !eqj99; < r" c p [ U 5 R SU R < SU R 5 S3$ )N(, ))rH r1 r@ as_dictr) s r __repr__ParseResults.__repr__ s2 t*%%&a
'84<<>:J!LLr" c
SSR U R Vs/ s H. n[ U[ 5 ( a [ U5 O
[ U5 PM0 sn5 - S- $ s snf )N[r ])joinr@ rE r rZ reprr$ s r __str__ParseResults.__str__ sd ii "]] * )L 9 9CFtAwF *
s 5A
c / nU R He nU( a U( a UR U5 [ U[ 5 ( a X#R 5 -
nMK UR [ U5 5 Mg U$ r )r@ r rE r
_asStringListrZ )r sepoutr s r r ParseResults._asStringList sZ MMDs
3$ --))++
3t9%
"
r" c U R Vs/ s H* n[ U[ 5 ( a UR 5 OUPM, sn$ s snf )a(
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) # -> ['sldkj', 'lsdkj', 'sldkj']
# Use as_list() to create an actual list
result_list = result.as_list()
print(type(result_list), result_list) # -> ['sldkj', 'lsdkj', 'sldkj']
)r@ rE r as_list)r ress r r ParseResults.as_list sD " }}
$ (\ : :CKKM C$
s 1Ac V ^ U4S jm[ U4S jU R 5 5 5 $ )aG
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)) # -> (['12', '/', '31', '/', '1999'], {'day': [('1999', 4)], 'year': [('12', 0)], 'month': [('31', 2)]})
result_dict = result.as_dict()
print(type(result_dict), repr(result_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 > [ U [ 5 ( a> U R 5 ( a U R 5 $ U Vs/ s H nT" U5 PM
sn$ U $ s snf r )rE r r r )objrc to_items r r %ParseResults.as_dict..to_item sL #|,,(+
s{{}TPS;TPS1GAJPS;TT
# U H u pUT" U5 4v M g 7fr r )r rg rc r s r r 'ParseResults.as_dict..! s = Q
O s )rS rq )r r s @r r ParseResults.as_dict s! * =
===r" c [ U R 5 nU R R 5 Ul U R Ul U=R
U R
- sl U R Ul U$ )z
Returns a new shallow copy of a :class:`ParseResults` object. `ParseResults`
items contained within the source are shared with the copy. Use
:class:`ParseResults.deepcopy()` to create a copy with its own separate
content values.
)r r@ rA r r= r> r< )r r s r r ParseResults.copy# sS 4==)}}))+ ll $//)JJ
r" c p U R 5 n[ U R 5 GH u p#[ U[ 5 ( a UR 5 U R U' M: [ U[ [ 45 ( a MW [ U[ 5 ( ac [ U5 " 5 =U R U' nUR 5 H. u pV[ U[ 5 ( a UR 5 OUXE' M0 M [ U[ 5 ( d M [ U5 " S U 5 5 U R U' GM U$ )z<
Returns a new deep copy of a :class:`ParseResults` object.
c 3 p # U H, n[ U[ 5 ( a UR 5 OUv M. g 7fr )rE r deepcopy)r rc s r r (ParseResults.deepcopy..A s+ -PS1Jq,$?$?AJJLQFPSs 46) r rr r@ rE r r rZ bytesr rH rq r )r r r% r destrg rc s r r ParseResults.deepcopy1 s iik
.FA#|,,#&<<>
a C#u ..C 00*.s)+5
a 4 IIKDA.8L.I.IajjlqDG (C++#'9 -PS- $
a /
r" c ^ T R ( a T R $ T R ( a< T R nUR R 5 n[ U 4S jU 5 S5 $ [ 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::
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 3 R ># U H u pU H u p4UTL d M Uv M M g 7fr r )r rg r rc locr s r r (ParseResults.get_name..e s2 $8"'Dy A"' $8s '
'Nrl r )r ra ) r< r= rA rq nextrm r r r )r parparent_tokdict_itemss ` r get_nameParseResults.get_nameF s 2 ::::
\\"&,,C#&<<#5#5#7 $8
INDMM"a'T$--..01215a8GCT]] / / 123 3r" c / nSnUR U( a U[ U R 5 5 - OS5 U( Ga U R 5 ( a [ S U R 5 5 5 nU H u pU( a UR U5 UR U SU- SU S35 [
U [ 5 ( aI U ( a& UR U R UUUUS- S95 M{ UR [ U 5 5 M UR [ U 5 5 M [ S U 5 5 ( a U n [ U 5 H u p[
U [ 5 ( aC UR S
R USU- U
USUS- - U R UUUUS- S95 5 M] UR S USU- U
USUS- - [ U 5 4- 5 M SR U5 $ ) 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::
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'
rY c 3 @ # U H u p[ U5 U4v M g 7fr )rZ )r rg rc s r r $ParseResults.dump.. s D|tqA{|s z z- z: rl )indentfull include_list_depthc 3 B # U H n[ U[ 5 v M g 7fr )rE r )r vvs r r r s ?$B:b,//$s z
{}{}[{}]:
{}{}{}z
%s%s[%d]:
%s%s%s)r rZ r r sortedrq rE r dumpr anyrr formatr ) r r r
r r r NLrq rg rc r% r s r r ParseResults.dumpv s *
<6C //RH ||~~ Dtzz| DD !DA
2JJ&4&=):"QCr BC!!\22 JJ !+1)-1=+1A: !' !" JJs1v .
47+# "$ ?$??? &q\EA!"l33
1 8 8 &!% ! &!%!!4 "+1)-1=+1A: !( !"
1 &!% ! &!%!!4 #B
% *< wws|r" c T [ R " U R 5 /UQ70 UD6 g)a
Pretty-printer for parsed results as a list, using the
`pprint `_ module.
Accepts additional positional or keyword args as defined for
`pprint.pprint `_ .
Example::
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::
['fna',
['a',
'b',
['(', 'fnb', ['c', 'd', '200'], ')'],
'100']]
N)pprintr )r r. rV s r r ParseResults.pprint s 2
dlln6t6v6r" c ~ U R U R R 5 S U R U R 44$ r )r@ rA r r> r< r) s r r* ParseResults.__getstate__ s9 MM
""$
r" c b Uu U l u U l p#U l [ U5 U l S U l g r )r@ rA r< rQ r> r= )r stater inAccumNamess r r/ ParseResults.__setstate__ s, HME
E
s$* l+ r" c 2 U R U R 4$ r )r@ r< r) s r __getnewargs__ParseResults.__getnewargs__ s }}djj((r" c ^ [ [ U 5 5 [ U R 5 5 - $ r )dirrH rF r r) s r __dir__ParseResults.__dir__ s 4:diik!222r" c S nU " / 5 nUR 5 H= u pV[ U[ 5 ( a X@R XeS9-
nM- X@" U/XS" U5 S9-
nM? Ub U " U/US9nU$ )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 d [ U 5 [ U [ 5 ( + $ ! [ a gf = f)NF)r rE r Exception)r s r is_iterable+ParseResults.from_dict..is_iterable s4
5S
&c8444
s "
//)rU )rU r] )rq rE r from_dict)rJ r rU r( r rg rc s r r* ParseResults.from_dict sx 5 "gKKMDA!W%%}}Q}//sA3Q{1~>> "
se$'C
r" )r> r? r< r= rA r@ )NNr )r r r{ r )r{ r )rY )rY TTr )@r1 r2 r3 r4 rM r; r r
r6 rZ r boolr
r r7 rF rI rE r r& ri ry r~ r5 r r r r r r r rq r r rf r r r r r r r r r r r r rS r r r r r r r* r/ r r# classmethodr* r] asDictgetNamer8 r r" r r r " s +Z &*2rNL%S/2 J
C L3i38n I0%t 0%d0 d$: .BF ,6
!." "" "8$ 8#( #)h )#.3% % 6 p!.2#"*(
, M# M
(> >: *.`N N `78
)3 4 F+
F+G,r" r )collections.abcr r r r r r r typingr r
r r r
rZ r r rH r6 rR r r registerr r" r r3 sy . . !5\%c
)2' "v - v -r % &r"