def pyparse_gml():
"""A pyparsing tokenizer for GML graph format.
This is not intended to be called directly.
See Also
--------
write_gml, read_gml, parse_gml
"""
try:
from pyparsing import \
Literal, CaselessLiteral, Word, Forward,\
ZeroOrMore, Group, Dict, Optional, Combine,\
ParseException, restOfLine, White, alphas, alphanums, nums,\
OneOrMore,quotedString,removeQuotes,dblQuotedString, Regex
except ImportError:
try:
from matplotlib.pyparsing import \
Literal, CaselessLiteral, Word, Forward,\
ZeroOrMore, Group, Dict, Optional, Combine,\
ParseException, restOfLine, White, alphas, alphanums, nums,\
OneOrMore,quotedString,removeQuotes,dblQuotedString, Regex
except:
raise ImportError('pyparsing not found',
'http://pyparsing.wikispaces.com/')
lbrack = Literal("[").suppress()
rbrack = Literal("]").suppress()
pound = ("#")
comment = pound + Optional(restOfLine)
integer = Word(nums + '-').setParseAction(lambda s, l, t: [int(t[0])])
real = Regex(r"[+-]?\d+\.\d*([eE][+-]?\d+)?").setParseAction(
lambda s, l, t: [float(t[0])])
dblQuotedString.setParseAction(removeQuotes)
key = Word(alphas, alphanums + '_')
value_atom = (real | integer | Word(alphanums) | dblQuotedString)
value = Forward() # to be defined later with << operator
keyvalue = Group(key + value)
value << (value_atom | Group(lbrack + ZeroOrMore(keyvalue) + rbrack))
node = Group(
Literal("node") + lbrack + Group(OneOrMore(keyvalue)) + rbrack)
edge = Group(
Literal("edge") + lbrack + Group(OneOrMore(keyvalue)) + rbrack)
creator = Group(Literal("Creator") + Optional(restOfLine))
version = Group(Literal("Version") + Optional(restOfLine))
graphkey = Literal("graph").suppress()
graph = Dict (Optional(creator)+Optional(version)+\
graphkey + lbrack + ZeroOrMore( (node|edge|keyvalue) ) + rbrack )
graph.ignore(comment)
return graph
def pyparse_gml():
"""A pyparsing tokenizer for GML nxgraph format.
This is not intended to be called directly.
See Also
--------
write_gml, read_gml, parse_gml
"""
try:
from pyparsing import \
Literal, CaselessLiteral, Word, Forward,\
ZeroOrMore, Group, Dict, Optional, Combine,\
ParseException, restOfLine, White, alphas, alphanums, nums,\
OneOrMore,quotedString,removeQuotes,dblQuotedString, Regex
except ImportError:
try:
from matplotlib.pyparsing import \
Literal, CaselessLiteral, Word, Forward,\
ZeroOrMore, Group, Dict, Optional, Combine,\
ParseException, restOfLine, White, alphas, alphanums, nums,\
OneOrMore,quotedString,removeQuotes,dblQuotedString, Regex
except:
raise ImportError('pyparsing not found',
'http://pyparsing.wikispaces.com/')
lbrack = Literal("[").suppress()
rbrack = Literal("]").suppress()
pound = ("#")
comment = pound + Optional( restOfLine )
integer = Word(nums+'-').setParseAction(lambda s,l,t:[ int(t[0])])
real = Regex(r"[+-]?\d+\.\d*([eE][+-]?\d+)?").setParseAction(
lambda s,l,t:[ float(t[0]) ])
dblQuotedString.setParseAction( removeQuotes )
key = Word(alphas,alphanums+'_')
value_atom = (real | integer | Word(alphanums) | dblQuotedString)
value = Forward() # to be defined later with << operator
keyvalue = Group(key+value)
value << (value_atom | Group( lbrack + ZeroOrMore(keyvalue) + rbrack ))
node = Group(Literal("node") + lbrack + Group(OneOrMore(keyvalue)) + rbrack)
edge = Group(Literal("edge") + lbrack + Group(OneOrMore(keyvalue)) + rbrack)
creator = Group(Literal("Creator")+ Optional( restOfLine ))
version = Group(Literal("Version")+ Optional( restOfLine ))
graphkey = Literal("nxgraph").suppress()
graph = Dict (Optional(creator)+Optional(version)+\
graphkey + lbrack + ZeroOrMore( (node|edge|keyvalue) ) + rbrack )
graph.ignore(comment)
return graph
def parse_sexp(data):
'''parse sexp/S-expression format and return a python list'''
# define punctuation literals
LPAR, RPAR, LBRK, RBRK, LBRC, RBRC, VBAR = map(Suppress, "()[]{}|")
decimal = Word("123456789", nums).setParseAction(lambda t: int(t[0]))
bytes = Word(printables)
raw = Group(decimal.setResultsName("len") + Suppress(":") + bytes).setParseAction(OtrPrivateKeys.verifyLen)
token = Word(alphanums + "-./_:*+=")
base64_ = Group(Optional(decimal, default=None).setResultsName("len") + VBAR
+ OneOrMore(Word( alphanums +"+/=" )).setParseAction(lambda t: b64decode("".join(t)))
+ VBAR).setParseAction(OtrPrivateKeys.verifyLen)
hexadecimal = ("#" + OneOrMore(Word(hexnums)) + "#")\
.setParseAction(lambda t: int("".join(t[1:-1]),16))
qString = Group(Optional(decimal, default=None).setResultsName("len") +
dblQuotedString.setParseAction(removeQuotes)).setParseAction(OtrPrivateKeys.verifyLen)
simpleString = raw | token | base64_ | hexadecimal | qString
display = LBRK + simpleString + RBRK
string_ = Optional(display) + simpleString
sexp = Forward()
sexpList = Group(LPAR + ZeroOrMore(sexp) + RPAR)
sexp << ( string_ | sexpList )
try:
sexpr = sexp.parseString(data)
return sexpr.asList()[0][1:]
except ParseFatalException, pfe:
print("Error:", pfe.msg)
print(pfe.loc)
print(pfe.markInputline())
def get_idl_line_parser():
"""
Based on http://pyparsing.wikispaces.com/file/view/parsePythonValue.py
"""
from pyparsing import \
Word, ZeroOrMore, OneOrMore, Optional, oneOf, StringEnd, Suppress, Group, Combine, \
nums, dblQuotedString, removeQuotes
s = Suppress
int_number = Combine(Optional(oneOf("+ -")) + Word(nums)).setParseAction(
lambda tokens: int(tokens[0])).setName("integer")
float_number = \
Combine(Optional(oneOf("+ -")) + Word(nums) + Optional("." +
Optional(Word(nums)) +
Optional(oneOf("e E")+Optional(oneOf("+ -")) +Word(nums)))) \
.setName("float") \
.setParseAction( lambda tokens: float(tokens[0]) )
bounding_box = s('(') + OneOrMore(int_number | s(',')) + s(')')
bounding_box_with_score = Group(bounding_box +
Optional((s(":") | s("~")) + float_number))
#filename = s('"') + Word(alphanums + "/_.~") + s('"')
quoted = dblQuotedString.setParseAction(removeQuotes)
filename = quoted
idl_line = filename + Optional(
s(':') + ZeroOrMore(bounding_box_with_score | s(','))) + (
s(";") | s(".")) + StringEnd()
#print( filename.parseString("\"left/image_00000004_0.png\"") )
#print( bounding_box.parseString("(221, 183, 261, 289)") )
return idl_line.parseString
def __init__(self, args):
super(HuginParser, self).__init__(args)
self.domains = {}
self.potentials = []
S = Suppress
p_optval = Or(
[dblQuotedString,
S("(") + OneOrMore(Word(nums)) + S(")")])
p_option = S(
Group(Word(alphanums + "_") + S("=") + Group(p_optval) + S(";")))
p_net = S(Word("net") + "{" + ZeroOrMore(p_option) + "}")
p_var = Word(alphanums + "_")
p_val = dblQuotedString.setParseAction(removeQuotes)
p_states = Group(
Word("states") + S("=") + S("(") + Group(OneOrMore(p_val)) +
S(")") + S(";"))
p_node = S(Word("node")) + p_var + S("{") + Group(
ZeroOrMore(Or([p_states, p_option]))) + S("}")
p_par = Regex(r'\d+(\.\d*)?([eE]\d+)?')
p_parlist = Forward()
p_parlist << S("(") + Or([OneOrMore(p_par),
OneOrMore(p_parlist)]) + S(")")
p_data = S(Word("data")) + S("=") + Group(p_parlist) + S(";")
p_potential = S(Word("potential")) + S("(") + p_var + Group(Optional(S("|") + OneOrMore(p_var))) + S(")") + S("{") + \
p_data + S("}")
p_option.setParseAction(self.parse_option)
p_node.setParseAction(self.parse_node)
p_potential.setParseAction(self.parse_potential)
self.parser = OneOrMore(Or([p_net, p_node, p_potential]))
def get_idl_line_parser():
"""
Based on http://pyparsing.wikispaces.com/file/view/parsePythonValue.py
"""
from pyparsing import \
Word, ZeroOrMore, OneOrMore, Optional, oneOf, StringEnd, Suppress, Group, Combine, \
nums, dblQuotedString, removeQuotes
s = Suppress
int_number = Combine(Optional(oneOf("+ -")) + Word(nums)).setParseAction(lambda tokens: int(tokens[0])).setName("integer")
float_number = \
Combine(Optional(oneOf("+ -")) + Word(nums) + Optional("." +
Optional(Word(nums)) +
Optional(oneOf("e E")+Optional(oneOf("+ -")) +Word(nums)))) \
.setName("float") \
.setParseAction( lambda tokens: float(tokens[0]) )
bounding_box = s('(') + OneOrMore( int_number | s(',') ) + s(')')
bounding_box_with_score = Group(bounding_box + Optional( ( s(":") | s("~") ) + float_number ))
#filename = s('"') + Word(alphanums + "/_.~") + s('"')
quoted = dblQuotedString.setParseAction(removeQuotes)
filename = quoted
idl_line = filename + Optional(s(':') + ZeroOrMore(bounding_box_with_score | s(','))) + ( s(";") | s(".") ) + StringEnd()
#print( filename.parseString("\"left/image_00000004_0.png\"") )
#print( bounding_box.parseString("(221, 183, 261, 289)") )
return idl_line.parseString
def __init__(self, db):
"""Initialize a new RDF parser with pre-defined grammar. Takes database db as an argument."""
self.__db = db
# grammar definition
# literals
self.__word = self.__prefix = self.__suffix = Word(alphanums)
self.__colon = Literal(':')
self.__a = Literal('a')
self.__quoted_string = dblQuotedString.setParseAction(removeQuotes)
self.__l_paren = Suppress('(')
self.__r_paren = Suppress(')')
self.__dot = Suppress('.')
self.__comma = Suppress(',')
self.__semicolon = Suppress(';')
# composites
self.__get_suffix = Suppress(self.__prefix + self.__colon) + self.__suffix
self.__get_object = Optional(self.__l_paren) + OneOrMore((self.__get_suffix | self.__quoted_string) +
Optional(self.__comma)) + Optional(self.__r_paren)
self.__is_a = (self.__get_suffix('subject') | self.__word) + self.__a('relation') + \
self.__get_suffix('object') + self.__dot
self.__has_x = self.__get_suffix('subject') + self.__get_suffix('relation') + \
Group(self.__get_object)('object') + self.__dot
# search term
self.__search = Forward()
self.__search << (self.__is_a | self.__has_x)
def grammar():
# terminals ----------------------------------
colon = Literal(':')
equal = Suppress('=')
slash = Suppress('/')
open_paren = Suppress('(')
close_paren = Suppress(')')
open_brace = Suppress('{')
close_brace = Suppress('}')
# np:tagName ---------------------------------
nspfx = Word(alphas)
local_name = Word(alphanums)
tagname = Combine(nspfx + colon + local_name)
# np:attr_name=attr_val ----------------------
attr_name = Word(alphas + ':')
attr_val = Word(alphanums + ' %-./:_')
attr_def = Group(attr_name + equal + attr_val)
attr_list = open_brace + delimitedList(attr_def) + close_brace
text = dblQuotedString.setParseAction(removeQuotes)
# w:jc{val=right} ----------------------------
element = (
tagname('tagname')
+ Group(Optional(attr_list))('attr_list')
+ Optional(text, default='')('text')
).setParseAction(Element.from_token)
child_node_list = Forward()
node = Group(
element('element')
+ Group(Optional(slash + child_node_list))('child_node_list')
).setParseAction(connect_node_children)
child_node_list << (
open_paren + delimitedList(node) + close_paren
| node
)
root_node = (
element('element')
+ Group(Optional(slash + child_node_list))('child_node_list')
+ stringEnd
).setParseAction(connect_root_node_children)
return root_node
def get_parser():
op_literal = ((Word(alphanums + ",.-_")
| dblQuotedString.setParseAction(removeQuotes)
| sglQuotedString.addParseAction(removeQuotes)).
addParseAction(toks0(Literal)))
op_tag = (Keyword('tag')
+ Suppress('[')
+ op_literal
+ Suppress(']')).setParseAction(Tag)
op_value = (op_tag
| (oneOf(" ".join(Variable.VARIABLES))
.setParseAction(toks0(Variable))))
op_lhs = op_value
op_rhs = op_value | op_literal
op_compare = (Keyword("=") | Keyword("~") | Keyword("!=") | Keyword("!~"))
op_and = Keyword("and")
op_or = Keyword("or")
op_not = Keyword("not")
op_true = Suppress(Keyword("true")).setParseAction(toksz(AlwaysTrue))
op_false = Suppress(Keyword("false")).setParseAction(toksz(AlwaysFalse))
op_compare_expression = ((op_lhs
+ op_compare
+ op_rhs)
.addParseAction(toks(Comparison)))
op_test_expression = (Group(op_lhs)
.addParseAction(lambda s, l, t: t[0])
.addParseAction(NotNull))
op_value_expression = (op_false
| op_true
| op_compare_expression
| op_test_expression)
op_expression = (
StringStart()
+ infixNotation(
op_value_expression,
[(Suppress(op_not), 1, opAssoc.RIGHT, toks00(Not)),
(Suppress(op_and), 2, opAssoc.LEFT, toks0(And)),
(Suppress(op_or), 2, opAssoc.LEFT, toks0(Or))])
+ StringEnd())
return op_expression
def grammar():
# terminals ----------------------------------
colon = Literal(':')
equal = Suppress('=')
slash = Suppress('/')
open_paren = Suppress('(')
close_paren = Suppress(')')
open_brace = Suppress('{')
close_brace = Suppress('}')
# np:tagName ---------------------------------
nspfx = Word(alphas)
local_name = Word(alphas)
tagname = Combine(nspfx + colon + local_name)
# np:attr_name=attr_val ----------------------
attr_name = Word(alphas + ':')
attr_val = Word(alphanums + ' -.%')
attr_def = Group(attr_name + equal + attr_val)
attr_list = open_brace + delimitedList(attr_def) + close_brace
text = dblQuotedString.setParseAction(removeQuotes)
# w:jc{val=right} ----------------------------
element = (
tagname('tagname')
+ Group(Optional(attr_list))('attr_list')
+ Optional(text, default='')('text')
).setParseAction(Element.from_token)
child_node_list = Forward()
node = Group(
element('element')
+ Group(Optional(slash + child_node_list))('child_node_list')
).setParseAction(connect_node_children)
child_node_list << (
open_paren + delimitedList(node) + close_paren
| node
)
root_node = (
element('element')
+ Group(Optional(slash + child_node_list))('child_node_list')
+ stringEnd
).setParseAction(connect_root_node_children)
return root_node
def getpattern(self):
# define grammar
point = Literal('.')
e = CaselessLiteral('E')
plusorminus = Literal('+') | Literal('-')
number = Word(nums)
integer = Combine( Optional(plusorminus) + number )
floatnumber = Combine( integer +
Optional( point + Optional(number) ) +
Optional( e + integer )
)
ident = Word(alphas,alphanums + '_@' )
plus,minus,mult,div = map(Literal,'+-*/')
lpar,rpar,comma,semicolon = map(lambda x: Literal(x).suppress(), '(),;')
addop = plus | minus
multop = mult | div
expop = Literal( "^" )
assign = Literal( "=" )
expr = Forward()
arglist = Group(Group(expr) + ZeroOrMore( comma + Group(expr)) | Empty()).setParseAction(self.pushArgCount)
atom = (
Optional(oneOf("- +")) + (ident+lpar+arglist+rpar).setParseAction(self.pushFunctionCall)
| (Optional(oneOf("- +")) +
(floatnumber|integer|ident).setParseAction(self.pushFirst))
| Optional(oneOf("- +")) + Group(lpar+expr+rpar)
).setParseAction(self.pushUnaryminus)
factor = Forward()
factor << atom + ZeroOrMore( ( expop + factor ).setParseAction( self.pushFirst ) )
term = factor + ZeroOrMore( ( multop + factor ).setParseAction( self.pushFirst ) )
expr << ( term + ZeroOrMore( ( addop + term ).setParseAction( self.pushFirst ) )
| Group(dblQuotedString.setParseAction(removeQuotes)).setParseAction( self.pushString ) )
bnf = (Optional((ident + assign).setParseAction(self.assignVar)) + expr).setParseAction( self.pushAssign )
label = semicolon + SkipTo(StringEnd()).setParseAction( self.pushLabel)
pattern = bnf + Optional(label) + StringEnd()
return pattern
def grammar():
# terminals ----------------------------------
colon = Literal(":")
equal = Suppress("=")
slash = Suppress("/")
open_paren = Suppress("(")
close_paren = Suppress(")")
open_brace = Suppress("{")
close_brace = Suppress("}")
# np:tagName ---------------------------------
nspfx = Word(alphas)
local_name = Word(alphanums)
tagname = Combine(nspfx + colon + local_name)
# np:attr_name=attr_val ----------------------
attr_name = Word(alphas + ":")
attr_val = Word(alphanums + " %-./:_")
attr_def = Group(attr_name + equal + attr_val)
attr_list = open_brace + delimitedList(attr_def) + close_brace
text = dblQuotedString.setParseAction(removeQuotes)
# w:jc{val=right} ----------------------------
element = (tagname("tagname") + Group(Optional(attr_list))("attr_list") +
Optional(text, default="")("text")).setParseAction(
Element.from_token)
child_node_list = Forward()
node = Group(
element("element") + Group(Optional(slash + child_node_list))
("child_node_list")).setParseAction(connect_node_children)
child_node_list << (open_paren + delimitedList(node) + close_paren | node)
root_node = (element("element") +
Group(Optional(slash + child_node_list))("child_node_list") +
stringEnd).setParseAction(connect_root_node_children)
return root_node
def parse_sexp(data):
'''parse sexp/S-expression format and return a python list'''
# define punctuation literals
LPAR, RPAR, LBRK, RBRK, LBRC, RBRC, VBAR = map(Suppress, "()[]{}|")
decimal = Word("123456789", nums).setParseAction(lambda t: int(t[0]))
bytes = Word(printables)
raw = Group(decimal.setResultsName("len") + Suppress(":") +
bytes).setParseAction(OtrPrivateKeys.verifyLen)
token = Word(alphanums + "-./_:*+=")
base64_ = Group(
Optional(decimal, default=None).setResultsName("len") + VBAR +
OneOrMore(Word(alphanums + "+/=")).setParseAction(
lambda t: b64decode("".join(t))) + VBAR).setParseAction(
OtrPrivateKeys.verifyLen)
hexadecimal = ("#" + OneOrMore(Word(hexnums)) + "#")\
.setParseAction(lambda t: int("".join(t[1:-1]),16))
qString = Group(
Optional(decimal, default=None).setResultsName("len") +
dblQuotedString.setParseAction(removeQuotes)).setParseAction(
OtrPrivateKeys.verifyLen)
simpleString = raw | token | base64_ | hexadecimal | qString
display = LBRK + simpleString + RBRK
string_ = Optional(display) + simpleString
sexp = Forward()
sexpList = Group(LPAR + ZeroOrMore(sexp) + RPAR)
sexp << (string_ | sexpList)
try:
sexpr = sexp.parseString(data)
return sexpr.asList()[0][1:]
except ParseFatalException, pfe:
print("Error:", pfe.msg)
print(pfe.loc)
print(pfe.markInputline())
def _parse_formula(text):
"""
>>> formula = "p(a,b)"
>>> print(_parse_formula(formula))
['p', ['a', 'b']]
>>> formula = "~p(a,b)"
>>> print(_parse_formula(formula))
['~', ['p', ['a', 'b']]]
>>> formula = "=(a,b)"
>>> print(_parse_formula(formula))
['=', ['a', 'b']]
>>> formula = "<(a,b)"
>>> print(_parse_formula(formula))
['<', ['a', 'b']]
>>> formula = "~p(a)"
>>> print(_parse_formula(formula))
['~', ['p', ['a']]]
>>> formula = "~p(a)|a(p)"
>>> print(_parse_formula(formula))
[['~', ['p', ['a']]], '|', ['a', ['p']]]
>>> formula = "p(a) | p(b)"
>>> print(_parse_formula(formula))
[['p', ['a']], '|', ['p', ['b']]]
>>> formula = "~p(a) | p(b)"
>>> print(_parse_formula(formula))
[['~', ['p', ['a']]], '|', ['p', ['b']]]
>>> formula = "p(f(a)) | p(b)"
>>> print(_parse_formula(formula))
[['p', [['f', ['a']]]], '|', ['p', ['b']]]
>>> formula = "p(a) | p(b) | p(c)"
>>> print(_parse_formula(formula))
[['p', ['a']], '|', ['p', ['b']], '|', ['p', ['c']]]
>>> formula = 'p("http://dbpedia.org/ontology/MeanOfTransportation_,_Instrument","1b")'
>>> print(_parse_formula(formula))
['p', ['http://dbpedia.org/ontology/MeanOfTransportation_,_Instrument', '1b']]
>>> formula = '"http://dbpedia.org/ontology/range"("http://dbpedia.org/ontology/MeanOfTransportation_,_Instrument","1b")'
>>> print(_parse_formula(formula))
['http://dbpedia.org/ontology/range', ['http://dbpedia.org/ontology/MeanOfTransportation_,_Instrument', '1b']]
"""
left_parenthesis, right_parenthesis, colon = map(Suppress, "():")
exists = Keyword("exists")
forall = Keyword("forall")
implies = Literal("->")
or_ = Literal("|")
and_ = Literal("&")
not_ = Literal("~")
equiv_ = Literal("%")
symbol = Word(alphas + "_" + "?" + ".", alphanums + "_" + "?" + "." + "-") | \
dblQuotedString.setParseAction(removeQuotes)
term = Forward()
term << (Group(symbol + Group(left_parenthesis + delimitedList(term) +
right_parenthesis)) | symbol)
pred_symbol = Word(alphas + "_" + ".", alphanums + "_" + "." + "-") | Literal("=") | Literal("<") | \
dblQuotedString.setParseAction(removeQuotes)
literal = Forward()
literal << (Group(pred_symbol + Group(
left_parenthesis + delimitedList(term) + right_parenthesis)) | Group(
not_ + pred_symbol +
Group(left_parenthesis + delimitedList(term) + right_parenthesis)))
formula = Forward()
forall_expression = Group(forall + delimitedList(symbol) + colon + formula)
exists_expression = Group(exists + delimitedList(symbol) + colon + formula)
operand = forall_expression | exists_expression | literal
formula << operatorPrecedence(operand, [(not_, 1, opAssoc.RIGHT),
(and_, 2, opAssoc.LEFT),
(or_, 2, opAssoc.LEFT),
(equiv_, 2, opAssoc.RIGHT),
(implies, 2, opAssoc.RIGHT)])
result = formula.parseString(text, parseAll=True)
return result.asList()[0]
import sys
from pyparsing import Word, alphas, alphanums, Optional, Group, delimitedList, quotedString, OneOrMore, dblQuotedString, removeQuotes
task = Word("task")
more = Word("-")
single = dblQuotedString.setParseAction(removeQuotes) | Word(alphanums)
tag = Word("#@!" + alphanums)
terms = OneOrMore(single | tag | task | more)
class Parser:
@staticmethod
def parse(string):
parts = []
try:
parts = terms.parseString(string)
except:
pass
return parts
def translate_cadp(cex, info):
def pprint_init_agent(args):
tid, iface = args[1], args[2][1:]
agent = pprint_agent(info, tid)
init = "".join(f"{agent}:\t{info.pprint_assign('I', int(k), v)}\n"
for k, v in enumerate(iface))
if len(args) == 4:
return init
lstig = args[3][1:]
init += "".join(
f"{agent}:\t{info.pprint_assign('L', int(k), v[1])},{v[2]}\n"
for k, v in enumerate(lstig))
return init
def pprint_init_env(args):
return "".join(f"\t{info.pprint_assign('E', int(k), v)}\n"
for k, v in enumerate(args[1:]))
lines = cex.split('\n')
first_line = next(i + 1 for i, l in enumerate(lines)
if "<initial state>" in l)
last_line = next(i for i, l in enumerate(lines[first_line:], first_line)
if "<goal state>" in l or "<deadlock>" in l)
lines = [
l[1:-1] for l in lines[first_line:last_line] if l and l[0] == '"'
] # noqa: E501, E741
ParserElement.setDefaultWhitespaceChars(' \t\n\x01\x02')
BOOLEAN = (Keyword("TRUE").setParseAction(replaceWith(True))
| Keyword("FALSE").setParseAction(replaceWith(False)))
NAME = Word(alphanums)
LPAR, RPAR = map(Suppress, "()")
RECORD = Forward()
OBJ = (ppc.number() | BOOLEAN | Group(RECORD))
RECORD <<= (NAME + LPAR + delimitedList(OBJ) + RPAR)
QUOTES = dblQuotedString.setParseAction(removeQuotes)
ASGN = NAME + ZeroOrMore(Suppress("!") + OBJ)
MONITOR = (Keyword("MONITOR") + Suppress("!") + (BOOLEAN | QUOTES))
STEP = ppc.number() | ASGN | MONITOR
yield "<initialization>\n"
for l in lines: # noqa: E741
if "invisible transition" in l:
# skip internal moves
continue
elif "<deadlock>" in l:
yield l
continue
step = STEP.parseString(l, parseAll=True)
if step[0] == "ENDINIT":
yield "<end initialization>\n"
elif step[0] == "MONITOR" and step[1] == "deadlock":
yield "<deadlock>\n"
elif step[0] == "MONITOR":
yield f"""<property {"satisfied" if step[1] else "violated"}>\n"""
elif step[0] == "E":
agent = pprint_agent(info, step[1])
yield f"{step.asList()}"
yield f"{agent}:\t{info.pprint_assign(*step[:3])}\n"
elif step[0] == "ATTR":
agent = pprint_agent(info, step[1])
yield f"{agent}:\t{info.pprint_assign('I', *step[2:4])}\n"
elif step[0] == "L":
agent = pprint_agent(info, step[1])
if len(step) > 4:
# This was a stigmergic message sent from another agent
yield f"{agent}:\t{info.pprint_assign('L', *step[2:4])}\t(from {pprint_agent(info, step[4])})\n" # noqa: E501
else:
# This was an assignment from the agent itself
yield f"{agent}:\t{info.pprint_assign('L', *step[2:4])}\n"
else:
yield f"<could not parse: {step}>\n"
import sys
from pyparsing import Word, alphas, alphanums, Optional, Group, delimitedList, quotedString, OneOrMore, dblQuotedString, removeQuotes
task = Word("task")
more = Word("-")
single = dblQuotedString.setParseAction(removeQuotes) | Word(alphanums)
tag = Word("#@!" + alphanums)
terms = OneOrMore(single | tag | task | more)
class Parser:
@staticmethod
def parse(string):
parts = []
try:
parts = terms.parseString(string)
except:
pass
return parts
from pyparsing import alphanums
from pyparsing import OneOrMore
from pyparsing import StringEnd
from pyparsing import ZeroOrMore
from pyparsing import removeQuotes
from pyparsing import dblQuotedString
from pyparsing import CaselessLiteral
from django.db.models import Q
from zinnia.models import Entry
# Simple tokens
SIMPLE = Word(alphanums)
QUOTED = dblQuotedString.setParseAction(removeQuotes)
SINGLE = SIMPLE | QUOTED
SPECIAL = Combine(Word(alphas) + ":" + SINGLE | QUOTED)
# Recursive parenthetical groups
TERMS = Forward()
PARENTHETICAL = Suppress("(") + Group(TERMS) + Suppress(")")
# Negative terms
NEGATIVE = Combine("-" + (SPECIAL | SINGLE | PARENTHETICAL))
# Boolean operators
OPERATOR = CaselessLiteral("or") | CaselessLiteral("and")
# Bring it all together
TERM = SPECIAL | SINGLE | PARENTHETICAL | NEGATIVE
from pyparsing import (
alphas,
dblQuotedString,
delimitedList,
Group,
Literal,
nums,
Optional,
pythonStyleComment,
removeQuotes,
Word,
)
from ctx_parser.common.parse_actions import convert_to_int
from ctx_parser.common.terminal_symbols import quote
# Terminal symbols
minus = Literal("-")
# Nonterminal symbols
NAME = Word(alphas)
POSITIVE_NUMBER = Word(nums)
NUMBER = Group(Optional(minus) + POSITIVE_NUMBER)
STR_VALUE = delimitedList(dblQuotedString.setParseAction(removeQuotes))
INT_VALUE = quote + NUMBER + quote
INT_VALUE.setParseAction(convert_to_int)
UINT_VALUE = quote + POSITIVE_NUMBER + quote
COMMENT = pythonStyleComment.suppress()
return spec
# Numbers are converted to ints if possible.
cql_number = Combine(
Optional('-') + ('0' | Word(nonzero_nums, nums)) +
Optional('.' + Word(nums)) +
Optional(Word('eE', exact=1) +
Word(nums + '+-', nums))).setParseAction(convert_number)
# Dates are parsed as double-quoted ISO8601 strings and converted to datetime
# objects.
cql_date = Combine(dbl_quote.suppress() + Regex(ISO8601_REGEX) +
dbl_quote.suppress()).setParseAction(convert_date)
# All double-quoted strings that are not dates are returned with their quotes
# removed.
cql_string = dblQuotedString.setParseAction(removeQuotes)
# URLs
protocol = Literal('http')
domain = Combine(OneOrMore(CharsNotIn('/')))
path = Combine(slash + OneOrMore(CharsNotIn(',~?&')))
cql_url = Combine(protocol + '://' + domain + path)
# Number range.
# FIXME: char ranges are not supported yet
cql_number_range = Group(cql_number + '-' +
cql_number).setParseAction(convert_range)
cql_values = Group(
delimitedList(
cql_number_range('range') | cql_number('number') | cql_date('date')
def parse_javascript_vars(data):
'''Receives a string of JavaScript-like data and tries to parse it.
Returns a dict with each var.
Several assumptions are made:
- Only the assignment operator '=' is supported.
- The script is composed of one or more assignments, and nothing else.
- The "var " prefix before an assignment is optional.
- No variable is assigned more than once.
- Comments should be correctly ignored, as well as whitespace.
- Values can be numbers, strings, arrays or dictionaries.
- Arrays and dictionaries can only contain number and strings.
- Dictionary keys can be numbers, strings, or an identifier.
Sample input for this grammar:
var i = 0; // Optional var, optional semicolon.
j = 0x10 // 16
k = -010 // -8
f = 1.0
g = +.9 // Optional leading 0, optional signal.
s = 'single quoted'
t = "double quoted"
a = []
b = [0, 1, 'string', "double", 3.14]
c = {}
d = {
foo: 'without quotes',
'bar': "as a string",
3: 'as a number'
}
This code can parse cgi_adsl_info.cgi, but it can't parse cgi_atm_info.cgi.
'''
from pyparsing import Combine, Dict, Group, Keyword, LineEnd, OneOrMore, \
Optional, StringEnd, Suppress, White, Word, alphanums, alphas, \
cppStyleComment, dblQuotedString, dblSlashComment, delimitedList, \
hexnums, nums, removeQuotes, sglQuotedString
# AKA identifier.
varname = Word(alphas + '_$', alphanums + '_$')
# This Optional(Suppress(White)) is required to because of the firstOf
# operator when defining number.
number_signal = Optional(Word('-+', exact=1)) + Optional(Suppress(White()))
decimal_number = number_signal + Word('123456789', nums)
# Scientific notation is not supported.
float_number = number_signal + Optional(Word(nums)) + '.' + Word(nums)
# For convenience, zero is considered an octal number.
octal_number = number_signal + Word('0', '01234567')
hex_number = number_signal + '0x' + Word(hexnums)
number = Combine(float_number | decimal_number | hex_number | octal_number)
def convert_number(toks):
s = toks[0]
signal = s[0] if s[0] in '+-' else ''
number = s[1:] if signal else s
if '.' in s:
return float(s)
elif number.startswith('0x'):
return int(signal + number[2:], base=16)
elif number.startswith('0'):
return int(s, base=8)
else:
return int(s, base=10)
number.setParseAction(convert_number)
string = (dblQuotedString.setParseAction(removeQuotes)
| sglQuotedString.setParseAction(removeQuotes))
# Nested arrays/dicts are not supported.
array_list = Group(
Suppress('[') + Optional(delimitedList(number | string)) +
Suppress(']'))
array_associative = Group(
Dict(
Suppress('{') + Optional(
delimitedList(
Group((number | string | varname) + Suppress(':') +
(number | string)))) + Suppress('}')))
value = number | string | array_list | array_associative
assignment = Group(
Optional(Suppress(Keyword('var'))) + varname + Suppress('=') + value +
Suppress(';' | LineEnd()))
parser = Dict(OneOrMore(assignment)) + StringEnd()
parser.ignore(dblSlashComment)
parser.ignore(cppStyleComment)
tree = parser.parseString(data)
# Converting the pyparsing.ParseResults tree into a simple Python dict.
ret = {}
for var, subtree in tree.asDict().items():
if isinstance(subtree, pyparsing.ParseResults):
try:
# Using .asDict() converts all integer keys to strings.
# ret[var] = subtree.asDict()
# Using .asList() retains numbers as numbers.
ret[var] = dict(subtree.asList())
except TypeError:
ret[var] = subtree.asList()
else:
# Most likely already a number or string.
ret[var] = subtree
return ret
decimal = Regex(r'-?0|-?[0-9]\d*').setParseAction(lambda t: ('Int', int(t[0])))
hexadecimal = ("#x" + Word(hexnums))\
.setParseAction(lambda t: (['BitVec', ('Int', 4*len(t[1]))], int("".join(t[1:]),16)))
bytes = Word(printables)
raw = Group(decimal("len") + Suppress(":") + bytes).setParseAction(verifyLen)
token = Word(alphanums + "-./_:*+=")
base64_ = Group(
Optional(decimal | hexadecimal, default=None)("len") + VBAR +
OneOrMore(Word(alphanums +
"+/=")).setParseAction(lambda t: b64decode("".join(t))) +
VBAR).setParseAction(verifyLen)
qString = Group(
Optional(decimal, default=None)("len") +
dblQuotedString.setParseAction(lambda s: ('String', stripDoubleQuotes(s[0])
))).setParseAction(verifyLen)
simpleString = base64_ | raw | decimal | token | hexadecimal | qString
# extended definitions
real = Regex(r"[+-]?\d+\.\d*([eE][+-]?\d+)?").setParseAction(
lambda tokens: float(tokens[0]))
token = Word(alphanums + "-./_:*+=!<>").setParseAction(lambda t: ('Bool', 'true') if t[0] == 'true' else \
('Bool', 'false') if t[0] == 'false' else t)
simpleString = real | base64_ | raw | decimal | token | hexadecimal | qString
display = LBRK + simpleString + RBRK
string_ = Optional(display) + simpleString
sexp = Forward()
# A record
# http://www.zytrax.com/books/dns/ch8/a.html
recordA = (Suppress(Keyword('A')) +
ipAddress('address') +
optional_comment)
# CNAME record
# http://www.zytrax.com/books/dns/ch8/cname.html
recordCNAME = (Suppress(Keyword('CNAME')) +
dns_name('canonical_name') +
optional_comment)
# TXT record
# http://www.zytrax.com/books/dns/ch8/txt.html
txtRecord = ((Suppress(Literal('(')) +
OneOrMore(dblQuotedString.setParseAction(removeQuotes)) +
Suppress(Literal(')'))) ^
OneOrMore(dblQuotedString.setParseAction(removeQuotes)))
recordTXT = (Suppress(Keyword('TXT')) +
txtRecord('text') +
optional_comment)
# MX Record
# http://www.zytrax.com/books/dns/ch8/mx.html
recordMX = (Suppress(Keyword('MX')) +
number('preference') +
dns_name('mail_exchanger') +
optional_comment)
# RP Record
return spec
# Numbers are converted to ints if possible.
cql_number = Combine(Optional('-') + ('0' | Word(nonzero_nums, nums)) +
Optional('.' + Word(nums)) +
Optional(Word('eE', exact=1) + Word(nums + '+-', nums))
).setParseAction(convert_number)
# Dates are parsed as double-quoted ISO8601 strings and converted to datetime
# objects.
cql_date = Combine(dbl_quote.suppress() + Regex(ISO8601_REGEX) +
dbl_quote.suppress()
).setParseAction(convert_date)
# All double-quoted strings that are not dates are returned with their quotes
# removed.
cql_string = dblQuotedString.setParseAction(removeQuotes)
# URLs
protocol = Literal('http')
domain = Combine(OneOrMore(CharsNotIn('/')))
path = Combine(slash + OneOrMore(CharsNotIn(',~?&')))
cql_url = Combine(protocol + '://' + domain + path)
# Number range.
# FIXME: char ranges are not supported yet
cql_number_range = Group(cql_number + '-' + cql_number
).setParseAction(convert_range)
cql_values = Group(
delimitedList(
cql_number_range('range') |
