pyparsing nestedExpr和嵌套括号

Question

我正在研究一种非常简单的“查询语法”，供具有适当技术技能的人员使用（即，本身不是编码人员，但可以触及该主题）

他们将在表格上输入的典型示例是：

address like street
AND
vote =  True
AND
(
  (
    age>=25
    AND
    gender = M
  )
  OR
  (
    age between [20,30]
    AND
    gender = F
  )
  OR
  (
    age >= 70
    AND
    eyes != blue
  )
)

用

1. 无需报价
2. 括号的潜在无限嵌套
3. 简单的AND | OR链接

我正在使用pyparsing（好吧，无论如何尝试）并达到以下目标：

from pyparsing import *

OPERATORS = [
    '<',
    '<=',
    '>',
    '>=',
    '=',
    '!=',
    'like'
    'regexp',
    'between'
]

unicode_printables = u''.join(unichr(c) for c in xrange(65536)
                              if not unichr(c).isspace())

# user_input is the text sent by the client form
user_input = ' '.join(user_input.split())
user_input = '(' + user_input + ')'

AND = Keyword("AND").setName('AND')
OR = Keyword("OR").setName('OR')

FIELD = Word(alphanums).setName('FIELD')
OPERATOR = oneOf(OPERATORS).setName('OPERATOR')
VALUE = Word(unicode_printables).setName('VALUE')
CRITERION = FIELD + OPERATOR + VALUE

QUERY = Forward()
NESTED_PARENTHESES = nestedExpr('(', ')')
QUERY << ( CRITERION | AND | OR | NESTED_PARENTHESES )

RESULT = QUERY.parseString(user_input)
RESULT.pprint()

输出为：

[['address',
  'like',
  'street',
  'AND',
  'vote',
  '=',
  'True',
  'AND',
  [['age>=25', 'AND', 'gender', '=', 'M'],
   'OR',
   ['age', 'between', '[20,30]', 'AND', 'gender', '=', 'F'],
   'OR',
   ['age', '>=', '70', 'AND', 'eyes', '!=', 'blue']]]]

我只对其中的一部分感到满意​​-主要原因是所需的最终输出看起来像这样：

[
  {
    "field" : "address",
    "operator" : "like",
    "value" : "street",
  },
  'AND',
  {
    "field" : "vote",
    "operator" : "=",
    "value" : True,
  },
  'AND',
  [
    [
      {
        "field" : "age",
        "operator" : ">=",
        "value" : 25,
      },
      'AND'
      {
        "field" : "gender",
        "operator" : "=",
        "value" : "M",
      }
    ],
    'OR',
    [
      {
        "field" : "age",
        "operator" : "between",
        "value" : [20,30],
      },
      'AND'
      {
        "field" : "gender",
        "operator" : "=",
        "value" : "F",
      }
    ],
    'OR',
    [
      {
        "field" : "age",
        "operator" : ">=",
        "value" : 70,
      },
      'AND'
      {
        "field" : "eyes",
        "operator" : "!=",
        "value" : "blue",
      }
    ],
  ]
]

非常感谢！

编辑

在Paul回答之后，这就是代码的样子。显然，它工作得更好：-)

unicode_printables = u''.join(unichr(c) for c in xrange(65536)
                              if not unichr(c).isspace())

user_input = ' '.join(user_input.split())

AND = oneOf(['AND', '&'])
OR = oneOf(['OR', '|'])
FIELD = Word(alphanums)
OPERATOR = oneOf(OPERATORS)
VALUE = Word(unicode_printables)
COMPARISON = FIELD + OPERATOR + VALUE

QUERY = infixNotation(
    COMPARISON,
    [
        (AND, 2, opAssoc.LEFT,),
        (OR, 2, opAssoc.LEFT,),
    ]
)

class ComparisonExpr:
    def __init__(self, tokens):
        self.tokens = tokens

    def __str__(self):
        return "Comparison:('field': {!r}, 'operator': {!r}, 'value': {!r})".format(*self.tokens.asList())

COMPARISON.addParseAction(ComparisonExpr)

