Pyparsing setParseAction function is getting no arguments

Question

I'm trying to parse a simple key = value query language. I've actually accomplished it with a huge monstrosity parser that I then make a second pass through to clean up the parse tree. What I'd like to do is make a clean parse from the bottom up, which includes things like using sets for the (key,val) pairs so redundant pairs are eliminated etc. While I got it working before, I don't feel like I fully understood why pyparsing was acting the way it was, so I did a lot of work arounds etc, sort of fighting against the grain. Currently, here is the beginning of my "simplified" parser: ``` from pyparsing import * bool_act = lambda t: bool(t[0]) int_act = lambda t: int(t[0]) def keyval_act(instring, loc, tokens): return set([(tokens.k, tokens.v)]) def keyin_act(instring, loc, tokens): return set([(tokens.k, set(tokens.vs))]) string = ( Word(alphas + '_', alphanums + '_') | quotedString.setParseAction( removeQuotes ) ) boolean = ( CaselessLiteral('true') | CaselessLiteral('false') ) integer…

Accepted Answer

Well, the latest version of `setParseAction` does do some extra magic, but unfortunately at the expense of some development simplicity. The argument detection logic in setParseAction now relies on the raising of exceptions in the parse action until it is called with the correct number of arguments, starting at 3 and working its way down to 0, after which it just gives up and raises the exception you saw.

Except in this case, the exception coming from the parse action was not due to an argument list mismatch, but be a real error in your code. To get a better view at this, insert a generic try-except into your parse action:

```
def keyin_act(instring, loc, tokens): 
    try:
        return set([(tokens.k, set(tokens.vs[0]))]) 
    except Exception as e:
        print e
```

And you get:

```
unhashable type: 'set'
```

In fact, the second element of your list from which you are creating the return set is itself a set, a mutable container, thus not hashable for inclusion in a set. If you change this to use a frozenset instead, then you'll get:

```
[set([('hi', frozenset([]))])]
```

Why is the frozenset empty? I suggest you change the location of your results name 'vs' to:

```
nestedExpr('{','}', content = delimitedList(value))('vs') 
```

And now the parsed results returned by parsing 'hi in {1,2,3}' are:

```
[set([('hi', frozenset([([1, 2, 3], {})]))])]
```

This is something of a mess, if we drop this line at the top of your parse action, you'll see what the different named results actually contain:

```
print tokens.dump()
```

We get:

```
['hi', [1, 2, 3]]
- k: hi
- vs: [[1, 2, 3]]
```

So 'vs' actually points to a list containing a list. So we probably want to build our set from `tokens.vs[0]`, not `tokens.vs`. Now our parsed results look like:

```
[set([('hi', frozenset([1, 2, 3]))])]
```

Some other tips on your grammar:

Instead of CaselessLiteral, try using CaselessKeyword. Keywords are better choice for grammar keywords, since they inherently avoid mistaking the leading 'in' of 'inside' as the keyword 'in' in your grammar.

Not sure where you are heading with returning sets from the parse actions - for key-value pairs, a tuple will probably be better, since it will preserve the order of tokens. Build up your sets of keys and values in the after-parsing phase of the program.

For other grammar debugging tools, check out `setDebug` and the `traceParseAction` decorator.

Pyparsing setParseAction function is getting no arguments

Solution

Problem