def __setitem__(self, k, v):
if isinstance(k, (slice, int)):
Log.error("not supported")
if v is None:
v = NO_RESULTS
if is_forward(self):
self.tokens[0][k] = v
return
for i, tok in enumerate(self.tokens):
if isinstance(tok, ParseResults):
if tok.name == k:
self.tokens[i] = v
v = NO_RESULTS # ERASE ALL OTHERS
elif isinstance(tok.type, Group):
continue
elif is_forward(tok.type) and isinstance(
tok.tokens[0].type, Group):
continue
elif tok.name:
continue
tok.__setitem__(k, NO_RESULTS) # ERASE ALL CHILDREN
if v is not NO_RESULTS:
self.tokens.append(Annotation(k, [v]))
def _get_item_by_name(self, name):
# return open list of (modal, value) pairs
# modal==True means only the last value is relevant
for tok in self.tokens:
if isinstance(tok, ParseResults):
if tok.name == name:
if isinstance(tok.type, Group):
yield tok
elif is_forward(tok.type) and isinstance(
tok.tokens[0].type, Group):
yield tok
else:
# STRIP NAME OFF
typ = tok.type
while is_forward(typ):
typ = typ.expr
if typ.token_name:
typ = typ.copy()
typ.token_name = None
yield ParseResults(typ, tok.start, tok.end, tok.tokens)
continue
elif isinstance(tok.type, Group):
continue
elif is_forward(tok.type) and isinstance(
tok.tokens[0].type, Group):
continue
elif tok.name:
continue
for f in tok._get_item_by_name(name):
yield f
def __iter__(self):
if is_forward(self.type):
if len(self.tokens) != 1:
Log.error("not expected")
output = list(self.tokens[0])
for i in output:
yield i
return
for r in self.tokens:
if isinstance(r, Annotation):
continue
elif isinstance(r, ParseResults):
if isinstance(r, Annotation):
return
elif isinstance(r.type, Group):
yield r
elif is_forward(r.type) and isinstance(forward_type(r), Group):
yield r
elif not isinstance(r.type, Group):
for mm in r:
yield mm
else:
yield r
def __lshift__(self, other):
self._str = ""
if is_forward(self.expr):
return self.expr << other
while is_forward(other):
other = other.expr
self.expr = engine.CURRENT.normalize(other).streamline()
self.checkRecursion()
return self
def __lshift__(self, other):
self.strRepr = ""
if other == None:
Log.error("can not set to None")
if is_forward(self.expr):
return self.expr << other
while is_forward(other):
other = other.expr
self.expr = engine.CURRENT.normalize(other)
return self
def __init__(self, expr):
ParserElement.__init__(self)
self.expr = expr = engine.CURRENT.normalize(expr)
if is_forward(expr):
expr.track(self)
self.parser_config.mayIndexError = expr.parser_config.mayIndexError
self.parser_config.mayReturnEmpty = expr.parser_config.mayReturnEmpty
def __getitem__(self, item):
if is_forward(self.type):
return self.tokens[0][item]
if isinstance(item, int):
if item < 0:
item = len(self) + item
for ii, v in enumerate(self):
if item == ii:
return v
elif isinstance(item, slice):
return list(iter(self))[item]
else:
values = list(self._get_item_by_name(item))
if len(values) == 0:
return None
if len(values) == 1:
return values[0]
# ENCAPSULATE IN A ParseResults FOR FURTHER NAVIGATION
try:
return ParseResults(NO_PARSER, values[0].start, values[-1].end,
values)
except Exception as e:
return ParseResults(NO_PARSER, values[0].start, values[-1].end,
values)
def iteritems(self):
if is_forward(self.type):
return self.tokens[0].iteritems()
output = {}
for tok in self.tokens:
if isinstance(tok, ParseResults):
if tok.name:
add(output, tok.name, [tok])
continue
if isinstance(tok.type, Group):
continue
if is_forward(tok.type) and isinstance(tok.tokens[0].type,
Group):
continue
for k, v in tok.iteritems():
add(output, k, v)
for k, v in output.items():
yield k, v
def __init__(self, exprs):
super(ParseExpression, self).__init__()
if isinstance(exprs, generator_types):
exprs = list(exprs)
elif not isinstance(exprs, ParserElement) and isinstance(exprs, Iterable):
exprs = list(exprs)
else:
exprs = [exprs]
self.exprs = [engine.CURRENT.normalize(e) for e in exprs]
for e in self.exprs:
if is_forward(e):
e.track(self)
def _get_item_by_name(self, name):
# return open list of (modal, value) pairs
# modal==True means only the last value is relevant
for tok in self.tokens:
if isinstance(tok, ParseResults):
if tok.name == name:
if isinstance(tok.type, Group):
yield tok
elif is_forward(tok.type) and isinstance(
tok.tokens[0].type, Group):
yield tok
else:
for t in tok.tokens:
yield t
continue
elif isinstance(tok.type, Group):
continue
elif is_forward(tok.type) and isinstance(
tok.tokens[0].type, Group):
continue
elif tok.name:
continue
for f in tok._get_item_by_name(name):
yield f
def output(*args, **kwargs):
with locker:
for a in _reset_actions:
try:
a()
except Exception as e:
Log.error("reset action failed", cause=e)
self = args[0]
if not self.streamlined and (
not is_forward(self) or not self.expr.streamlined
):
Log.alert("Expecting expression to be streamlined before use")
self = self.streamline()
return func(self, *args[1:], **kwargs)
def _parseString(self, string, parseAll=False):
# TODO: PUT THIS streamline IN THE ENTRY POINT
start = 0
e = expr = self.streamline()
while is_forward(e):
e = e.expr
eng = None
if isinstance(e, Many) or isinstance(e, And):
eng = e.parser_config.engine
start = eng.skip(string, start)
if expr.token_name:
# TOP LEVEL NAMES ARE NOT ALLOWED
expr = Group(expr)
tokens = expr._parse(string, start)
end = tokens.end
if parseAll:
if eng:
end = eng.skip(string, end)
StringEnd()._parse(string, end)
return tokens
def __getitem__(self, item):
if is_forward(self.type):
return self.tokens[0][item]
if is_text(item):
values = list(self._get_item_by_name(item))
if len(values) == 0:
return NO_RESULTS
if len(values) == 1:
return values[0]
# ENCAPSULATE IN A ParseResults FOR FURTHER NAVIGATION
return ParseResults(NO_PARSER, -1, 0, values)
elif isinstance(item, int):
if item < 0:
item = len(self) + item
for ii, v in enumerate(self):
if item == ii:
return v
elif isinstance(item, slice):
return list(iter(self))[item]
else:
Log.error("not expected")
def __init__(self, expr):
ParserElement.__init__(self)
self.expr = expr = engine.CURRENT.normalize(expr)
if is_forward(expr):
expr.track(self)