RESULT = QUERY.parseString(user_input).asList()
print type(RESULT)
from pprint import pprint
pprint(RESULT)

输出为：

[
  [
    <[snip]ComparisonExpr instance at 0x043D0918>,
    'AND',
    <[snip]ComparisonExpr instance at 0x043D0F08>,
    'AND',
    [
      [
        <[snip]ComparisonExpr instance at 0x043D3878>,
        'AND',
        <[snip]ComparisonExpr instance at 0x043D3170>
      ],
      'OR',
      [
        [
          <[snip]ComparisonExpr instance at 0x043D3030>,
          'AND',
          <[snip]ComparisonExpr instance at 0x043D3620>
        ],
        'AND',
        [
          <[snip]ComparisonExpr instance at 0x043D3210>,
          'AND',
          <[snip]ComparisonExpr instance at 0x043D34E0>
        ]
      ]
    ]
  ]
]

有没有办法用字典而不是ComparisonExpr实例返回RESULT ？

编辑2

提出了一个幼稚且非常具体的解决方案，但到目前为止对我仍然有效：

[snip]
class ComparisonExpr:
    def __init__(self, tokens):
        self.tokens = tokens

    def __str__(self):
        return "Comparison:('field': {!r}, 'operator': {!r}, 'value': {!r})".format(*self.tokens.asList())

    def asDict(self):
        return {
            "field": self.tokens.asList()[0],
            "operator": self.tokens.asList()[1],
            "value": self.tokens.asList()[2]
        }

[snip]
RESULT = QUERY.parseString(user_input).asList()[0]
def convert(list):
    final = []
    for item in list:
        if item.__class__.__name__ == 'ComparisonExpr':
            final.append(item.asDict())
        elif item in ['AND', 'OR']:
            final.append(item)
        elif item.__class__.__name__ == 'list':
            final.append(convert(item))
        else:
            print 'ooops forgotten something maybe?'

    return final

FINAL = convert(RESULT)
pprint(FINAL)

哪个输出：

[{'field': 'address', 'operator': 'LIKE', 'value': 'street'},
   'AND',
   {'field': 'vote', 'operator': '=', 'value': 'true'},
   'AND',
   [[{'field': 'age', 'operator': '>=', 'value': '25'},
     'AND',
     {'field': 'gender', 'operator': '=', 'value': 'M'}],
    'OR',
    [[{'field': 'age', 'operator': 'BETWEEN', 'value': '[20,30]'},
      'AND',
      {'field': 'gender', 'operator': '=', 'value': 'F'}],
     'AND',
     [{'field': 'age', 'operator': '>=', 'value': '70'},
      'AND',
      {'field': 'eyes', 'operator': '!=', 'value': 'blue'}]]]]

再次感谢保罗为我指出正确的方向！

唯一未知的左边是为我转'true'成True和'[20,30]'成[20, 30]。

Answer 1

nestedExpr是 pyparsing 中的一个方便表达式，可以轻松定义具有匹配开始和结束字符的文本。当你想解析嵌套的内容时，nestedExpr通常结构不够好。

使用 pyparsing 的infixNotation方法可以更好地提供您尝试解析的查询语法。您可以在 pyparsing wiki 的示例页面上看到几个示例 - SimpleBool 与您正在解析的内容非常相似。

“中缀表示法”是运算符位于其相关操作数之间的表达式的通用解析术语（相对于运算符跟在操作数之后的“后缀表示法”，如“2 3 +”而不是“2 + 3”；或“前缀符号”看起来像“+ 2 3”）。运算符在求值中可以有一个优先顺序，可以覆盖从左到右的顺序——例如，在“2 + 3 * 4”中，运算的优先级规定乘法在加法之前被计算。中缀表示法还支持使用括号或其他分组字符来覆盖该优先级，如在 "(2 + 3) * 4" 中强制首先完成加法运算。

pyparsing 的infixNotation方法接受一个基本操作数表达式，然后是一个运算符定义元组列表，按优先顺序排列。例如，4 函数整数运算看起来像：

