R`iDh U d dl mZmZmZmZmZmZ d dlZd dlm Z m
Z
m Z m Z m
Z
eefZe edf ed< ed dD Z G d d Z G d
d Z ej, e ej, e y) )MutableMappingMappingMutableSequenceIteratorSequence ContainerN)TupleAnyDictSetList.str_typec # K | ] }| y wN ).0_s /builddir/build/BUILDROOT/alt-python312-pip-23.3.1-3.el8.x86_64/opt/alt/python312/lib/python3.12/site-packages/pip/_vendor/pyparsing/results.py r s 2a2s r c J e Zd ZU edef ed< dgZdddefdZd Zd Z d Z
y )
_ParseResultsWithOffset ParseResultstupp1p2c ||f| _ y r r )selfr r s r __init__z _ParseResultsWithOffset.__init__ s
.0"X c | j | S r r r is r __getitem__z#_ParseResultsWithOffset.__getitem__ s xx{r c | j S r r r s r __getstate__z$_ParseResultsWithOffset.__getstate__ s xxr c |d | _ y Nr r )r argss r __setstate__z$_ParseResultsWithOffset.__setstate__ s
7r N) __name__
__module__ __qualname__r int__annotations__ __slots__r r$ r' r+ r r r r r s; ~s" ##I6> 6s 6r r c e Zd ZU dZdg dfZeedf ed< eed< d ed< e e ed< e
ed < e e ed
< e eef ed < d Z
G d
de Z d8dZddddefdZd ZefdZd Zde
fdZdefdZde
fdZdefdZdefdZd Z d Z d Z de
fd Z d Z d9d Z!d! Z"d" Z#d# Z$d$ Z%d% Z&d:d&Z'd:d'Z(d;d(Z)defd)Z*defd*Z+dr 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)r4 r5 r6 r7 r8 r9 c e Zd ZdZddZy)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.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 |g }t |t s-t | j dt | j t j | S )Nz* may only be constructed with a list, not )
isinstancelist TypeErrorr, type__new__)cls containeds r rA zParseResults.List.__new__ sT i. ||n$NtT]OgOgNhi <<$ $r r )r, r- r. __doc__rA r r r r
r; b s
$ L %r r
c ^ t |t r|S t j | }d |_ d |_ t
|_ |g |_ nOt |t t f r1t |t j r|d d gn
t | |_ n|g|_ t |_
|S r )r= r objectrA r4 r5 setr6 r8 r> _generator_typer
dictr9 )rB toklistnamekwargsr s r rA zParseResults.__new__ s g| ,N~~c"
% ? DM
$!8
9 g|'8'89 ']
M %IDM
r Tc | || _ ||dk7 r ||t r t | }|s|h| _ || _ || j
vrx ||t t f r|g}|rV ||t r#t t |j d | |< nt t |d d | |< || | _ y |d | |< y y y y # t t t f$ r || ur|| |< Y y || _ Y y w xY w)N r )r7 r/ strr6 r4 r3 r r@ r r r8 KeyErrorr?
IndexError)r rJ rK asListmodalr= s r r zParseResults.__init__ s
$$4y#'& DJd / // g$'78 &iG!'<8%< ()9)9 :A&T
&= ( 4a&T
(,DJ$.%,QZT
0
!+ , %i< ."$.)0DJ)-DJ .s 7C C,"C,+C,c t |t t f r| j | S || j vr| j
| d d S t
| j
| D cg c] }|d c} S c c}w )Nr )r= r/ slicer8 r6 r9 r )r r# vs r r$ zParseResults.__getitem__ sp a#u &==# #'}}Q'+A..#4==3C$D3CaQqT3C$DEE$Ds A2c ||t r;| j j |t |gz | j |< |d }nf ||t t
f r|| j |< |}nA| j j |t t |d gz | j |< |} ||t r| |_ y y r) ) r r9 getr> r/ rV r8 r r5 )r krW r= subs r __setitem__zParseResults.__setitem__ s a0 1 #}} 0 0DF ;qc ADMM! A$C
C<
( DMM! C #}} 0 0DF ;'1-? DMM! C c< ( CK )r c t |t t f rt | j }| j |= t |t r|dk r||z
}t ||dz }t t
|j | }|j | j j D ]7 \ }}|D ]- }t | D ] \ }\ }} t || | |kD z
||< / 9 y | j |= y )Nr )
r= r/ rV lenr8 r> rangeindicesreverser9 items enumerater )
r r# mylenremovedrK occurrencesjrZ valuepositions
r __delitem__zParseResults.__delitem__ s a#u &
&E
a !S!q5JA!QUO5!))E"234G OO %)]]%8%8%:!k A09+0F,,E8)@ !8x!|#<* A 1G ! &;
a r returnc || j v S r r9 )r rZ s r __contains__zParseResults.__contains__ s DMM!!r c , t | j S r )r_ r8 r& s r __len__zParseResults.__len__ s 4==!!r c : | j xs | j S r )r8 r9 r& s r __bool__zParseResults.__bool__ s
6 777r c , t | j S r iterr8 r& s r __iter__zParseResults.__iter__ DMM""r c 8 t | j d d d S )NrU ru r& s r __reversed__zParseResults.__reversed__ s DMM$B$'((r c , t | j S r )rv r9 r& s r keyszParseResults.keys
rx r c 6 fd j D S )Nc 3 ( K | ] }| y wr r r rZ r s r r z&ParseResults.values.. s -AQs r| r& s `r valueszParseResults.values
s ---r c 6 fd j D S )Nc 3 , K | ] }|| f
y wr r r s r r z%ParseResults.items.. s 2kDG ks r r& s `r rc zParseResults.items s 2diik22r 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.rn r& s r haskeyszParseResults.haskeys s }}$$$r c |sdg}|j D ] \ }}|dk( r|d |f}t d| t |d t st | 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']
rU defaultr z)pop() got an unexpected keyword argument r^ )rc r? r= r/ r_ )r r* rL rZ rW indexret defaultvalues r popzParseResults.pop s P 4DLLNDAqI~ Q| "KA5 QRR #
d1gs #s4yA~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.getQ s $ $;9 r c | j j || | j j D ]0 \ }}t | D ] \ }\ }}t ||||kD z ||< 2 y)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)r8 insertr9 rc rd r )r r
ins_stringrK rg rZ ri rj s r r zParseResults.inserth sj "
UJ/!% !4!4!6 D+(1+(>$$E8!88x%'78" A )? "7r c : | j j | y)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)r8 append)r items r r zParseResults.append s
T"r c ~ t |t r| j | y| j j | y)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)r= r __iadd__r8 extend)r itemseqs r r zParseResults.extend s, g| , MM' " MM )r c V | j dd= | j j y)z7
Clear all elements and results names.
N)r8 r9 clearr& s r r zParseResults.clear s
MM!
r c d | | S # t $ r |j d r t | Y yw xY w)N__rN )rP
startswithAttributeError)r rK s r __getattr__zParseResults.__getattr__ s: : t$$T** s %//c 0 | j }||z
}|S r )copy)r otherr s r __add__zParseResults.__add__ s iik u
r c |s| S |j rt | j fd}|j j }|D cg c]& \ }}|D ] }|t |d ||d f ( }}}}|D ]( \ }}|| |< t |d t s | |d _ * | xj |j z
c_ | xj |j z c_ | S c c}}}w )Nc | dk rS | z S r) r )aoffsets r z'ParseResults.__iadd__.. s AE&"Aq6z"Ar r r^ ) r9 r_ r8 rc r r= r r5 r6 ) r r addoffset
otheritemsrZ vlistrW otherdictitemsr s @r r zParseResults.__iadd__ s K >> 'FAI --/J !+ *HAu A +AaD)AaD/BC D *
'1Q adL1#'AaDL '
'
5+++ s +C(c V t |t r|dk( r| j S || z S r) )r= r/ r )r r s r __radd__zParseResults.__radd__ s* eS !eqj99; 4< r c n t | j d| j d| j dS )N(, ))r@ r, r8 as_dictr& s r __repr__zParseResults.__repr__ s2 t*%%&a
'84<<>:J!LLr c
ddj | j D cg c]( }t |t r t | n
t | * c} z dz S c c}w )N[r ])joinr8 r= r rO reprr" s r __str__zParseResults.__str__ sa ii "]] * )L 9CFtAwF *
s -A
c g }| j D ]U }|r|r|j | t |t r||j z
}<|j t | W |S r )r8 r r= r
_asStringListrO )r sepoutr s r r zParseResults._asStringList sY MMDs
3$ -t))++
3t9%
"
r c | j D cg c]$ }t |t r|j n|& c}S c c}w )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']
)r8 r= r as_list)r ress r r zParseResults.as_list sA " }}
$ (\ :CKKM C$
s );c R fdt fd| j 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| j r| j S | D cg c]
} | c}S | S c c}w r )r= r r r )objrW to_items r r z%ParseResults.as_dict..to_item sG #|,(+
s{{}TPS;TPS1GAJPS;TT
.! s = 1Q
O s )rI rc )r r s @r r zParseResults.as_dict s! * =
===r c t | j }| j j |_ | j |_ |xj
| j
z c_ | j |_ |S )a
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 r8 r9 r r5 r6 r4 )r r s r r zParseResults.copy# sS 4==)}}))+ ll $//)JJ
r c 0 | j }t | j D ] \ }}t |t r |j | j |< 4t |t t f rKt |t r] t | x| j |< }|j D ]* \ }}t |t r|j n|||< , t |t s t | d |D | j |< |S )zL
Returns a new deep copy of a :class:`ParseResults` object.
c 3 ` K | ]& }t |t r|j n| ( y wr )r= r deepcopy)r rW s r r z(ParseResults.deepcopy..A s) -PS1Jq,$?AJJLQFPSs ,.) r rd r8 r= r r rO bytesr r@ rc r )r r r# r destrZ rW s r r zParseResults.deepcopy1 s iik
.FAs#|,#&<<>
a C#u .C 0*3$s)+5
a 4 IIKDAq.8L.IajjlqDG (C+#,49 -PS- $
a /
r c j r j S j r; j }|j j }t fd|D d S t dk( rxt j dk( r`t t
j j d d dv r,t t
j j S y)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 D K | ] \ }}|D ]
\ }}|u r| y wr r )r rZ r rW locr s r r z(ParseResults.get_name..e s5 $85"'3Dy "' $8s Nr^ r )r rU ) r4 r5 r9 rc nextr_ rv r r| )r parparent_tokdict_itemss ` r get_namezParseResults.get_nameF s 2 ::::
\\"&,,C#&<<#5#5#7 $8
INDMM"a'T$--..01215a8GCT]] / / 123 3r c g }d}|j |r |t | j z nd |r| j rt d | j D }|D ] \ }} |r|j | |j | d|z d| d t
| t rE| r(|j | j ||||dz o|j t | |j t | t d | D r| } t | D ] \ }
} t
| t rE|j d
j |d|z |
|d|dz z | j ||||dz [|j d |d|z |
|d|dz z t | fz dj | 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'
rN c 3 < K | ] \ }}t | |f y wr )rO )r rZ rW s r r z$ParseResults.dump.. s D|tq!A{| z z- z: r^ )indentfull include_list_depthc 3 < K | ] }t |t y wr )r= r )r vvs r r z$ParseResults.dump.. s ?$B:b,/$r z
{}{}[{}]:
{}{}{}z
%s%s[%d]:
%s%s%s)r rO r r sortedrc r= r dumpr anyrd formatr ) r r r r r r NLrc rZ rW r# r s r r zParseResults.dumpv s *
<6C //RH ||~ Dtzz| DD !DAq
2JJ&4&=):"QCr BC!!\2 JJ !+1)-1=+1A: !' !" JJs1v .
47+# "$ ?$?? &q\EAr!"l3
1 8 8 &!% ! &!%!!4 "+1)-1=+1A: !( !"
1 &!% ! &!%!!4 #B
% *< wws|r c R t j | j g|i | y)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* rL s r r zParseResults.pprint s 2
dlln6t6v6r c ~ | j | j j d | j | j ffS r )r8 r9 r r6 r4 r& s r r' zParseResults.__getstate__ s9 MM
""$
r c d |\ | _ \ | _ }}| _ t | | _ d | _ y r )r8 r9 r4 rG r6 r5 )r stater inAccumNamess r r+ zParseResults.__setstate__ s. HME
E
sL$* l+ r c 2 | j | j fS r )r8 r4 r& s r __getnewargs__zParseResults.__getnewargs__ s }}djj((r c ^ t t | t | j z S r )dirr@ r> r| r& s r __dir__zParseResults.__dir__ s 4:diik!222r c d } | g }|j D ]A \ }}t |t r|| j || z
}-| | |g| || z
}C | | |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 Z t | t | t S # t $ r Y yw xY w)NF)rv r= r Exception)r s r is_iterablez+ParseResults.from_dict..is_iterable s4
5S
&c8444
s **)rK )rK rR )rc r= r from_dict)rB r rK r r rZ rW s r r zParseResults.from_dict s{ 5 "gKKMDAq!W%s}}QQ}//sA3Q{1~>> "
se$'C
r )NNr )r r rl r )rl r )rN )rN TTr )>r, r- r. rD r3 r r
r0 rO r boolr
r r1 r> rA r= r r$ r\ rk ro r/ rq rs r rw rz r| r rc r r rY r r r r r r r r r r r r rI r r r r r r r' r+ r r classmethodr rR asDictgetNamer 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
rO r r r@ r0 rH r r registerr r r r s} . . !5\%c
)2' "v - v -r % &r