U
ʗReb @ s U d dl mZmZmZmZ d dlZd dlmZ d dl m
Z
m Z e e
fZe
edf ed< edd d D ZG d
d d ZG d d
d
Zee ee dS ) )MutableMappingMappingMutableSequenceIteratorN)ref)TupleAny.str_typec c s | ]
}|V qd S N ).0_r r /builddir/build/BUILDROOT/alt-python38-pip-22.2.1-2.el8.x86_64/opt/alt/python38/lib/python3.8/site-packages/pip/_vendor/pyparsing/results.py s r r c @ s2 e Zd ZdgZdd Zdd Zdd Zdd Zd
S ) _ParseResultsWithOffsettupc C s ||f| _ d S r
r )selfp1p2r r r __init__ s z _ParseResultsWithOffset.__init__c C s
| j | S r
r r ir r r __getitem__ s z#_ParseResultsWithOffset.__getitem__c C s | j S r
r r r r r __getstate__ s z$_ParseResultsWithOffset.__getstate__c G s |d | _ d S Nr r )r argsr r r __setstate__ s z$_ParseResultsWithOffset.__setstate__N)__name__
__module__ __qualname__ __slots__r r r r r r r r r s
r c @ s
e Zd ZU dZdg ddfZeedf ed< ddd d
d d d
gZG dd de Z
d_ddZ dddde fddZ
dd Ze fddZdd Zedd d Zedd d Zedd d!Zedd"d#Zedd$d%Zd&d' Zd(d) Zd*d+ Zedd,d-Z d.d/ Z d`d0d1Z d2d3 Z d4d5 Z d6d7 Z!d8d9 Z"d:d; Z#d ddd?Z%d dd@dAZ&e'ddBdCZ(e'ddDdEZ)dadFdGZ*e ddHdIZ+e,ddJdKZ-d ddLdMZ.dNdO Z/dbe'ddQdRZ0dSdT Z1dUdV Z2dWdX Z3dYdZ Z4d[d\ Z5e6dcd dd]d^Z7e+Z8e-Z9e/Z:dS )d 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 @ s e Zd ZdZdddZdS )zParseResults.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 C s8 |d kr g }t |ts.td| jt|jt| S )Nz.{} may only be constructed with a list, not {})
isinstancelist TypeErrorformatr type__new__)cls containedr r r r2 | s
zParseResults.List.__new__)N)r r r! __doc__r2 r r r r ListU s &r6 c K s t |tr|S t| }d |_d |_t |_|d kr s z,ParseResults.__getitem__..)r- r> slicer* r( r+ r# r r r r r s
zParseResults.__getitem__c C s ||t r0| j|t |g | j|< |d }nD||ttfrN|| j|< |}n&| j|t t |dg | j|< |}||trt| |_ d S r )
r r+ getr. r> rH r* r# wkrefr' )r krF r- subr r r __setitem__ s
zParseResults.__setitem__c
C s t |ttfrt| j}| j|= t |trH|dk r:||7 }t||d }tt|| }| | j
D ]>\}}|D ]0}t |D ]"\}\}} t || | |k ||< qqxqln| j |= d S )Nr )
r- r> rH lenr* r. rangeindicesreverser+ items enumerater )
r r mylenremovedr< occurrencesjrK valuepositionr r r __delitem__ s"
zParseResults.__delitem__)returnc C s
|| j kS r
)r+ )r rK r r r __contains__ s zParseResults.__contains__c C s
t | jS r
)rO r* r r r r __len__ s zParseResults.__len__c C s | j p
| j S r
)r* r+ r r r r __bool__ s zParseResults.__bool__c C s
t | jS r
iterr* r r r r __iter__ s zParseResults.__iter__c C s t | jd d d S )NrD r` r r r r __reversed__ s zParseResults.__reversed__c C s
t | jS r
)ra r+ r r r r keys s zParseResults.keysc s fdd D S )Nc 3 s | ]} | V qd S r
r r rK r r r r s z&ParseResults.values..rd r r r r values s zParseResults.valuesc s fdd D S )Nc 3 s | ]}| | fV qd S r
r re r r r r s z%ParseResults.items..rf r r r r rS s zParseResults.itemsc C s
t | jS )z
Since ``keys()`` returns an iterator, this method is helpful in bypassing
code that looks for the existence of any defined results names.)boolr+ r r r r haskeys s zParseResults.haskeysc O s |s
dg}| D ],\}}|dkr0|d |f}qtd|qt|d tsft|dksf|d | kr|d }| | }| |= |S |d }|S dS )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']
rD defaultr z-pop() got an unexpected keyword argument {!r}rN N)rS r/ r0 r- r> rO )r r r= rK rF indexret defaultvaluer r r pop s (&zParseResults.popc C s || kr| | S |S dS )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
Nr )r key
default_valuer r r rI F s zParseResults.getc C sR | j || | j D ]4\}}t|D ]"\}\}}t||||k ||< q(qdS )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* insertr+ rS rT r )r rk
ins_stringr< rW rK rY rZ r r r rq ] s
zParseResults.insertc C s | 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)r* append)r itemr r r rs v s zParseResults.appendc C s& t |tr| | n | 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)r- r# __iadd__r* extend)r itemseqr r r rv s
zParseResults.extendc C s | j dd= | j dS )z7
Clear all elements and results names.
N)r* r+ clearr r r r rx s zParseResults.clearc C s8 z
| | W S t k
r2 |dr,t|Y dS X d S )N__r$ )r@
startswithAttributeError)r r< r r r __getattr__ s
zParseResults.__getattr__c C s | }||7 }|S r
)copy)r otherrl r r r __add__ s zParseResults.__add__c s |j rjt| jfdd |j } fdd|D }|D ],\}}|| |< t|d tr z'ParseResults.__iadd__..c s4 g | ],\}}|D ] }|t |d |d fqqS )r rN )r )r rK vlistrF ) addoffsetr r rG s z)ParseResults.__iadd__..r ) r+ rO r* rS r- r# rJ r' r( )r r~
otheritemsotherdictitemsrK rF r )r r r ru s
zParseResults.__iadd__c C s& t |tr|dkr| S || S d S r )r- r> r} )r r~ r r r __radd__ s zParseResults.__radd__c C s d t| j| j| S )Nz {}({!r}, {}))r0 r1 r r* as_dictr r r r __repr__ s zParseResults.__repr__c C s dd dd | jD d S )N[z, c S s& g | ] }t |trt|nt|qS r )r- r# r? repr)r r r r r rG s z(ParseResults.__str__..])joinr* r r r r __str__ s zParseResults.__str__c C sL g }| j D ]<}|r |r || t|tr8|| 7 }q
|t| q
|S r
)r* rs r- r#
_asStringListr? )r sepoutrt r r r r s
zParseResults._asStringListc C s dd | 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 S s" g | ]}t |tr| n|qS r )r- r# as_list)r resr r r rG s z(ParseResults.as_list..)r* r r r r r s zParseResults.as_listc s& fdd t fdd| 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 s4 t | tr,| r| S fdd| D S | S d S )Nc s g | ] } |qS r r rE to_itemr r rG s z9ParseResults.as_dict..to_item..)r- r# ri r objr r r r
s
"z%ParseResults.as_dict..to_itemc 3 s | ]\}}| |fV qd S r
r r rK rF r r r r s z'ParseResults.as_dict..)r: rS r r r r r s zParseResults.as_dictc C s: t | j}| j |_| j|_| j| jO _| j|_|S )zG
Returns a new copy of a :class:`ParseResults` object.
)r# r* r+ r} r' r( r& )r rl r r r r} s
zParseResults.copyc s | j r | j S | jr6| fdd} r2|| S dS t| dkrt| jdkrtt| j d d dkrtt| j S dS 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 s t fddj D d S )Nc 3 s, | ]$\}}|D ]\}} |kr|V qqd S r
r )r rK r rF locrL r r r @ s
z@ParseResults.get_name..find_in_parent..)nextr+ rS r parr r find_in_parent> s
z-ParseResults.get_name..find_in_parentNrN r )r rD )r& r' rO r+ r ra rg rd )r r r r r get_name s
zParseResults.get_namer c C sl g }d}| |r |t| nd |rb| rtdd | D }|D ]x\}} |rd| | | d|d| | t| tr| r| | j ||||d d q| t| qN| t
| qNt d d | D rb| } t | D ]x\}
} t| tr6| d
|d| |
|d|d | j ||||d d q| d |d| |
|d|d t| f qd
|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 s s | ]\}}t ||fV qd S r
)r? r r r r r n s z$ParseResults.dump..z
{}{}- {}: z rN )indentfull include_list_depthc s s | ]}t |tV qd S r
)r- r# )r vvr r r r s z
{}{}[{}]:
{}{}{}z
%s%s[%d]:
%s%s%s)rs r? r ri sortedrS r0 r- r# dumpr anyrT r ) r r r r r r NLrS rK rF r r r r r r S sj
zParseResults.dumpc O s t j | f|| 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 r= r r r r s zParseResults.pprintc C s. | j | j | jd k r | p d | j| jffS r
)r* r+ r} r' r( r& r r r r r s zParseResults.__getstate__c C s> |\| _ \| _}}| _t|| _|d k r4t|| _nd | _d S r
)r* r+ r& r8 r( rJ r' )r stater inAccumNamesr r r r s
zParseResults.__setstate__c C s | j | jfS r
)r* r& r r r r __getnewargs__ s zParseResults.__getnewargs__c C s t t| t| S r
)dirr1 r. rd r r r r __dir__ s zParseResults.__dir__c C sr dd }| g }| D ]>\}}t|tr>|| j||d7 }q|| |g|||d7 }q|dk rn| |g|d}|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 S s4 z t | W n tk
r" Y dS X t| t S d S )NF)ra Exceptionr- r r r r r is_iterable s
z+ParseResults.from_dict..is_iterable)r< )r< rB N)rS r- r from_dict)r3 r~ r< r rl rK rF r r r r s
zParseResults.from_dict)NN)N)r$ )r$ TTr )N);r r r! r5 r% r r __annotations__r" r. r6 r2 r- r r rM r[ rh r] r> r^ r_ r rb rc rd rg rS ri rn rI rq rs rv rx r| r ru r r? r r r r r: r r} r r r r r r r classmethodr rB asDictgetNamer r r r r# st
-
3
:
3P r# )collections.abcr r r r r weakrefr rJ typingr r r? bytesr r1 r r9 r r# registerr r r r s a