parser = infixNotation(integer,
             [
             (oneOf('* /'), 2, opAssoc.LEFT),
             (oneOf('+ -'), 2, opAssoc.LEFT),
             ])

这意味着我们将按照“*”和“/”二元左关联运算以及“+”和“-”二元运算的顺序解析整数操作数。支持括号覆盖顺序内置于infixNotation.

查询字符串通常是布尔运算 NOT、AND 和 OR 的某种组合，并且通常按该优先顺序进行评估。在您的情况下，这些运算符的操作数是比较表达式，例如“address = street”或“age between [20,30]”。因此，如果您为比较表达式定义一个表达式，形式为fieldname operator value，那么您可以使用infixNotation对 AND 和 OR 进行正确分组：

import pyparsing as pp
query_expr = pp.infixNotation(comparison_expr,
                [
                    (NOT, 1, pp.opAssoc.RIGHT,),
                    (AND, 2, pp.opAssoc.LEFT,),
                    (OR, 2, pp.opAssoc.LEFT,),
                ])

最后，我建议您定义一个类来将比较标记作为类 init args，然后您可以将行为附加到该类以评估比较并输出调试字符串，例如：

class ComparisonExpr:
    def __init__(self, tokens):
        self.tokens = tokens

    def __str__(self):
        return "Comparison:('field': {!r}, 'operator': {!r}, 'value': {!r})".format(
                            *self.tokens.asList())

# attach the class to the comparison expression
comparison_expr.addParseAction(ComparisonExpr)

然后你可以得到如下输出：

query_expr.parseString(sample).pprint()

[[Comparison:({'field': 'address', 'operator': 'like', 'value': 'street'}),
  'AND',
  Comparison:({'field': 'vote', 'operator': '=', 'value': True}),
  'AND',
  [[Comparison:({'field': 'age', 'operator': '>=', 'value': 25}),
    'AND',
    Comparison:({'field': 'gender', 'operator': '=', 'value': 'M'})],
   'OR',
   [Comparison:({'field': 'age', 'operator': 'between', 'value': [20, 30]}),
    'AND',
    Comparison:({'field': 'gender', 'operator': '=', 'value': 'F'})],
   'OR',
   [Comparison:({'field': 'age', 'operator': '>=', 'value': 70}),
    'AND',
    Comparison:({'field': 'eyes', 'operator': '!=', 'value': 'blue'})]]]]

SimpleBool.py 示例有更多详细信息向您展示如何创建此类以及 NOT、AND 和 OR 运算符的相关类。

编辑：

“有没有办法用字典而不是ComparisonExpr 实例返回结果？” 正在调用__repr__您ComparisonExpr类上的方法而不是__str__. 最简单的解决方案是添加到您的类中：

__repr__ = __str__

或者只是重命名__str__为__repr__.

“对我来说唯一未知的就是将 'true' 变为 True，将 '[20,30]' 变为 [20, 30]”

尝试：

CK = CaselessKeyword  # 'cause I'm lazy
bool_literal = (CK('true') | CK('false')).setParseAction(lambda t: t[0] == 'true')
LBRACK,RBRACK = map(Suppress, "[]")
# parse numbers using pyparsing_common.number, which includes the str->int conversion parse action
num_list = Group(LBRACK + delimitedList(pyparsing_common.number) + RBRACK)

然后将这些添加到您的 VALUE 表达式中：

VALUE = bool_literal | num_list | Word(unicode_printables)

最后：

from pprint import pprint
pprint(RESULT)

我得到这么累进口的pprint所有的时间来做到这这，我只是把它添加到了API ParseResults。尝试：

RESULT.pprint()  # no import required on your part

或者

print(RESULT.dump()) # will also show indented list of named fields

编辑2

最后，结果名称很好学。如果您对 COMPARISON 进行此更改，则一切仍然如您所愿：

COMPARISON = FIELD('field') + OPERATOR('operator') + VALUE('value')

但现在你可以写：

def asDict(self):
    return self.tokens.asDict()

并且您可以按名称而不是索引位置（使用result['field']符号或result.field符号）访问解析的值。