"""
Various pyparsing grammar elements and a few useful routines.
"""
import re
from contextlib import contextmanager
from threading import Lock
from typing import Optional
import pyparsing as pp
from .decorators import cache
_grammar_lock = Lock()
_grammar_users = 0
_grammar_defaults = None
[docs]
@contextmanager
def generate_grammar():
"""Share SPRKKR parser defaults until the last grammar builder exits.
Only entry and exit are synchronized; grammar construction can overlap.
Other pyparsing users must not rely on independent global defaults while
this context is active.
"""
global _grammar_users, _grammar_defaults
pe = pp.ParserElement
with _grammar_lock:
if _grammar_users == 0:
_grammar_defaults = (pe.DEFAULT_WHITE_CHARS, pp.Keyword.DEFAULT_KEYWORD_CHARS)
pe.set_default_whitespace_chars(" \t\r")
if "-" not in pp.Keyword.DEFAULT_KEYWORD_CHARS:
pp.Keyword.DEFAULT_KEYWORD_CHARS += "-"
_grammar_users += 1
try:
yield
finally:
with _grammar_lock:
_grammar_users -= 1
if _grammar_users == 0:
whitespace, keywords = _grammar_defaults
pe.set_default_whitespace_chars(whitespace)
pp.Keyword.DEFAULT_KEYWORD_CHARS = keywords
_grammar_defaults = None
[docs]
def replace_whitechars(expr):
expr = expr.copy()
expr.set_whitespace_chars(" \t\r")
return expr
with generate_grammar():
optional_line_end = pp.Suppress(pp.LineEnd() | pp.WordStart()).set_name(" ")
""" Grammar for an optinal newline """
line_end = pp.Suppress(pp.LineEnd()).set_name("\n")
""" Grammar for a required newline """
end_of_file = (pp.Regex(r"[\s]*") + pp.StringEnd()).suppress().set_name("<EOF>")
""" Grammar for an end of file (ending whitespaces are allowed) """
optional_quote = pp.Optional("'").suppress()
""" Grammar for an optional quote """
[docs]
def as_delimiter(grammar, written=None):
"""Return a suppressed delimiter grammar named by its written form."""
if isinstance(grammar, str):
if written is None:
written = grammar
grammar = pp.Suppress(grammar) if grammar else pp.Empty()
if written is not None:
grammar = grammar.set_name(written)
return grammar
[docs]
def separator_pattern(char):
return f"[{char}]" * 11 + "*"
[docs]
@cache
def separator_grammar(char):
"""Pattern for separating sections in an input file"""
separator = pp.Regex(separator_pattern(char)).set_name(f"{char * 10}[{char * 4}....]").suppress()
return separator
[docs]
def delimitedList(expr, delim):
"""Delimited list with already suppressed delimiter (or with a in-results-wanted one)"""
return expr + pp.ZeroOrMore(delim + expr)
[docs]
def add_condition_ex(self, condition, message):
"""Add check condition to the pyparsing ParseElement,
that, if it failed, raise a parse exception with a given message."""
def check_condition(s, loc, tocs):
m = message
if condition(tocs):
return tocs
if not isinstance(m, str):
m = m(tocs)
raise pp.ParseException(s, loc, m)
self.add_parse_action(check_condition)
return self
[docs]
def add_parse_action_ex(self, pa, message=None):
"""
Add parse action to a given pyparsing ParseElemenet,
that, if it raise an exception, fail with a given message
"""
def parse_action(s, loc, x):
try:
return pa(x)
except Exception as e:
if message:
msg = f"{message}\n{e}"
else:
msg = str(e)
raise pp.ParseException(s, loc, msg).with_traceback(e.__traceback__) from e
self.add_parse_action(parse_action)
[docs]
class White(pp.White):
"""Fix for whitechars in pp.White
In Python 3.10, pyparsing.White do not respect default_white_chars.
This class fixes this.
"""
[docs]
def __init__(self, white):
super().__init__(white)
self.set_whitespace_chars("")
[docs]
class SkipToRegex(pp.Token):
"""Skip to given regex"""
[docs]
def __init__(self, pattern, include_pattern: Optional[bool] = None, parse_pattern: bool = False):
if not isinstance(pattern, re.Pattern):
pattern = re.compile(pattern)
self.pattern = pattern
if include_pattern is None:
include_pattern = parse_pattern
self.include_pattern = include_pattern
self.parse_pattern = parse_pattern
super().__init__()
@property
def custom_name(self):
self.customName = "skipTo{self.pattern}"
[docs]
def parseImpl(self, instr, loc, doActions=True):
result = self.pattern.search(instr, loc)
if result:
start = result.start()
out = instr[loc:start]
if self.parse_pattern:
out = (out, instr[start : result.end()])
if self.include_pattern:
loc = result.end()
else:
loc = result.start()
return loc, pp.ParseResults(out)
raise pp.ParseException(instr, loc, "Pattern {self.pattern} not found", self)
[docs]
class Transparent(pp.ParseElementEnhance):
""" Pyparsing ParseElementEnhance wrongly takes care about whitespaces, if there is
nested Forward with whitespaces not already set. So we have to use out own lightweight
replacement.
"""
[docs]
def preParse(self, instring, loc):
return loc
[docs]
def parseImpl(self, instring, loc, do_actions=True):
return self.expr._parse(instring, loc, do_actions)
def __str__(self):
return f"{self.__class__.__name__}({self.expr})"
[docs]
class Suppress(Transparent):
[docs]
def __init__(self, expr):
super().__init__(expr)
self.add_parse_action(lambda x:[])
self.set_name('Suppress')
[docs]
class TokenConverter(Transparent):
pass
[docs]
class Forward(Transparent):
[docs]
def __init__(self, expr=None):
super().__init__(expr)
def __lshift__(self, other):
self.expr = other
pp.ParserElement.add_condition_ex = add_condition_ex
pp.ParserElement.add_parse_action_ex = add_parse_action_ex