|
7 lat temu | |
---|---|---|
docs | 7 lat temu | |
examples | 7 lat temu | |
lark | 7 lat temu | |
tests | 7 lat temu | |
LICENSE | 7 lat temu | |
MANIFEST.in | 7 lat temu | |
README.md | 7 lat temu | |
setup.cfg | 7 lat temu | |
setup.py | 7 lat temu |
Lark is a modern general-purpose parsing library for Python.
It’s intended for everyone, from complete beginners to experts in parsing.
Lark focuses on simplicity, power, and speed. It lets you choose between two parsing algorithms:
Both algorithms are written in Python and can be used interchangeably with the same grammar*. Similarly, the lexer can be turned on/off without changing the grammar. That means you can write your parser without any limitations (just keep it context-free) and optimize it for speed only when you need to.
Lark can automagically build an AST from your grammar, without any more code on your part.
* Both the lexer and the LALR algorithm require certain limitations on the grammar. If you choose to use them, it’s better to learn what they are first.
Here is a little program to parse “Hello, World!” (Or any other similar phrase):
from lark import Lark
l = Lark('''start: WORD "," WORD "!"
%import common.WORD
%ignore " "
''')
print( l.parse("Hello, World!") )
And the output is:
Tree(start, [Token(WORD, 'Hello'), Token(WORD, 'World')])
Notice punctuation doesn’t appear in the resulting tree. It’s automatically filtered away by Lark.
from lark import Lark, InlineTransformer
parser = Lark('''?sum: product
| sum "+" product -> add
| sum "-" product -> sub
?product: item
| product "*" item -> mul
| product "/" item -> div
?item: NUMBER -> number
| "-" item -> neg
| "(" sum ")"
%import common.NUMBER
%import common.WS
%ignore WS
''', start='sum')
class CalculateTree(InlineTransformer):
from operator import add, sub, mul, truediv as div, neg
number = float
def calc(expr):
return CalculateTree().transform( parser.parse(expr) )
In the grammar, we shape the resulting tree. The ‘->’ operator renames branches, and the ‘?’ prefix tells Lark to inline single values. (see the tutorial for a more in-depth explanation)
Then, the transformer calculates the tree and returns a number:
>>> calc("(200 + 3*-3) * 7")
1337.0
$ pip install lark-parser
Lark has no dependencies.
These features are planned to be implemented in the near future:
These features may be implemented some day:
Separates code from grammar: Parsers written this way are cleaner and easier to read & work with.
Automatically builds a parse tree (AST): Trees are always simpler to work with than state-machines. (But if you want to provide a callback for efficiency reasons, Lark lets you do that too)
Follows Python’s Idioms: Beautiful is better than ugly. Readability counts.
Code | CPython Time | PyPy Time | CPython Mem | PyPy Mem |
---|---|---|---|---|
Lark - LALR(1) | 4.7s | 1.2s | 70M | 134M |
PyParsing | 32s | 3.5s | 443M | 225M |
funcparserlib | 8.5s | 1.3s | 483M | 293M |
Parsimonious | 5.7s | 1545M |
Check out the JSON tutorial for more details on how the comparison was made.
Library | Algorithm | LOC | Grammar | Builds tree? |
---|---|---|---|---|
Lark | Earley/LALR(1) | 0.5K | EBNF+ | Yes! |
PLY | LALR(1) | 4.6K | Yacc-like BNF | No |
PyParsing | PEG | 5.7K | Parser combinators | No |
Parsley | PEG | 3.3K | EBNF-like | No |
funcparserlib | Recursive-Descent | 0.5K | Parser combinators | No |
Parsimonious | PEG | ? | EBNF | Yes |
(LOC measures lines of code of the parsing algorithm(s), without accompanying files)
It’s hard to compare parsers with different parsing algorithms, since each algorithm has many advantages and disadvantages. However, I will try to summarize the main points here:
Lark offers both Earley and LALR(1), which means you can choose between the most powerful and the most efficient algorithms, without having to change libraries.
(* According to Wikipedia, it remains unanswered whether PEGs can really parse all deterministic CFGs)
Lark uses the MIT license.
If you have any questions or want to contribute, you can email me at erezshin at gmail com.