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([])
