def add_conj(word_type_list):
new_list = []
for type in word_type_list:
new_list.append(type)
new_type = Literal('و') + type
new_type.setName('C_' + type.name)
new_list.append(new_type)
return (new_list)
quotedArg = (dblQuotedString | sglQuotedString)
quotedArg.setParseAction(removeQuotes)
quotedArg.setName("quotedArg")
plainArgChars = printables.replace('#', '').replace('"', '').replace("'", "")
plainArg = Word(plainArgChars)
plainArg.setName("plainArg")
arguments = Group(ZeroOrMore(quotedArg | plainArg))
arguments = arguments.setResultsName('arguments')
arguments.setName("arguments")
# comment line.
comment = Literal('#') + restOfLine
comment = comment.suppress()
comment.setName('comment')
full_command = (comment | (command + arguments + Optional(comment)))
full_command.setName('full_command')
###
command_list = [] # filled in by namespaces.init_global_dict().
# command/argument handling.
def process_args(args, globals_dict, locals_dict):
"""
Take a list of string arguments parsed via pyparsing and evaluate
the special variables ('__*').
def get_parsing_expr():
expr = Literal('[') + sts_type + "," + sts_type + Literal(']')
expr.setName('Interval')
return True, expr
quotedArg = ( dblQuotedString | sglQuotedString )
quotedArg.setParseAction(removeQuotes)
quotedArg.setName("quotedArg")
plainArgChars = printables.replace('#', '').replace('"', '').replace("'", "")
plainArg = Word(plainArgChars)
plainArg.setName("plainArg")
arguments = Group(ZeroOrMore(quotedArg | plainArg))
arguments = arguments.setResultsName('arguments')
arguments.setName("arguments")
# comment line.
comment = Literal('#') + restOfLine
comment = comment.suppress()
comment.setName('comment')
full_command = (
comment
| (command + arguments + Optional(comment))
)
full_command.setName('full_command')
###
command_list = [] # filled in by namespaces.init_global_dict().
### command/argument handling.
def process_args(args, globals_dict, locals_dict):
"""
def operator():
token = Literal("+") | Literal("-") | Literal("/") | Literal("*")
token.setName("operator")
return token
class Parser:
"""
Parse a dbus signature using pyparsing.
"""
# pylint: disable=too-many-instance-attributes
# pylint: disable=too-few-public-methods
# pylint: disable=invalid-name
def __init__(self):
"""
Initializer.
Instantiates the entire parser.
All productions are public instance attributes.
"""
self.BYTE = Literal("y")("BYTE")
self.BOOLEAN = Literal("b")("BOOLEAN")
self.INT16 = Literal("n")("INT16")
self.UINT16 = Literal("q")("UINT16")
self.INT32 = Literal("i")("INT32")
self.UINT32 = Literal("u")("UINT32")
self.INT64 = Literal("x")("INT64")
self.UINT64 = Literal("t")("UINT64")
self.DOUBLE = Literal("d")("DOUBLE")
self.UNIX_FD = Literal("h")("UNIX_FD")
self.STRING = Literal("s")("STRING")
self.OBJECT_PATH = Literal("o")("OBJECT_PATH")
self.SIGNATURE = Literal("g")("SIGNATURE")
self.VARIANT = Literal("v")("VARIANT")
self.CODE = (
self.BYTE
^ self.BOOLEAN
^ self.DOUBLE
^ self.INT16
^ self.UINT16
^ self.INT32
^ self.UINT32
^ self.INT64
^ self.UINT64
^ self.UNIX_FD
^ self.STRING
^ self.OBJECT_PATH
^ self.SIGNATURE
^ self.VARIANT
)
self.COMPLETE = Forward()
self.DICT_ENTRY = (
Literal("{") + self.CODE + Forward(self.COMPLETE) + Literal("}")
)
self.DICT_ENTRY.setName("DICT_ENTRY")
self.ARRAY = Literal("a") + (Forward(self.COMPLETE) ^ self.DICT_ENTRY)
self.ARRAY.setName("ARRAY")
self.STRUCT = Literal("(") + OneOrMore(Forward(self.COMPLETE)) + Literal(")")
self.STRUCT.setName("STRUCT")
self.COMPLETE <<= self.CODE ^ self.ARRAY ^ self.STRUCT
self.PARSER = ZeroOrMore(self.COMPLETE)
def __init__(self):
self.stack = []
self.dice_roles = []
self.binary_ops = {
'+': operator.add,
'-': operator.sub,
'*': operator.mul,
'/': operator.truediv,
'^': operator.pow,
'>': operator.gt,
'>=': operator.ge,
'<': operator.lt,
'<=': operator.le,
'!=': operator.ne,
'==': operator.eq,
'or': operator.or_,
'and': operator.and_
}
self.constants = {'PI': math.pi, 'E': math.e}
self.functions = {
'sum': lambda *a: sum(a),
'sin': math.sin,
'cos': math.cos,
'tan': math.tan,
'exp': math.exp,
'hypot': math.hypot,
'abs': abs,
'trunc': int,
'round': round,
'sgn': lambda a: -1 if a < -math.e else 1 if a > math.e else 0,
'multiply': lambda a, b: a * b,
'all': lambda *a: all(a),
'any': lambda *a: any(a)
}
# lang vars
e = CaselessKeyword("E")
pi = CaselessKeyword("PI")
number = Regex(r"[+-]?\d+(?:\.\d*)?(?:[eE][+-]?\d+)?")
number.setName('Number')
ident = Word(alphas, alphanums + "_$")
ident.setName('Ident')
dice = Regex(r'\d?[dD]\d+')
dice.setName('Dice')
plus, minus, lt, le, gt, ge, eq, ne, or_, and_ = map(
Literal, ['+', '-', '<', '<=', '>', '>=', '==', '!=', 'or', 'and'])
bi_op = plus | minus | lt | le | gt | ge | eq | ne | or_ | and_
bi_op.setName('LowBinaryOp')
mult = Literal('*')
div = Literal('/')
multop = mult | div
multop.setName('MediumBinaryOp')
expop = Literal('^')
expop.setName('HighBinaryOp')
lpar = Suppress('(')
rpar = Suppress(')')
factor = Forward()
expr = Forward()
expr_list = delimitedList(Group(expr))
expr_list.setName('ExpressionList')
def dice_role(s: str) -> int:
rolls = DiceRolls(roll=s, results=[])
s = s.lower()
if s.startswith('d'):
count = 1
limit = s[1:]
else:
count, limit = s.lower().split('d')
count = int(count)
limit = int(limit)
for _ in range(0, count):
roll = random.randint(1, limit)
rolls.results.append(roll)
self.dice_roles.append(rolls)
return rolls.sum
def insert_fn_arg_count_tuple(t: Tuple) -> None:
fn = t.pop(0)
argc = len(t[0])
t.insert(0, (fn, argc))
def push(tokens) -> None:
self.stack.append(tokens[0])
def push_unary_minus(tokens) -> None:
if '-' in tokens:
push('unary -')
def push_dice(t: ParseResults) -> None:
self.stack.append(functools.partial(dice_role, t[0]))
dice.setParseAction(push_dice)
fn_call = ((ident + lpar - Group(expr_list) +
rpar).setParseAction(insert_fn_arg_count_tuple))
atom = dice | (bi_op[...] + (
((fn_call | pi | e | number | ident).setParseAction(push))
| Group(lpar + expr + rpar)).setParseAction(push_unary_minus))
factor <<= atom + (expop + factor).setParseAction(push)[...]
term = factor + (multop + factor).setParseAction(push)[...]
expr <<= term + (bi_op + term).setParseAction(push)[...]
self.expr = expr
expr.setName('Expression')
factor.setName('Factor')
atom.setName('Atom')
term.setName('Term')
class Parser(object):
"""
Parse a dbus signature using pyparsing.
"""
# pylint: disable=too-many-instance-attributes
# pylint: disable=too-few-public-methods
def __init__(self):
"""
Initializer.
Instantiates the entire parser.
All productions are public instance attributes.
"""
self.BYTE = Literal('y')('BYTE')
self.BOOLEAN = Literal('b')('BOOLEAN')
self.INT16 = Literal('n')('INT16')
self.UINT16 = Literal('q')('UINT16')
self.INT32 = Literal('i')('INT32')
self.UINT32 = Literal('u')('UINT32')
self.INT64 = Literal('x')('INT64')
self.UINT64 = Literal('t')('UINT64')
self.DOUBLE = Literal('d')('DOUBLE')
self.UNIX_FD = Literal('h')('UNIX_FD')
self.STRING = Literal('s')('STRING')
self.OBJECT_PATH = Literal('o')('OBJECT_PATH')
self.SIGNATURE = Literal('g')('SIGNATURE')
self.VARIANT = Literal('v')('VARIANT')
self.CODE = \
self.BYTE ^ \
self.BOOLEAN ^ \
self.DOUBLE ^ \
self.INT16 ^ \
self.UINT16 ^ \
self.INT32 ^ \
self.UINT32 ^ \
self.INT64 ^ \
self.UINT64 ^ \
self.UNIX_FD ^ \
self.STRING ^ \
self.OBJECT_PATH ^ \
self.SIGNATURE ^ \
self.VARIANT
self.COMPLETE = Forward()
self.DICT_ENTRY = \
Literal('{') + \
self.CODE + \
Forward(self.COMPLETE) + \
Literal('}')
self.DICT_ENTRY.setName('DICT_ENTRY')
self.ARRAY = Literal('a') + (Forward(self.COMPLETE) ^ self.DICT_ENTRY)
self.ARRAY.setName('ARRAY')
self.STRUCT = \
Literal('(') + OneOrMore(Forward(self.COMPLETE)) + Literal(')')
self.STRUCT.setName('STRUCT')
self.COMPLETE <<= self.CODE ^ self.ARRAY ^ self.STRUCT
self.PARSER = ZeroOrMore(self.COMPLETE)
C = oneOf(conjunctions)("stem")
C.setName('C')
PREP = oneOf(prepositions)("stem")
PREP.setName('PREP')
# Particles
GEN = oneOf(genitive)("stem")
GEN_PRO = oneOf(genitive)("stem") + oneOf(poss_suffixes)
GEN_PRO.setName('GEN_PRO')
# انني --> ان + ني
PART_PRO = Literal('ان')("stem") + oneOf(dir_obj_suffixes)
PART_PRO.setName('PART_PRO')
# Nouns
# كتابها --> كتاب + ها
N_PRO = SkipTo(N_SUFF)("stem") + N_SUFF("suffix")
N_PRO.setName('N_PRO')
# لكتابها --> ل + كتاب + ها
PREP_N_PRO = oneOf(prepositions)("prefix") + SkipTo(N_SUFF)("stem") + N_SUFF(
"suffix")
PREP_N_PRO.setName('PREP_N_PRO')
# الكتاب --> ال + كتاب
DET_N = oneOf(def_art)("prefix") + SkipTo(endOfString)("stem")
DET_N.setName('DET_N')
def model_grammar():
"""
Construct a parser for winBugs/openBugs/JAGS models.
Returns *parser*, which is a *pyaparsing.ParserElement, with the
*parser.parserString()* method.
Be sure to strip comments from the string prior to parsing, so that the
grammar can be a little simpler.
"""
###factor = Forward().setName('factor') # for right-to-left parsing
expression = Forward().setName('expr')
group = Forward().setName('group')
# start:stop used for indexing and for loops
inner_range = Optional (expression + Optional(Literal(":") + expression))
paren_range = Literal("(").suppress() + inner_range + Literal(")").suppress()
slice = inner_range | paren_range
paren_range.setName('(slice)')
inner_range.setName('slice').setParseAction(
lambda s,l,t: [(SLICE,(NONE,),(NONE,)) if len(t)==0 else (SLICE,t[0],t[2]) if len(t)>1 else t[0]])
# indexing
subscripts = slice + ZeroOrMore(Literal(',').suppress() + slice)
index = Literal('[').suppress() + subscripts + Literal(']').suppress()
indexed_variable = variable + Optional(index)
subscripts.setName('subs')
index.setName('index')
indexed_variable.setName('deref').setParseAction(
lambda s,l,t: [(DEREF,t[0],t[1:])])
# arithmetic
muldiv = Literal('*') | Literal('/')
addsub = Literal('+') | Literal('-')
###exponent = Literal('^')
pars = expression + ZeroOrMore(Literal(',').suppress() + expression)
function = variable + Literal('(') + Optional(pars) + Literal(')')
paren = Literal('(') + expression + Literal(')')
value = constant + Empty()
atom = Optional("-") + (function | indexed_variable | value | paren )
###factor << (atom | ZeroOrMore (exponent + factor))
###term = factor + ZeroOrMore(muldiv + factor)
term = atom + ZeroOrMore(muldiv + atom)
expression << (term + ZeroOrMore(addsub + term))
paren.setName('paren').setParseAction(
lambda s,l,t: [t[1]])
value.setName('value').setParseAction(
lambda s,l,t: [(CONST, t[0])])
function.setName('apply').setParseAction(
lambda s,l,t: [(APPLY, t[0], t[2:-1])])
atom.setName('atom').setParseAction(
lambda s,l,t: [(UNARY, t[0], t[1]) if len(t)>1 else t[0]])
###factor.setName('factor').setParseAction(lambda s,l,t: [_binop(t)])
term.setName('term').setParseAction(
lambda s,l,t: [_binop(t)])
expression.setName('expr').setParseAction(
lambda s,l,t: [_binop(t)])
# priors look like dname(p1,p2,...) with optional qualifier T(left,right)
# to set the bounds on the prior. Since left/right are optional, the
# function parser can't be used, and we need a special bounds term to
# parse this form.
bounds_limit = expression | Empty()
bounds_function = (variable + Literal('(') + bounds_limit
+ Literal(',') + bounds_limit + Literal(')'))
bounds = bounds_function | Empty()
bounds_limit.setName('limit').setParseAction(
lambda s,l,t: [(t[0] if len(t) else (NONE,))])
bounds.setName('trunc').setParseAction(
lambda s,l,t: [(APPLY,t[0],[t[2],t[4]]) if len(t) else (NONE,)])
# Funky assignment lhs functions, such as:
# logit(t) <- alpha; D(C[5],t) <- PER1 * C[7] - R*kT1*C[1]
lhs_function = variable + Literal('(') + indexed_variable \
+ ZeroOrMore(Literal(',') + indexed_variable) + Literal(')')
lhs_function.setName('f(lhs)').setParseAction(
lambda s,l,t: [(APPLY, t[0], t[2::2])])
# statements
assignment = (lhs_function | indexed_variable) + Literal("<-") + expression
prior = indexed_variable + Literal("~") + function + bounds
loop = (Keyword("for") + Literal("(") + variable + Keyword("in")
+ expression + Literal(":") + expression + Literal(")") + group)
assignment.setName('assign').setParseAction(
lambda s,l,t: [(ASSIGN, t[0], t[2])])
prior.setName('prior').setParseAction(
lambda s,l,t: [(PRIOR, t[0], t[2], t[3])])
loop.setName('loop').setParseAction(
lambda s,l,t: [(LOOP, t[2], t[4], t[6], t[8:])])
# Note: line breaks are ignored. That means the following are valid:
# statement\n
# statement;\n
# statement; statement\n
# statement statement\n
# partial statement\n statement completion
# Indeed, all of these forms exist in the openBugs example models.
#comment = Literal("#[^\n]*")
statement = (loop | assignment | prior) + Optional(Literal(';')).suppress()
body = ZeroOrMore(statement)
group << (Literal("{").suppress() + body + Literal("}").suppress())
model = Keyword("model") + group + StringEnd()
model.setName('model').setParseAction(
lambda s,l,t: [(MODEL, t[1:])])
if 0: # Debug
all_terms = (
model, group, body, statement, loop, prior, assignment,
expression, term, atom, muldiv, addsub,
value, constant, paren, function, pars,
indexed_variable, variable, index, subscripts,
slice, inner_range, paren_range,
)
for s in all_terms: s.setDebug(True)
return model
def operator():
token = Literal("+") | Literal("-") | Literal("/") | Literal("*")
token.setName("operator")
token.setResultsName("operator")
return token
