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"
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') |