pyparsing a string with operator precedence - pyparsing

Question

I would like to use pyparsing module for parsing expressions such as:
carbo * or oxy * or nitro *
Once parsed, those expressions should be transformed to:
carbo(universe).select([*]) | oxy(universe).select([*]) | nitro(universe).select([*])
for a further eval.
I built a grammar that works only for the first or found in the string but not for the subsequent ones. Here is my grammar:
from pyparsing import *
def parse_keyword(token):
return '"%s"(universe).select' % token[0]
def parse_arguments(token):
return "(%s)" % str(token)
def operator_and(token):
token[0][1] = "&"
return " ".join(token[0])
def operator_or(token):
token[0][1] = "|"
return " ".join(token[0])
def parse_expression(self, token):
return "".join([str(t) for t in token])
expression = 'carbo * or oxy * or nitro *'
linkers = oneOf(["and","or",], caseless=True)
keyword = oneOf(['carbo','oxy','nitro'], caseless=True).setParseAction(parse_keyword)
arguments = Optional(~linkers + delimitedList(Word(printables,excludeChars=","),combine=False)).setParseAction(parse_arguments)
selector = OneOrMore((keyword+arguments))
grammar = Forward()
grammar << selector.setParseAction(parse_expression)
grammar = operatorPrecedence(grammar, [(oneOf(["and"],caseless=True), 2, opAssoc.LEFT , operator_and),
(oneOf(["or"] ,caseless=True), 2, opAssoc.LEFT , operator_or)],
lpar="(",
rpar=")")
parsedExpression = grammar.transformString(expression)
print parsedExpression
would you have any idea about what is wrong with it ?
thanks
Eric

Answer 1

The problem with the grammar was the use of LEFT association instead of RIGHT in the operator precedence definition.
Here is the final grammar that does the job:
from pyparsing import *
def parse_keyword(token):
return '"%s"(universe).select' % token[0]
def parse_arguments(token):
return "(%s)" % str(token)
def operator_and(token):
token[0][1] = "&"
return " ".join(token[0])
def operator_or(token):
token[0][1] = "|"
return " ".join(token[0])
def parse_expression(self, token):
return "".join([str(t) for t in token])
expression = 'carbo * or oxy * or nitro *'
linkers = oneOf(["and","or",], caseless=True)
keyword = oneOf(['carbo','oxy','nitro'], caseless=True).setParseAction(parse_keyword)
arguments = Optional(~linkers + delimitedList(Word(printables,excludeChars=","),combine=False)).setParseAction(parse_arguments)
selector = OneOrMore((keyword+arguments))
grammar = Forward()
grammar << selector.setParseAction(parse_expression)
grammar = operatorPrecedence(grammar, [(oneOf(["and"],caseless=True), 2, opAssoc.RIGHT , operator_and),
(oneOf(["or"] ,caseless=True), 2, opAssoc.RIGHT , operator_or)],
lpar="(",
rpar=")")
parsedExpression = grammar.transformString(expression)
The difference is subtle (and still a bit unclear for me) but it works.
Eric