^Wݫ U d dl mZmZmZmZ d dlZd dlmZ d dl m
Z
m Z e e
fZe
edf ed< ed dD Z G d d
Z G d d Z ej e ej e dS )
)MutableMappingMappingMutableSequenceIteratorN)ref)TupleAny.str_typec # K | ]}|V d S N ).0_s /builddir/build/BUILDROOT/alt-python311-setuptools-65.6.3-2.el9.x86_64/opt/alt/python311/lib/python3.11/site-packages/setuptools/_vendor/pyparsing/results.py r s a r
c , e Zd ZdgZd Zd Zd Zd ZdS )_ParseResultsWithOffsettupc ||f| _ d S r r )selfp1p2s r __init__z _ParseResultsWithOffset.__init__ s 8r c | j | S r r r is r __getitem__z#_ParseResultsWithOffset.__getitem__ s x{r c | j S r r r s r __getstate__z$_ParseResultsWithOffset.__getstate__ s xr c |d | _ d S Nr r )r argss r __setstate__z$_ParseResultsWithOffset.__setstate__ s 7r N)__name__
__module__ __qualname__ __slots__r r r" r& r
r r r r sW I r r c e Zd ZU dZdg ddfZeedf ed< g dZ G d d e Z
d3d
Z ddd d e fd Z
d
Ze fdZd ZdefdZdefdZdefdZdefdZdefdZd Zd Zd ZdefdZ d Z d4dZ d Z d Z d Z!d Z"d Z#d5d!Z$d5d"Z%d5d#Z&de'fd$Z(de'fd%Z)d6d&Z*de fd'Z+de,fd(Z-d5d)Z.d* Z/d7de'fd,Z0d- Z1d. Z2d/ Z3d0 Z4d1 Z5e6d4d5d2 Z7e+Z8e-Z9e/Z:dS )8 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.`` - 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 r
. _null_values)_name_parent
_all_names_modal_toklist_tokdict __weakref__c e Zd ZdZddZdS )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, )
[2,3,4]
([2, 3, 4], )
[[2, 1],3,4]
([[2, 1], 3, 4], )
(Used internally by :class:`Group` when `aslist=True`.)
Nc |g }t |t s:t d | j t | j t | S )Nz.{} may only be constructed with a list, not {})
isinstancelist TypeErrorformatr' type__new__)cls containeds r r> zParseResults.List.__new__| sd i..
$fS\4 ??3K L L
<<$$ $r r )r' r( r) __doc__r> r
r r Listr7 U s3 $ $ L
%
%
%
%
%
%r rB c t |t r|S t | }d |_ d |_ t
|_ |g |_ n^t |t t f r:t |t j r |d d gnt | |_ n|g|_ t |_
|S r )r9 r, objectr> r/ r0 setr1 r3 r: _generator_typerB dictr4 )r? toklistnamekwargsr s r r> zParseResults.__new__ s g| , , N~~c""
%% ? DMM
$!8
9
9 & g|'899# ']]
MM %IDM
r Tc 4 || _ | |dk r ||t rt | }|s|h| _ || _ || j vr ||t t f r|g}|rl ||t r&t t |j
d | |< n&t t |d d | |< || | _ d S |d | |< d S # t t t f$ r || ur|| |< Y d S || _ Y d S w xY wd S d S d S )Nr- r )r2 intstrr1 r/ r. r
r= r, r r3 KeyErrorr;
IndexError)r rH rI asListmodalr9 s r r zParseResults.__init__ sl
z$$$
!4yy
)#'& DJd /// :g$'788 ( &iG .!z'<88 %< ()9 : :A& &T
&= ( 4 4a& &T
(,DJ$$$.%,QZT
$i< . . ."$..)0DJJJJ)-DJJJJ .-
0/s C# # DDDc t |t t f r
| j | S || j vr| j | d d S t
d | j | D S )Nr c g | ]
}|d S )r r
)r vs r
z,ParseResults.__getitem__.. s $D$D$DaQqT$D$D$Dr )r9 rL slicer3 r1 r4 r, r s r r zParseResults.__getitem__ sn a#u & & F=# #''}Q'+A..#$D$D4=3C$D$D$DEEEr c ||t r<| j |t |gz | j |< |d }nh ||t t
f r
|| j |< |}nC| j |t t |d gz | j |< |} ||t rt | |_ d S d S r$ )
r r4 getr: rL rW r3 r, wkrefr0 )r krU r9 subs r __setitem__zParseResults.__setitem__ s :a0 1 1
#} 0 0DFF ; ;qc ADM! A$CC
ZC<
(
( DM! CC #} 0 0DFF ; ;'1--? DM! C :c< ( ( & ++CKKK & &r c t |t t f rt | j }| j |= t |t r |dk r||z
}t ||dz }t t
| | }| | j
D ]<\ }}|D ]4}t | D ]"\ }\ }} t || | |k z
||< #5=d S | j |= d S )Nr )
r9 rL rW lenr3 r: rangeindicesreverser4 items enumerater )
r r mylenremovedrI occurrencesjr[ valuepositions
r __delitem__zParseResults.__delitem__ s1 a#u & & !
&&E
a !S!!
$q55JA!QUOO5!))E"2"2344G OO %)]%8%8%:%:
!k A09+0F0F ,,E8)@ !8x!|#<* * A
a r returnc || j v S r )r4 )r r[ s r __contains__zParseResults.__contains__ s DM!!r c * t | j S r )r` r3 r! s r __len__zParseResults.__len__ s 4=!!!r c " | j p| j S r )r3 r4 r! s r __bool__zParseResults.__bool__ s
6 777r c * t | j S r iterr3 r! s r __iter__zParseResults.__iter__ DM"""r c < t | j d d d S )NrS ru r! s r __reversed__zParseResults.__reversed__ s DM$$B$'(((r c * t | j S r )rv r4 r! s r keyszParseResults.keys rx r c D fd D S )Nc 3 ( K | ] }| V
d S r r
r r[ r s r r z&ParseResults.values.. s' --AQ------r r| r! s `r valueszParseResults.values s% --------r c D fd D S )Nc 3 , K | ]}|| fV d S r r
r s r r z%ParseResults.items.. s+ 22DG 222222r r r! s `r rd zParseResults.items s% 2222diikk2222r c * 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.)boolr4 r! s r haskeyszParseResults.haskeys s DM"""r c R |sdg}| D ]7\ }}|dk r |d |f}t d | t |d t s t | dk s
|d | v r|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']
rS defaultr z-pop() got an unexpected keyword argument {!r}r_ )rd r; r< r9 rL r` )r r% rJ r[ rU indexret defaultvalues r popzParseResults.pop s P 4DLLNN DAqI~~ Q| CJJ1MM d1gs # # s4yyA~~aD GEu+CU J 7L r c || v r| | S |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
r
)r key
default_values r rY zParseResults.getF s $ $;;9 r c | j || | j D ]7\ }}t | D ]"\ }\ }}t ||||k z ||< #8dS )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)r3 insertr4 rd re r )r r
ins_stringrI rh r[ rj rk s r r zParseResults.insert] s "
UJ///!% !4!4!6!6 D+(1+(>(>
$$E8!88x%'78" " A
r c : | j | dS )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)r3 append)r items r r zParseResults.appendv s
T"""""r c t |t r| | dS | j | dS )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)r9 r, __iadd__r3 extend)r itemseqs r r zParseResults.extend sJ g| , , * MM' " " " " " M ) ) ) ) )r c L | j dd= | j dS )z7
Clear all elements and results names.
N)r3 r4 clearr! s r r zParseResults.clear s,
M!!!
r c ~ | | S # t $ r( | d rt | Y dS w xY w)N__r- )rN
startswithAttributeError)r rI s r __getattr__zParseResults.__getattr__ sU : t$$
+$T***22 s
.<<c 8 | }||z
}|S r )copy)r otherr s r __add__zParseResults.__add__ s iikk u
r c p |j rt | j fd|j }fd|D }|D ]?\ }}|| |< t |d t
rt
| |d _ @| xj |j z
c_ | xj |j z c_ | S )Nc | dk rn| z S r$ r
)aoffsets r z'ParseResults.__iadd__.. s AEE&&q6z r c n g | ]1\ }}|D ])}|t |d |d f*2S )r r_ )r )r r[ vlistrU addoffsets r rV z)ParseResults.__iadd__.. sd Au +AaD))AaD//BBC r r ) r4 r` r3 rd r9 r, rZ r0 r1 )r r
otheritemsotherdictitemsr[ rU r r s @@r r zParseResults.__iadd__ s > / ''FAAAAI --//J * N
'
/
/1Q adL11 /#(;;AaDL
'
5++ r c j t |t r|dk r| S || z S r$ )r9 rL r )r r s r __radd__zParseResults.__radd__ s6 eS ! ! eqjj99;; 4< r c d t | j | j | S )Nz {}({!r}, {}))r< r= r' r3 as_dictr! s r __repr__zParseResults.__repr__ s- $$T$ZZ%8$- XXXr c V dd d | j D z dz S )N[z, c t g | ]5}t |t rt | nt | 6S r
)r9 r, rM repr)r r s r rV z(ParseResults.__str__.. sG )L 9 9FCFFFtAww r ])joinr3 r! s r __str__zParseResults.__str__ sH ii !]
r c g }| j D ]j}|r|r| | t |t r|| z
}H| t | k|S r )r3 r r9 r,
_asStringListrM )r sepoutr s r r zParseResults._asStringList s M & &D
s
3$ --
&t))+++
3t99%%%%
r c $ 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) # -> ['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']
c d g | ]-}t |t r| n|.S r
)r9 r, as_list)r ress r rV z(ParseResults.as_list.. sC
(\ : : CCKKMMM
r )r3 r! s r r zParseResults.as_list s%
}
r c h fdt fd| 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)) # -> (['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 t | t r6| r| n
fd| D S | S )Nc & g | ]
} | S r
r
)r rU to_items r rV z9ParseResults.as_dict..to_item.. s! ;T;T;T1GGAJJ;T;T;Tr )r9 r, r r )objr s r r z%ParseResults.as_dict..to_item
sO #|,,
(+
Ts{{}}};T;T;T;TPS;T;T;TT
r c 3 8 K | ]\ }}| | fV d S r r
)r r[ rU r s r r z'ParseResults.as_dict.. s3 ==1Q
O======r )rG rd )r r s @r r zParseResults.as_dict sI * ====
======r c t | j }| j |_ | j |_ |xj | j z c_ | j |_ |S )zG
Returns a new copy of a :class:`ParseResults` object.
)r, r3 r4 r r0 r1 r/ )r r s r r zParseResults.copy sQ 4=))}))++ l $/)J
r c | j r| j S | j r(| fd}r || ndS t | dk rt | j dk rtt t | j d d dv r3t t | j S dS )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 l t fdj D d S )Nc 3 : K | ]\ }}|D ]
\ }}|u |V d S r r
)r r[ r rU locr\ s r r z@ParseResults.get_name..find_in_parent..@ sS $Au&+ #As !88 $8888 r )nextr4 rd )r\ pars `r find_in_parentz-ParseResults.get_name..find_in_parent> sO (+ (:(:(<(< r Nr_ r )r rS )r/ r0 r` r4 r rv r r| )r r r s @r get_namezParseResults.get_name s 2 : :
\ ,,..C
,/8>>$'''D 8 IINNDM""a''T$-..00112215a8GCCT] / / 1 12233 34r r c t g }d}| |r$|t | z nd |r| rt d | D }|D ]\ }} |r| | | d |d|z | t | t rU| r0| | ||||dz | t | | t | t d | D r| } t | D ]\ }
} t | t rQ| d |d|z |
|d|dz z | ||||dz k| d
|d|z |
|d|dz z t | fz d
| 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 3 > K | ]\ }}t | |fV d S r )rM )r r[ rU s r r z$ParseResults.dump..n s0 D Dtq!A{ D D D D D Dr z
{}{}- {}: z r_ )indentfull include_list_depthc 3 @ K | ]}t |t V d S r )r9 r, )r vvs r r z$ParseResults.dump.. s, ??B:b,//??????r z
{}{}[{}]:
{}{}{}z
%s%s[%d]:
%s%s%s)r rM r r sortedrd r< r9 r, dumpr anyre r ) r r r r r r NLrd r[ rU r r s r r zParseResults.dumpS s *
<G6C / ///RHHH 3 ||~~
, D Dtzz|| D D DDD ! , ,DAq '
2JJ| 2 26D6MA N NOOO!!\22
,
/ JJ !+1)-1=+1A: !' !" !" JJs1vv . . . .
477++++??$?????
&q\\ EAr!"l33
1 8 8 &!% ! &!%!!4 "+1)-1=+1A: !( !" !"
1 &!% ! &!%!!4 #B
wws||r c T t j | g|R i | dS )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(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% rJ s r r zParseResults.pprint s2 2
dllnn6t666v66666r c | j | j | j d ur| pd | j | j ffS r )r3 r4 r r0 r1 r/ r! s r r" zParseResults.__getstate__ sM M
""$$ D(;T\\^^Ct
r c |\ | _ \ | _ }}| _ t | | _ |t | | _ d S d | _ d S r )r3 r4 r/ rE r1 rZ r0 )r stater inAccumNamess r r& zParseResults.__setstate__ sK HME
E
sL$* l++ ? ::DLLL DLLLr c | j | j fS r )r3 r/ r! s r __getnewargs__zParseResults.__getnewargs__ s }dj((r c ~ t t | t | z S r )dirr= r: r| r! s r __dir__zParseResults.__dir__ s) 4::diikk!2!222r c d } | g }| D ]P\ }}t |t r|| || z
}5| | |g| || z
}Q| | |g| }|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 p t | t | t S # t $ r Y dS w xY w)NF)rv r9 r
Exception)r s r is_iterablez+ParseResults.from_dict..is_iterable sK
5S &c84444
uu
s '
55)rI )rI rP )rd r9 r from_dict)r? r rI r r r[ rU s r r zParseResults.from_dict s 5 5 5 c"ggKKMM ? ?DAq!W%%
?s}}QQ}///ssA3Q{{1~~>>>> #se$'''C
r )NNr )rm r, )r- )r- TTr );r' r( r) rA r. r r __annotations__r* r: rB r> r9 r r r] rl r ro rL rq rs r rw rz r| r rd r r rY r r r r r r r r rM r r r r rG r r r r r r" r& r r classmethodr rP asDictgetNamer
r r r, r, s + +Z &*2r2$6L%S/666 I1% 1% 1% 1% 1%t 1% 1% 1%f 0 d$: . . . .@F F F ,6
&
&
&
& ! ! !." " " " "" " " " "8$ 8 8 8 8#( # # # #)h ) ) ) )# # #. . .3 3 3# # # # # 8 8 8 t! ! ! !. 2# # #"* * *(
& Y# Y Y Y Y
(> > > > >: 1 1 1fN N N N N N `7 7 78
) ) )3 3 3 [2 F
FGGGr r, )collections.abcr r r r r weakrefr rZ typingr r rM bytesr
r= r rF r r, registerr
r r r s N N N N N N N N N N N N N
!5\%c
) ) )$2''
Y Y Y Y Y Y Y Y x % % % & & & & &r