def pa(s, l, t): t = t[0] if len(t) > initlen: ret = pyp.ParseResults(t[:initlen]) i = initlen while i < len(t): ret = pyp.ParseResults([ret] + t[i:i + incr]) i += incr return pyp.ParseResults([ret])
def parse_guard(exp): post_guard = guardExp.parseString(exp)[0] while (len(post_guard) > 3): fusion = pp.ParseResults(post_guard[0:3]) post_guard = pp.ParseResults(post_guard[3:]) post_guard.insert(0, fusion) return post_guard
def _parse(mystr): LBRACE, RBRACE, EQUAL = map(pp.Suppress, "{}=") field = pp.Word(pp.printables + ' ', excludeChars='[]=') field.addParseAction(pp.tokenMap(str.rstrip)) string = pp.dblQuotedString().setParseAction(pp.removeQuotes) number = pp.pyparsing_common.number() date_expr = pp.Regex(r'\d\d\d\d-\d\d-\d\d') time_expr = pp.Regex(r'\d\d:\d\d:\d\d\.\d\d\d') scalar_value = (string | date_expr | time_expr | number) list_marker = pp.Suppress("[]") value_list = pp.Forward() jobject = pp.Forward() memberDef1 = pp.Group(field + EQUAL + scalar_value) memberDef2 = pp.Group(field + EQUAL + jobject) memberDef3 = pp.Group(field + list_marker + EQUAL + LBRACE + value_list + RBRACE) memberDef = memberDef1 | memberDef2 | memberDef3 value_list <<= (pp.delimitedList(scalar_value, ",") | pp.ZeroOrMore(pp.Group(pp.Dict(memberDef2)))) value_list.setParseAction(lambda t: [pp.ParseResults(t[:])]) members = pp.OneOrMore(memberDef) jobject <<= pp.Dict(LBRACE + pp.ZeroOrMore(memberDef) + RBRACE) # force empty jobject to be a dict jobject.setParseAction(lambda t: t or {}) parser = members parser = pp.OneOrMore(pp.Group(pp.Dict(memberDef))) return parser.parseString(mystr)
def ParseRecord(self, parser_mediator, key, structure): """Parses a structure of tokens derived from a line of a text file. Args: parser_mediator (ParserMediator): mediates interactions between parsers and other components, such as storage and dfvfs. key (str): name of the parsed structure. structure (pyparsing.ParseResults): structure of tokens derived from a line of a text file. Raises: ParseError: when the structure type is unknown. """ if key != 'line': raise errors.ParseError( 'Unable to parse record, unknown structure: {0:s}'.format(key)) msg_value = self._GetValueFromStructure(structure, 'msg') if not msg_value: parser_mediator.ProduceExtractionWarning( 'missing msg value: {0!s}'.format(structure)) return try: seconds = int(msg_value[0], 10) except ValueError: parser_mediator.ProduceExtractionWarning( 'unsupported number of seconds in msg value: {0!s}'.format( structure)) return try: milliseconds = int(msg_value[1], 10) except ValueError: parser_mediator.ProduceExtractionWarning( 'unsupported number of milliseconds in msg value: {0!s}'. format(structure)) return timestamp = ((seconds * 1000) + milliseconds) * 1000 body_text = structure[2][0] try: # Try to parse the body text as key value pairs. Note that not # all log lines will be properly formatted key value pairs. body_structure = self._SELINUX_KEY_VALUE_DICT.parseString( body_text) except pyparsing.ParseException: body_structure = pyparsing.ParseResults() event_data = SELinuxLogEventData() event_data.audit_type = self._GetValueFromStructure(structure, 'type') event_data.body = body_text event_data.pid = self._GetValueFromStructure(body_structure, 'pid') date_time = dfdatetime_posix_time.PosixTimeInMicroseconds( timestamp=timestamp) event = time_events.DateTimeValuesEvent( date_time, definitions.TIME_DESCRIPTION_WRITTEN) parser_mediator.ProduceEventWithEventData(event, event_data)
def action_DD(self, s, loc, toks): r"""Replace \DD expansion on-the-fly.""" a = [''] * 4 for n in range(1, 4): c = toks.P.get(f'#{n}') if c: a[n] = self.unparse(c.A) if a[1]: tmpl = r'\frac{{d^{1}{2}}}{{d {3}{{}}^{1}}}'.format(*a) else: tmpl = r'\frac{{d {2}}}{{d {3}}}'.format(*a) tmpl = pp.ParseResults(tmpl) toks.T = tmpl toks[:] = tmpl return (toks)
def action_DP(self, s, loc, toks): r"""Replace \DP expansion on-the-fly.""" a = [''] * 5 for n in range(1, 5): c = toks.P.get(f'#{n}') if c: a[n] = self.unparse(c.A) if a[2]: tmpl = (r'\left(\frac{{\partial^{1}{3}}}' + r'{{\partial {4}{{}}^{1}}}\right)_{2}').format(*a) elif a[1]: tmpl = (r'\frac{{\partial^{1}{3}}}' + r'{{\partial {4}{{}}^{1}}}').format(*a) else: tmpl = r'\frac{{\partial{3}}}{{\partial {4}}}'.format(*a) tmpl = pp.ParseResults(tmpl) toks.T = tmpl toks[:] = tmpl return (toks)
def cvt_to_function_call(tokens): ret = pp.ParseResults(['abs']) + tokens ret['fn_name'] = 'abs' ret['args'] = tokens return [ret]
def test_parse_expression(self): f = "test/gene-filter-example-3.xml" gemtractor = GEMtractor(f) expr = gemtractor._unfold_complex_expression( gemtractor._parse_expression("something")) self.assertEqual(len(expr), 1) self.assertEqual(len(expr[0].genes), 1) self.assertEqual(next(iter(expr[0].genes)).identifier, "something") expr = gemtractor._unfold_complex_expression( gemtractor._parse_expression( "a or ((b and c) or (d and e and f)) or (g and h) or (i or j)") ) self.assertEqual(len(expr), 6) self.assertEqual(len(expr[0].genes), 1) self.assertEqual(next(iter(expr[0].genes)).identifier, "a") self.assertEqual(len(expr[1].genes), 2) self.assertTrue(next(iter(expr[1].genes)).identifier, "b") self.assertTrue(next(iter(expr[1].genes)).identifier, "c") self.assertEqual(len(expr[2].genes), 3) self.assertTrue(next(iter(expr[2].genes)).identifier, "d") self.assertTrue(next(iter(expr[3].genes)).identifier, "e") self.assertTrue(next(iter(expr[3].genes)).identifier, "f") self.assertEqual(len(expr[3].genes), 2) self.assertTrue(next(iter(expr[3].genes)).identifier, "g") self.assertTrue(next(iter(expr[3].genes)).identifier, "h") self.assertEqual(len(expr[4].genes), 1) self.assertEqual(next(iter(expr[4].genes)).identifier, "i") self.assertEqual(len(expr[5].genes), 1) self.assertEqual(next(iter(expr[5].genes)).identifier, "j") expr = gemtractor._unfold_complex_expression( gemtractor._parse_expression("a or (b and c)")) self.assertEqual(len(expr), 2) self.assertEqual(len(expr[0].genes), 1) self.assertEqual(next(iter(expr[0].genes)).identifier, "a") self.assertEqual(len(expr[1].genes), 2) self.assertTrue(next(iter(expr[1].genes)).identifier, "b") self.assertTrue(next(iter(expr[1].genes)).identifier, "c") with self.assertRaises(InvalidGeneExpression): gemtractor._parse_expression("a or a (b and c)") with self.assertRaises(NotImplementedError): pr = pp.ParseResults() pr.append("a") pr.append("and") pr.append("b") pr.append("or") pr.append("c") gemtractor._unfold_complex_expression(pr) with self.assertRaises(NotImplementedError): pr = pp.ParseResults() pr.append("a") pr.append("b") gemtractor._unfold_complex_expression(pr)
import unittest import pyparsing from interface.advanced_search import ComparisonNode, search, AndNode, OrNode, get_query, TextNode import re # Search string --> [ expected parse tree, expected mongo query ] search_dict = { 'url = amazon': [ pyparsing.ParseResults([ComparisonNode(['url', '$regex', 'amazon'])]), { 'url': { '$regex': re.compile('amazon') } } ], 'url != amazon': [ pyparsing.ParseResults([ComparisonNode(['url', '$not', 'amazon'])]), { 'url': { '$not': re.compile('amazon') } } ], 'url == amazon': [ pyparsing.ParseResults([ComparisonNode(['url', '==', 'amazon'])]), { 'url': 'amazon' } ], 'url ~ ./amazon./:_-': [ pyparsing.ParseResults( [ComparisonNode(['url', '$regex', './amazon./: -'])]), { 'url': {
def parse(cls, value): return p.ParseResults([])