/usr/local/lib/python3.6/site-packages/pyparsing/__pycache__
Edit: /usr/local/lib/python3.6/site-packages/pyparsing/__pycache__/results.cpython-36.pyc (25411B)
3
Eg\d @ s U d dl mZmZmZmZmZ d dlZd dlmZm Z m
Z
m Z m Z ddl
mZ eefZeedf edd f D ZG d d
d
ZG d d d Zeje eje dS )
)MutableMappingMappingMutableSequenceIteratorIterableN)TupleAnyDictSetList )replaced_by_pep8.c c s | ]
}|V qd S )N ).0_r r ;/usr/local/lib/python3.6/site-packages/pyparsing/results.py
s r c @ sH e Zd ZU edef dgZdedddZdd Zdd Z d
d Z
d S )
_ParseResultsWithOffset ParseResultstup)p1p2c C s ||f| _ d S )N)r )selfr r r r r __init__ s z _ParseResultsWithOffset.__init__c C s
| j | S )N)r )r ir r r __getitem__ s z#_ParseResultsWithOffset.__getitem__c C s | j S )N)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__r intr __slots__r r r r r r r r r s
r c @ s6 e Zd ZU dZdg f fZeedf ed e
e e
ee eeef d_ZG d
d d eZd`d d
ZddddefddZdd ZefddZdd Ze dddZedddZ e dd d Z e dd d Z e dd d!Z d"d# Z!d$d% Z"d&d' Z#e dd(d)Z$d*d+ Z%dad,d-Z&d.d/ Z'd0d1 Z(d2d3 Z)d4d5 Z*d6d7 Z+d d d8d9d:Z,d d d8d;d<Z-d dd=d>Z.edd?d@Z/eddAdBZ0dbdDdEZ1eddFdGZ2e3ddHdIZ4d ddJdKZ5d ddLdMZ6eddNdOZ7dceddQdRZ8dSdT Z9dUdV Z:dWdX Z;dYdZ Zddd dd]d^Z?e2Z@e4ZAe7ZBdS )er 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'
N._name_parent
_all_names_modal_toklist_tokdictc @ 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.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 C s: |d kr g }t |ts0t| j dt|j tj| S )Nz* may only be constructed with a list, not )
isinstancelist TypeErrorr type__new__)clsZ containedr r r r. s
zParseResults.List.__new__)N)r r r! __doc__r. r r r r r d s %r c K s t |tr|S tj| }d |_d |_t |_|d kr s z,ParseResults.__getitem__..)r* r" slicer( r& r) r )r r r r r r s
zParseResults.__getitem__c C s ||t r0| jj|t |g | j|< |d }nD||ttfrN|| j|< |}n&| jj|t t |dg | j|< |}||tr| |_d S )Nr ) r r) getr+ r" rC r( r r% )r kr@ r* subr r r __setitem__ s
zParseResults.__setitem__c C s t |ttfs| j|= d S t| j}| j|= t |trT|dk rF||7 }t||d }tt|j| }|j xP| jj
D ]B}x<|D ]4}x.t |D ]"\}\}}t ||||k ||< qW qW qzW d S )Nr r )
r* r" rC r) lenr( r+ rangeindicesreversevalues enumerater ) r r mylenremoved occurrencesjrE valuepositionr r r __delitem__ s
zParseResults.__delitem__)returnc C s
|| j kS )N)r) )r rE r r r __contains__ s zParseResults.__contains__c C s
t | jS )N)rH r( )r r r r __len__ s zParseResults.__len__c C s | j p
| j S )N)r( r) )r r r r __bool__
s zParseResults.__bool__c C s
t | jS )N)iterr( )r r r r __iter__
s zParseResults.__iter__c C s t | jd d d S )Nr rB )rY r( )r r r r __reversed__ s zParseResults.__reversed__c C s
t | jS )N)rY r) )r r r r keys s zParseResults.keysc s fdd j D S )Nc 3 s | ]} | V qd S )Nr )r rE )r r r r s z&ParseResults.values..)r\ )r r )r r rL s zParseResults.valuesc s fdd j D S )Nc 3 s | ]}| | fV qd S )Nr )r rE )r r r r s z%ParseResults.items..)r\ )r r )r r items s zParseResults.itemsc C s
| 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.)r) )r r r r haskeys s zParseResults.haskeysc O s |s
dg}x8|j D ],\}}|dkr2|d |f}qtd|qW t|d tsjt|dksj|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']
r defaultr z)pop() got an unexpected keyword argument NrB )r] r, r* r" rH )r r r7 rE r@ 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 rD Z s zParseResults.getc C sV | j j|| xB| jj D ]4}x.t|D ]"\}\}}t||||k ||< q(W qW dS )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) rL rM r )r r` Z
ins_stringrP rE rR rS r r r rf q s
zParseResults.insertc C s | j 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 rg s zParseResults.appendc C s& t |tr| j| n | jj| 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 rj s
zParseResults.extendc C s | j dd= | jj dS )z7
Clear all elements and results names.
N)r( r) clear)r r r r rl s zParseResults.clearc C s4 y| | S t k
r. |jdr*t|dS X d S )N__r8 )r<
startswithAttributeError)r r6 r r r __getattr__ s
zParseResults.__getattr__)otherrU c C s | j }||7 }|S )N)copy)r rq ra r r r __add__ s zParseResults.__add__c s |s| S |j rrt| jfdd |j j } fdd|D }x0|D ](\}}|| |< t|d trF| |d _qFW | j|j7 _| j|jO _| S )Nc s | dk r S | S )Nr r )a)offsetr r s z'ParseResults.__iadd__..c s4 g | ],\}}|D ] }|t |d |d fqqS )r r )r )r rE vlistr@ ) addoffsetr r rA s z)ParseResults.__iadd__..r )r) rH r( r] r* r r% r& )r rq
otheritemsotherdictitemsrE r@ r )rx ru r ri s
zParseResults.__iadd__c C s& t |tr|dkr| j S || S d S )Nr )r* r" rr )r rq r r r __radd__ s zParseResults.__radd__c C s" t | j d| jd| j dS )N(z, ))r- r r( as_dict)r r r r __repr__ s zParseResults.__repr__c C s ddj dd | jD d S )N[z, c S s& g | ] }t |trt|nt|qS r )r* r r9 repr)r r r r r rA s z(ParseResults.__str__..])joinr( )r r r r __str__ s zParseResults.__str__r8 c C sP g }xF| j D ]<}|r"|r"|j| t|tr:||j 7 }q |jt| q W |S )N)r( rg r* r
_asStringListr9 )r sepoutrh 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|j n|qS r )r* r as_list)r resr r r rA s z(ParseResults.as_list..)r( )r r r r r s zParseResults.as_listc s& fdd t fdd| 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 s4 t | tr,| j r| j S fdd| D S | S d S )Nc s g | ] } |qS r r )r r@ )to_itemr r rA & s z9ParseResults.as_dict..to_item..)r* r r^ r~ )obj)r r r r $ s
"z%ParseResults.as_dict..to_itemc 3 s | ]\}}| |fV qd S )Nr )r rE r@ )r r r r * s z'ParseResults.as_dict..)r4 r] )r r )r r r~ s zParseResults.as_dictc C s: t | j}| jj |_| j|_| j| jO _| 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 r( r) rr r% r& r$ )r ra r r r rr , s
zParseResults.copyc C s | j }xt| jD ]\}}t|tr6|j |j|< qt|ttfrFqt|trt | |j|< }xV|j
D ]"\}}t|tr|j n|||< qnW qt|t rt |dd |D |j|< qW |S )zL
Returns a new deep copy of a :class:`ParseResults` object.
c s s$ | ] }t |tr|j n|V qd S )N)r* r deepcopy)r r@ r r r r K s z(ParseResults.deepcopy..) rr rM r( r* r r r9 bytesr r- r] r )r ra r r destrE r@ r r r r : s
zParseResults.deepcopyc s j r j S jr: j}|jj }t fdd|D dS t dkrt jdkrtt jj d d dkrtt jj 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 3 s, | ]$\}}|D ]\}}| kr|V qqd S )Nr )r rE rw r@ loc)r r r r o s z(ParseResults.get_name..Nr r rB )r rB ) r$ r% r) r] nextrH rY rL r\ )r parZparent_tokdict_itemsr )r r get_nameO s
zParseResults.get_namer c
C s g }d}|j |r |t| j nd |s4dj|S | j rtdd | j D }x|D ]~\}} |rn|j | |j | d| d| d t| ts|j t | qX| s|j t| qX|j | j
||||d d qXW t d
d | D sdj|S | } d}
d} xt | D ]\} }
t|
trr|
j
||||d d }|j | | |
| d | d | | |
|d |
n:|j | | |
| d | d | | |
|d |
q W 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'
r8 c s s | ]\}}t ||fV qd S )N)r9 )r rE r@ r r r r s z$ParseResults.dump..z z- z: r )indentfull include_list_depthc s s | ]}t |tV qd S )N)r* r )r vvr r r r s r z]:)
rg r9 r r r^ sortedr] r* r r dumpanyrM )r r r r r r NLr] rE r@ incrnlr r Zvv_dumpr r r r sP
8<zParseResults.dumpc O s t j | 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(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 r7 r r r r s zParseResults.pprintc C s | j | jj d | j| jffS )N)r( r) rr r& r$ )r r r r r s
zParseResults.__getstate__c C s* |\| _ \| _}}| _t|| _d | _d S )N)r( r) r$ r2 r& r% )r stater inAccumNamesr r r r s
zParseResults.__setstate__c C s | j | jfS )N)r( r$ )r r r r __getnewargs__ s zParseResults.__getnewargs__c C s t t| t| j S )N)dirr- r+ r\ )r r r r __dir__ s zParseResults.__dir__c C sv dd }| g }xJ|j D ]>\}}t|tr@|| j||d7 }q|| |g|||d7 }qW |dk rr| |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 s2 y t | W n tk
r dS X t| t S d S )NF)rY Exceptionr* r; )r r r r is_iterable s
z+ParseResults.from_dict..is_iterable)r6 )r6 r> N)r] r* r from_dict)r/ rq r6 r ra rE r@ r r r r s
zParseResults.from_dict)r$ r% r& r' r( r) )NN)N)r8 )r8 TTr )N)Cr r r! r0 r: r r r9 r$ r% r
r& boolr' r r( r r) r# r+ r. r* r r rG rT rV r" rW rX r rZ r[ r\ rL r] r^ rc rD rf rg rj rl rp rs ri r{ r r r r r4 r~ rr r r r r r r r r classmethodr r> asDictgetNamer r r r r $ sv
, 2
& 8
0J r )collections.abcr r r r r r typingr r r r
r utilr
r9 r r; r- r3 r r registerr r r r s