def get_truncation_language() -> ParserElement:
"""Build a parser for protein truncations."""
l1 = truncation_tag + nest(
amino_acid(AMINO_ACID) + ppc.integer(TRUNCATION_POSITION))
l1.setParseAction(_handle_trunc)
l2 = truncation_tag + nest(ppc.integer(TRUNCATION_POSITION))
l2.setParseAction(_handle_trunc_legacy)
return l1 | l2
def __init__(self):
self.language = psub_tag + nest(amino_acid(PSUB_REFERENCE),
ppc.integer(PSUB_POSITION),
amino_acid(PSUB_VARIANT))
self.language.setParseAction(self.handle_psub)
super(ProteinSubstitutionParser, self).__init__(self.language)
def __init__(self):
self.language = gsub_tag + nest(dna_nucleotide(GSUB_REFERENCE),
ppc.integer(GSUB_POSITION),
dna_nucleotide(GSUB_VARIANT))
self.language.setParseAction(self.handle_gsub)
super(GeneSubstitutionParser, self).__init__(self.language)
def __init__(self, identifier_parser=None):
"""
:param IdentifierParser identifier_parser: An identifier parser for checking the 3P and 5P partners
"""
self.identifier_parser = identifier_parser if identifier_parser is not None else IdentifierParser(
)
pmod_default_ns = oneOf(list(
language.pmod_namespace.keys())).setParseAction(
self.handle_pmod_default_ns)
pmod_legacy_ns = oneOf(list(
language.pmod_legacy_labels.keys())).setParseAction(
self.handle_pmod_legacy_ns)
pmod_identifier = MatchFirst([
Group(self.identifier_parser.identifier_qualified),
Group(pmod_default_ns),
Group(pmod_legacy_ns)
])
self.language = pmod_tag + nest(
pmod_identifier(IDENTIFIER) +
Optional(WCW + amino_acid(PMOD_CODE) +
Optional(WCW + ppc.integer(PMOD_POSITION))))
super(ProteinModificationParser, self).__init__(self.language)
def get_gene_substitution_language():
language = gsub_tag + nest(
dna_nucleotide(GSUB_REFERENCE),
ppc.integer(GSUB_POSITION),
dna_nucleotide(GSUB_VARIANT),
)
language.setParseAction(_handle_gsub)
return language
def get_protein_substitution_language():
language = psub_tag + nest(
amino_acid(PSUB_REFERENCE),
ppc.integer(PSUB_POSITION),
amino_acid(PSUB_VARIANT),
)
language.setParseAction(_handle_psub)
return language
def get_protein_substitution_language() -> ParserElement:
"""Build a protein substitution parser."""
parser_element = psub_tag + nest(
amino_acid(PSUB_REFERENCE),
ppc.integer(PSUB_POSITION),
amino_acid(PSUB_VARIANT),
)
parser_element.setParseAction(_handle_psub)
return parser_element
def get_gene_substitution_language() -> ParserElement:
"""Build a gene substitution parser."""
parser_element = gsub_tag + nest(
dna_nucleotide(GSUB_REFERENCE),
ppc.integer(GSUB_POSITION),
dna_nucleotide(GSUB_VARIANT),
)
parser_element.setParseAction(_handle_gsub)
return parser_element
def get_protein_modification_language(
concept_qualified: ParserElement) -> ParserElement:
"""Build a protein modification parser."""
pmod_concept = MatchFirst([
concept_qualified,
pmod_default_ns,
pmod_legacy_ns,
])
return pmod_tag + nest(
Group(pmod_concept)(CONCEPT) + Optional(
WCW + amino_acid(PMOD_CODE) +
Optional(WCW + ppc.integer(PMOD_POSITION)), ), )
def get_protein_modification_language(identifier_qualified):
"""
:param pyparsing.ParseElement identifier_qualified:
:rtype: pyparsing.ParseElement
"""
pmod_identifier = MatchFirst(
[identifier_qualified, pmod_default_ns, pmod_legacy_ns])
return pmod_tag + nest(
Group(pmod_identifier)(IDENTIFIER) +
Optional(WCW + amino_acid(PMOD_CODE) +
Optional(WCW + ppc.integer(PMOD_POSITION))))
def get_protein_modification_language(identifier_qualified: ParserElement) -> ParserElement:
"""Build a protein modification parser."""
pmod_identifier = MatchFirst([
identifier_qualified,
pmod_default_ns,
pmod_legacy_ns
])
return pmod_tag + nest(
Group(pmod_identifier)(IDENTIFIER) +
Optional(
WCW +
amino_acid(PMOD_CODE) +
Optional(
WCW +
ppc.integer(PMOD_POSITION)
)
)
)
def _parse_twr_period(timing_str: str) -> pp.ParseResults:
"""Parse period constraints from an ISE timing report
Expects the default ISE verbose output from a command like: ::
trce -v 3 -n 3 -fastpaths top.ncd top.pcf -o top.twr
"""
# Look for a section of the report like the following and extract the
# constraint, path information, and minimum period.
#
# ================================================================================
# Timing constraint: TS_clk = PERIOD TIMEGRP "clk" 150 MHz HIGH 50%;
# For more information, see Period Analysis in the Timing Closure User Guide (UG612).
#
# 39892 paths analyzed, 3774 endpoints analyzed, 632 failing endpoints
# 632 timing errors detected. (632 setup errors, 0 hold errors, 0 component switching limit errors)
# Minimum period is 10.877ns.
# --------------------------------------------------------------------------------
#
# or
#
# ================================================================================
# Timing constraint: TS_soclinux_crg_pll_sdram_half_b = PERIOD TIMEGRP
# "soclinux_crg_pll_sdram_half_b" TS_soclinux_crg_clk50b / 3.33333333
# PHASE 4.16666667 ns HIGH 50%;
# For more information, see Period Analysis in the Timing Closure User Guide (UG612).
#
# 0 paths analyzed, 0 endpoints analyzed, 0 failing endpoints
# 0 timing errors detected. (0 component switching limit errors)
# Minimum period is 1.730ns.
# --------------------------------------------------------------------------------
period = ppc.real("min period") + pp.Suppress("ns")
# Build up a case-insensitive match for any of the below units
units = ["ps", "ns", "micro", "ms", "%", "MHz", "GHz", "kHz"]
pp_units = pp.CaselessLiteral(units[0])
for u in units[1:]:
pp_units |= pp.CaselessLiteral(u)
hl = pp.Literal("HIGH") | pp.Literal("LOW")
num = ppc.number + pp.Optional(pp_units)
jitter = pp.Optional("INPUT_JITTER" + num)
# Remove leading and trailing whitespace and any line breaks
#
# SkipTo in the below timespec parser will pickup whitespace including
# new lines if they are included in the report.
def remove_ws_and_newlines(s):
lines = [l.strip() for l in s.splitlines()]
return " ".join(lines)
timespec = (pp.Suppress("Timing constraint:") +
pp.Word(pp.printables)("timespec") +
pp.Suppress("= PERIOD TIMEGRP") +
pp.Word(pp.printables)("timegroup") +
pp.SkipTo(hl)("constraint").setParseAction(
pp.tokenMap(remove_ws_and_newlines)) +
pp.Suppress(hl + num + jitter + ";"))
# Parse the path information from the report like:
#
# 0 paths analyzed, 0 endpoints analyzed, 0 failing endpoints
# 0 timing errors detected. (0 component switching limit errors)
#
# or
#
# 266 paths analyzed, 235 endpoints analyzed, 0 failing endpoints
# 0 timing errors detected. (0 setup errors, 0 hold errors, 0 component switching limit errors)
stats = (
ppc.integer("paths") + pp.Suppress("paths analyzed,") +
ppc.integer("endpoints") + pp.Suppress("endpoints analyzed,") +
ppc.integer("failing") + pp.Suppress("failing endpoints") +
ppc.integer("timing errors") +
pp.Suppress("timing errors detected. (") + pp.Optional(
ppc.integer("setup errors") + pp.Suppress("setup errors,") +
ppc.integer("hold errors") + pp.Suppress("hold errors,")) +
ppc.integer("switching limit errors") +
pp.Suppress("component switching limit errors)"))
# It's not clear why this doesn't show up for one timing constraint in
# the LiteX Linux VexRISCV example
min_period = pp.Optional(pp.Suppress("Minimum period is") + period)
constraint = timespec + pp.Suppress(
pp.SkipTo(stats)) + stats + min_period
result = constraint.searchString(timing_str)
return result
keyword = and_ | or_ | not_ | to_
expression = pp.Forward()
valid_word = pp.Regex(
r'([a-zA-Z0-9*_+.-]|\\\\|\\([+\-!(){}\[\]^"~*?:]|\|\||&&))+'
).setName("word")
valid_word.setParseAction(
lambda t: t[0].replace("\\\\", chr(127)).replace("\\", "").replace(chr(127), "\\")
)
string = pp.QuotedString('"')
required_modifier = pp.Literal("+")("required")
prohibit_modifier = pp.Literal("-")("prohibit")
integer = ppc.integer()
proximity_modifier = pp.Group(TILDE + integer("proximity"))
number = ppc.fnumber()
fuzzy_modifier = TILDE + pp.Optional(number, default=0.5)("fuzzy")
term = pp.Forward()
field_name = valid_word().setName("fieldname")
incl_range_search = pp.Group(LBRACK - term("lower") + to_ + term("upper") + RBRACK)
excl_range_search = pp.Group(LBRACE - term("lower") + to_ + term("upper") + RBRACE)
range_search = incl_range_search("incl_range") | excl_range_search("excl_range")
boost = CARAT - number("boost")
string_expr = pp.Group(string + proximity_modifier) | string
word_expr = pp.Group(valid_word + fuzzy_modifier) | valid_word
term << (
pp.Optional(field_name("field") + COLON)
TRUE = make_keyword("true", True)
FALSE = make_keyword("false", False)
NULL = make_keyword("null", None)
ed5 = make_keyword("|>|", 'increased_in_magnitude_relative_to')
ed6 = make_keyword("|<|", 'decreased_in_magnitude_relative_to')
ed7 = make_keyword("|=|", 'has_count')
ed1 = make_keyword(">", 'has_part')
ed3 = make_keyword("<", 'part_of')
ed2 = make_keyword('>>', 'bearer_of')
ed4 = make_keyword('<<', 'inheres_in')
#graph_word = Word(alphanums +"_", alphanums+"_")
#jsonNumber = ppc.number()
phsInt = ppc.integer()('num_int')
phsReal = ppc.real()('num_real')
graph_alphanum = Word(alphanums + "_" + "-")
#graph_alphanum = Word(alphanums +"_", alphanums+"_")
graph_word = (phsReal | phsInt | graph_alphanum)
#----------- Node
# Node Properties: N[]
propertyWord = Word(alphanums + "_" + ":") # in []
#jsonString = quotedString().setParseAction(removeQuotes)
jsonStr = quotedString().setParseAction(removeQuotes)
jsonString = (jsonStr | propertyWord)
jsonNumber = ppc.number()
def __mk_grammar(self):
""" Метод, в котором создаётся описание грамматики, вызывается в конструкторе класса Parser. """
# Описание LiteralNode и IdentNode
num = ppc.integer() | ppc.real()
str_ = pp.QuotedString('"', escChar='\\', unquoteResults=True, convertWhitespaceEscapes=False)
literal = (num | str_).setName('Literal')
ident = ppc.identifier.setName('Ident')
# Описание ключевых слов
VAR_KW, FUNC_KW, RETURN_KW = pp.Keyword('var'), pp.Keyword('function'), pp.Keyword('return')
IF_KW, ELSE_KW = pp.Keyword('if'), pp.Keyword('else')
FOR_KW, DO_KW, WHILE_KW = pp.Keyword('for'), pp.Keyword('do'), pp.Keyword('while')
# Описание различных скобок, запятой и точки с запятой.
L_PAR, R_PAR = pp.Literal('(').suppress(), pp.Literal(')').suppress()
L_BRACKET, R_BRACKET = pp.Literal('{').suppress(), pp.Literal('}').suppress()
SEMICOLON, COMMA = pp.Literal(';').suppress(), pp.Literal(',').suppress()
# Описание операторов
ASSIGN = pp.Literal('=')
ADD, SUB, MUL, DIV, MOD, EXP = pp.Literal('+'), pp.Literal('-'), pp.Literal('*'), pp.Literal('/'), \
pp.Literal('%'), pp.Literal('**')
LOG_AND, LOG_OR, LOG_NOT = pp.Literal('&&'), pp.Literal('||'), pp.Literal('!')
GT, LT, GE, LE = pp.Literal('>'), pp.Literal('<'), pp.Literal('>='), pp.Literal('<=')
NEQ, EQ = pp.Literal('!='), pp.Literal('==')
INCR, DECR = pp.Literal('++'), pp.Literal('--')
# Объявляем переменные, описывающие операции умножения, сложения и Выражение. Они определяются дальше в коде.
mul_op = pp.Forward()
add_op = pp.Forward()
expr = pp.Forward()
# Описание вызова функции
call = (ident + L_PAR + pp.Optional(expr + pp.ZeroOrMore(COMMA + expr)) + R_PAR).setName('Call')
# Описание унарных операций: инкремент, декремент.
incr_op = (ident + INCR).setName('UnaryExpr')
decr_op = (ident + DECR).setName('UnaryExpr')
group = (literal | call | ident | L_PAR + expr + R_PAR)
# Описание бинарных выражений.
mul_op << pp.Group(group + pp.ZeroOrMore((EXP | MUL | DIV | MOD) + group)).setName('BinExpr')
add_op << pp.Group(mul_op + pp.ZeroOrMore((ADD | SUB) + mul_op)).setName('BinExpr')
compare = pp.Group(add_op + pp.ZeroOrMore((GE | LE | GT | LT) + add_op)).setName('BinExpr')
compare_eq = pp.Group(compare + pp.ZeroOrMore((EQ | NEQ) + compare)).setName('BinExpr')
log_and_op = pp.Group(compare_eq + pp.ZeroOrMore(LOG_AND + compare_eq)).setName('BinExpr')
log_or_op = pp.Group(log_and_op + pp.ZeroOrMore(LOG_OR + log_and_op)).setName('BinExpr')
expr << log_or_op
# Описание присвоения и объявления переменных.
assign = (ident + ASSIGN + expr).setName('BinExpr')
simple_assign = (ident + ASSIGN.suppress() + expr)
var_item = simple_assign | ident
simple_var = (VAR_KW.suppress() + var_item).setName('Declarator')
mult_var_item = (COMMA + var_item).setName('Declarator')
mult_var = (simple_var + pp.ZeroOrMore(mult_var_item)).setName('VarDeclaration')
stmt = pp.Forward()
simple_stmt = assign | call | incr_op | decr_op
# Описание цикла for.
for_statement_list = pp.Optional(simple_stmt + pp.ZeroOrMore(COMMA + simple_stmt)).setName('BlockStatement')
for_statement = mult_var | for_statement_list
for_test = expr | pp.Group(pp.empty)
for_block = stmt | pp.Group(SEMICOLON).setName('BlockStatement')
# Описание циклов for, while, do while, условного оператора if.
if_ = (IF_KW.suppress() + L_PAR + expr + R_PAR + stmt + pp.Optional(ELSE_KW.suppress() + stmt)).setName('If')
for_ = (FOR_KW.suppress() + L_PAR + for_statement + SEMICOLON + for_test + SEMICOLON +
for_statement + R_PAR + for_block).setName('For')
while_ = (WHILE_KW.suppress() + L_PAR + expr + R_PAR + stmt).setName('While')
do_while = (DO_KW.suppress() + stmt + WHILE_KW.suppress() + L_PAR + expr + R_PAR).setName('DoWhile')
# Описание блока кода в { } и без них, аргументов функции, объявления функции и оператора return.
block = pp.ZeroOrMore(stmt + pp.ZeroOrMore(SEMICOLON)).setName('BlockStatement')
br_block = L_BRACKET + block + R_BRACKET
args = ((expr + pp.ZeroOrMore(COMMA + expr)) | pp.Group(pp.empty)).setName("Args")
func_decl = (FUNC_KW.suppress() + ident + L_PAR + args + R_PAR + br_block)\
.setName('FuncDeclaration')
return_ = (RETURN_KW.suppress() + expr).setName('Return')
stmt << (
if_ |
for_ |
while_ |
do_while |
br_block |
mult_var + SEMICOLON |
simple_stmt + SEMICOLON |
func_decl |
return_
)
# locals().copy().items() возвращает словарь всех переменных в текущей области видимости
# все элементы этого словаря перебираются в цикле for
for var_name, value in locals().copy().items():
# проверка на то, что текущий элемент является экземлпяром класса ParserElement
if isinstance(value, pp.ParserElement):
# вызов метода __set_parse_action
self.__set_parse_action(var_name, value)
return block.ignore(pp.cStyleComment).ignore(pp.dblSlashComment) + pp.stringEnd
NOT, AND, OR = map(CaselessKeyword, "NOT AND OR".split())
BEFORE, AFTER, JOIN = map(CaselessKeyword, "BEFORE AFTER JOIN".split())
lpar = Suppress('{')
rpar = Suppress('}')
keyword = MatchFirst([
LINE_CONTAINS, LINE_STARTSWITH, LINE_ENDSWITH, NOT, AND, OR, BEFORE, AFTER,
JOIN
]) # declaring all keywords and assigning order for all further use
phrase_word = ~keyword + (Word(alphanums + '_'))
upto_N_words = Group(lpar + 'upto' +
pyparsing_common.integer('numberofwords') + 'words' +
rpar)
upto_N_chars = Group(lpar + 'upto' +
pyparsing_common.integer('numberofchars') + 'characters' +
rpar)
phrase_term = Group(
OneOrMore(phrase_word) + ZeroOrMore((
(upto_N_words) | ZeroOrMore(upto_N_chars)) + OneOrMore(phrase_word))
) | quotedString # changed phrase_word to OneOrMore(phrase_word) to allow multi-word phrases
# phrase-term
# want to know if there is a way to just say that the phrase_term can contain both types of elements instead of
# having to give the exact grammar for it as p_w+upto+p_W
phrase_expr = infixNotation(
LINE_CONTAINS, LINE_STARTSWITH, LINE_ENDSWITH = map(CaselessKeyword,
"""LINE_CONTAINS LINE_STARTSWITH LINE_ENDSWITH""".split()) # put option for LINE_ENDSWITH. Users may use, I don't presently
NOT, AND, OR = map(CaselessKeyword, "NOT AND OR".split())
BEFORE, AFTER, JOIN = map(CaselessKeyword, "BEFORE AFTER JOIN".split())
lpar=Suppress('{')
rpar=Suppress('}')
keyword = MatchFirst([LINE_CONTAINS, LINE_STARTSWITH, LINE_ENDSWITH, NOT, AND, OR,
BEFORE, AFTER, JOIN]) # declaring all keywords and assigning order for all further use
phrase_word = ~keyword + (Word(alphanums + '_'))
upto_N_words = Group(lpar + 'upto' + pyparsing_common.integer('numberofwords') + 'words' + rpar)
upto_N_chars = Group(lpar + 'upto' + pyparsing_common.integer('numberofchars') + 'characters' + rpar)
phrase_term = Group(OneOrMore(phrase_word) + ZeroOrMore(((upto_N_words) | ZeroOrMore(upto_N_chars)) + OneOrMore(phrase_word))) | quotedString # changed phrase_word to OneOrMore(phrase_word) to allow multi-word phrases
# phrase-term
# want to know if there is a way to just say that the phrase_term can contain both types of elements instead of
# having to give the exact grammar for it as p_w+upto+p_W
phrase_expr = infixNotation(phrase_term,
[
((BEFORE | AFTER | JOIN), 2, opAssoc.LEFT,), # (opExpr, numTerms, rightLeftAssoc, parseAction)
(NOT, 1, opAssoc.RIGHT,),
(AND, 2, opAssoc.LEFT,),
(OR, 2, opAssoc.LEFT),
def get_truncation_language():
language = truncation_tag + nest(ppc.integer(TRUNCATION_POSITION))
language.setParseAction(_handle_trunc_legacy)
return language
def create(cls, base_shader_path, base_texture_path):
"""
Create a Stanford polygon file parser (PLY).
:param base_shader_path:
:param base_texture_path:
:return:
"""
# Define the base patterns for parsing
real = pyparsing_common.real()
integer = pyparsing_common.integer()
# Define how the header portion begins and ends
start_keyword = cls._or(cls.begin_header_keyword, suppress=True)
stop_keyword = cls._or(cls.end_header_keyword, suppress=True)
# Define the grammar of a comment statement
comment_keyword = cls._or(cls.comment_keyword, suppress=True)
vertex_shader_comment = Group(
comment_keyword + Suppress(CaselessKeyword("VertexShaderFile")) +
Word(alphanums + ".-_"))("vertex_shader_file")
fragment_shader_comment = Group(
comment_keyword + Suppress(CaselessKeyword("FragmentShaderFile")) +
Word(alphanums + ".-_"))("fragment_shader_file")
texture_comment = Group(comment_keyword +
Suppress(CaselessKeyword("TextureFile")) +
Word(alphanums + ".-_"))("texture_file")
other_comment = comment_keyword + NotAny("TextureFile") + Word(
printables + " ")
# Define the grammar of a format statement
format_keyword = cls._or(cls.format_keyword, suppress=True)
format_type = cls._or(cls.format_type_map)
format_expr = Group(format_keyword + format_type("file_type") +
real("version"))("format")
# Define the grammar of properties
property_keyword = cls._or(cls.property_keyword, suppress=True)
list_keyword = cls._or(cls.list_keyword, suppress=True)
property_type = cls._or(cls.data_type_map)
psp = property_keyword + property_type("data_type")
position_keywords = [cls._or(k) for k in ("x", "y", "z")]
property_position = cls._aggregate_property("position", psp,
*position_keywords)
property_color = Group(
And([
Group(psp + MatchFirst((CaselessKeyword("r"),
CaselessKeyword("red")))("name")),
Group(psp + MatchFirst((CaselessKeyword("g"),
CaselessKeyword("green")))("name")),
Group(psp + MatchFirst((CaselessKeyword("b"),
CaselessKeyword("blue")))("name")),
Optional(
Group(psp +
MatchFirst((CaselessKeyword("a"),
CaselessKeyword("alpha")))("name")), )
]))("color")
ambient_keywords = [
cls._or(k) for k in ("ambient_red", "ambient_green",
"ambient_blue", "ambient_alpha")
]
property_ambient_color = cls._aggregate_property(
"ambient_color", psp, *ambient_keywords)
diffuse_keywords = [
cls._or(k) for k in ("diffuse_red", "diffuse_green",
"diffuse_blue", "diffuse_alpha")
]
property_diffuse_color = cls._aggregate_property(
"diffuse_color", psp, *diffuse_keywords)
specular_keywords = [
cls._or(k) for k in ("specular_red", "specular_green",
"specular_blue", "specular_alpha")
]
property_specular_color = cls._aggregate_property(
"specular_color", psp, *specular_keywords)
texture_keywords = [
cls._or(*k) for k in (("s", "u", "tx"), ("t", "v", "ty"))
]
property_texture = cls._aggregate_property("texture", psp,
*texture_keywords)
normal_keywords = [cls._or(k) for k in ("nx", "ny", "nz")]
property_normal = cls._aggregate_property("normal", psp,
*normal_keywords)
power_keywords = [CaselessKeyword("specular_power")]
property_specular_power = cls._aggregate_property(
"specular_power", psp, *power_keywords)
opacity_keywords = [CaselessKeyword("opacity")]
property_opacity = cls._aggregate_property("opacity", psp,
*opacity_keywords)
plp = property_keyword + list_keyword + property_type(
"index_type") + property_type("data_type")
vertex_index_keywords = [cls._or("vertex_index", "vertex_indices")]
property_vertex_index = cls._aggregate_property(
"vertex_index", plp, *vertex_index_keywords)
material_index_keywords = [
cls._or("material_index", "material_indices")
]
property_material_index = cls._aggregate_property(
"material_index", plp, *material_index_keywords)
# Define the grammar of elements
element_keyword = cls._or(cls.element_keyword, suppress=True)
element_vertex = Group(
element_keyword + CaselessKeyword("vertex")("name") +
integer("count") + Group(
OneOrMore(property_position | property_color
| property_ambient_color | property_diffuse_color
| property_specular_color | property_texture
| property_normal | property_specular_power
| property_opacity))("properties"))
element_face = Group(element_keyword +
CaselessKeyword("face")("name") +
integer("count") +
Group(property_vertex_index
| property_material_index)("properties"))
element_group = element_vertex | element_face
declarations = format_expr + \
Group(ZeroOrMore(vertex_shader_comment | fragment_shader_comment | texture_comment | other_comment))("comments") + \
Group(OneOrMore(element_group))("elements")
header_grammar = start_keyword + declarations + stop_keyword
return cls(header_grammar, base_shader_path, base_texture_path)
alphas,
alphanums,
Combine,
oneOf,
Optional,
QuotedString,
Forward,
Group,
ZeroOrMore,
srange,
pyparsing_common as ppc,
)
MARK, UNMARK, AT, COLON, QUOTE = map(Suppress, "[]@:'")
NUMBER = ppc.integer()
FLOAT = ppc.real()
STRING = QuotedString('"', multiline=True) | QuotedString("'", multiline=True)
WORD = Word(alphas, alphanums + "_:")
ATTRIBUTE = Combine(AT + WORD)
strBody = Forward()
def setBodyLength(tokens):
strBody << Word(srange(r"[\0x00-\0xffff]"), exact=int(tokens[0]))
return ""
BLOB = Combine(
QUOTE + Word(nums).setParseAction(setBodyLength) + COLON + strBody + QUOTE
