Parsimonious

Warnings

• breaking Parsimonious is pre-1.0, and API changes have occurred in previous versions (e.g., 0.5). While 0.11.0 doesn't have explicitly documented breaking changes from 0.10.x, it's generally advised to pin exact versions to avoid unexpected behavior changes in future minor releases.
  Fix: Always pin your `parsimonious` dependency to a specific version (e.g., `parsimonious==0.11.0`) to ensure stability. Consult the GitHub changelog for specific migration details between versions.
• gotcha The library's internal regex handling uses the `regex` library (not Python's built-in `re`) and employs a specific `~"regex"` syntax. The author has also indicated a potential future deprecation of explicit regexes in favor of dynamically built primitives.
  Fix: Adhere strictly to Parsimonious's regex syntax (`~"pattern"`). Be aware that future versions might change how regexes are defined or preferred. For complex character classes, explicit regexes are currently efficient.
• gotcha Parsimonious is a 'Collection parser' rather than a 'stream parser'. This means it loads the entire input (e.g., a string or file content) into memory before parsing. For extremely large inputs, this can lead to high memory consumption.
  Fix: For very large files or data streams, consider pre-processing to break them into smaller, manageable chunks, or evaluate if a stream-based parsing library is more suitable for your specific use case. Parsimonious is best suited for inputs that fit comfortably in memory.
• gotcha While direct manipulation of `Node` objects is possible, the recommended and most robust way to process the Abstract Syntax Tree (AST) after parsing is to create a subclass of `NodeVisitor`.
  Fix: For any non-trivial processing of the parse tree, implement a `NodeVisitor` subclass. This provides an organized, maintainable, and less error-prone way to traverse and transform the tree.

Install

• pip install parsimonious Install stable version

Imports

• Grammar

  from parsimonious.grammar import Grammar

• NodeVisitor

  from parsimonious.nodes import NodeVisitor

  Used for structured traversal and transformation of the parse tree.

Quickstart

This quickstart demonstrates how to define a simple arithmetic grammar, parse an input string, and then process the resulting parse tree using a `NodeVisitor` to evaluate the expression. This pattern of grammar definition followed by a visitor for tree manipulation is central to using Parsimonious effectively.

from parsimonious.grammar import Grammar
from parsimonious.nodes import NodeVisitor

# 1. Define your grammar
grammar = Grammar(
    """
    expression = term (("+" / "-") term)*
    term       = factor (("*" / "/") factor)*
    factor     = "(" expression ")" / number
    number     = ~"[0-9]+"
    """
)

# 2. Parse an input string
input_string = "(10 + 20) * 3"
try:
    tree = grammar.parse(input_string)
    print(f"Successfully parsed: {input_string}")
    # print(tree.prettily())

    # 3. (Optional) Process the parse tree using a NodeVisitor
    class CalculatorVisitor(NodeVisitor):
        def visit_number(self, node, visited_children):
            return int(node.text)

        def visit_factor(self, node, visited_children):
            if len(visited_children) == 3: # ( expression )
                _, expr, _ = visited_children
                return expr
            return visited_children[0] # number

        def visit_term(self, node, visited_children):
            result = visited_children[0]
            for i in range(1, len(visited_children), 2):
                op = visited_children[i][0].text # Access the operator node's text
                num = visited_children[i+1]
                if op == '*':
                    result *= num
                elif op == '/':
                    result /= num
            return result

        def visit_expression(self, node, visited_children):
            result = visited_children[0]
            for i in range(1, len(visited_children), 2):
                op = visited_children[i][0].text # Access the operator node's text
                num = visited_children[i+1]
                if op == '+':
                    result += num
                elif op == '-':
                    result -= num
            return result

        def generic_visit(self, node, visited_children):
            return visited_children or node

    calculator = CalculatorVisitor()
    result = calculator.visit(tree)
    print(f"Result: {result}")

except Exception as e:
    print(f"Error parsing: {e}")