This repo contains code to mirror other repos. It also contains the code that is getting mirrored.
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
Erez Shinan d46318c725 Merge branch 'pr_accept' (Containing #129 with corrections) 6 years ago
docs README even better? 7 years ago
examples Standalone generator working again. Updated examples 6 years ago
lark Corrections to PR and added get_context 6 years ago
tests Fixed bug in Earley prioritization 6 years ago
.gitmodules Switch nearley submodule to original repo 7 years ago
.travis.yml Python 3.2 and 3.3 are End of Life 6 years ago
LICENSE Changed to the MIT license 7 years ago
MANIFEST.in Version 0.5.0 is out with lots of improvements 6 years ago
README.md Update README.md 6 years ago
nearley-requirements.txt Style fixes 7 years ago
setup.cfg Include LICENSE, docs, examples, tests, in tar.gz. 7 years ago
setup.py Updated setup.py. How long has it been saying 'Alpha'? Hmm.. 6 years ago

README.md

Lark - a modern parsing library for Python

Parse any context-free grammar, FAST and EASY!

Beginners: Lark is not just another parser. It can parse any grammar you throw at it, no matter how complicated or ambiguous, and do so efficiently. It also constructs a parse-tree for you, without additional code on your part.

Experts: Lark lets you choose between Earley and LALR(1), to trade-off power and speed. It also contains a CYK parser and experimental features such as a contextual-lexer.

Lark can:

  • Parse all context-free grammars, and handle all ambiguity
  • Build a parse-tree automagically, no construction code required
  • Outperform all other Python libraries when using LALR(1) (Yes, including PLY)
  • Run on every Python interpreter (it’s pure-python)
  • Generate a stand-alone parser (for LALR(1) grammars)

And many more features. Read ahead and find out.

Most importantly, Lark will save you time and prevent you from getting parsing headaches.

Install Lark

$ pip install lark-parser

Lark has no dependencies.

Build Status

Hello World

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.

Fruit flies like bananas

Lark is very good at handling ambiguity. Here’s how it parses the phrase “fruit flies like bananas”:

fruitflies.png

See more examples in the wiki

List of main features

  • Builds a parse-tree (AST) automagically, based on the structure of the grammar
  • Earley parser
    • Can parse all context-free grammars
    • Full support for ambiguous grammars
  • LALR(1) parser
    • Fast and light, competitive with PLY
    • Can generate a stand-alone parser
  • CYK parser, for highly ambiguous grammars (NEW! Courtesy of ehudt)
  • EBNF grammar
  • Unicode fully supported
  • Python 2 & 3 compatible
  • Automatic line & column tracking
  • Standard library of terminals (strings, numbers, names, etc.)
  • Import grammars from Nearley.js
  • Extensive test suite codecov
  • And much more!

See the full list of features in the wiki

Comparison to other libraries

Performance comparison

Lark is the fastest and lightest (lower is better)

Run-time Comparison

Memory Usage Comparison

Check out the JSON tutorial for more details on how the comparison was made.

Note: I really wanted to add PLY to the benchmark, but I couldn’t find a working JSON parser anywhere written in PLY. If anyone can point me to one that actually works, I would be happy to add it!

Feature comparison

Library Algorithm Grammar Builds tree? Supports ambiguity? Can handle every CFG? Line/Column tracking Generates Stand-alone
Lark Earley/LALR(1) EBNF Yes! Yes! Yes! Yes! Yes! (LALR only)
PLY LALR(1) BNF No No No No No
PyParsing PEG Combinators No No No* No No
Parsley PEG EBNF No No No* No No
funcparserlib Recursive-Descent Combinators No No No No No
Parsimonious PEG EBNF Yes No No* No No

(* PEGs cannot handle non-deterministic grammars. Also, according to Wikipedia, it remains unanswered whether PEGs can really parse all deterministic CFGs)

Projects using Lark

  • mappyfile - a MapFile parser for working with MapServer configuration
  • pytreeview - a lightweight tree-based grammar explorer

Using Lark? Send me a message and I’ll add your project!

How to use Nearley grammars in Lark

Lark comes with a tool to convert grammars from Nearley, a popular Earley library for Javascript. It uses Js2Py to convert and run the Javascript postprocessing code segments.

Here’s an example:

git clone https://github.com/Hardmath123/nearley
python -m lark.tools.nearley nearley/examples/calculator/arithmetic.ne main nearley > ncalc.py

You can use the output as a regular python module:

>>> import ncalc
>>> ncalc.parse('sin(pi/4) ^ e')
0.38981434460254655

License

Lark uses the MIT license.

Contribute

Lark is currently accepting pull-requests.

There are many ways you can help the project:

  • Improve the documentation
  • Write new grammars for Lark’s library
  • Write a blog post introducing Lark to your audience
  • Port Lark to another language
  • Help me with code developemnt

If you’re interested in taking one of these on, let me know and I will provide more details and assist you in the process.

Contact

If you have any questions or want my assistance, you can email me at erezshin at gmail com.

I’m also available for contract work.