dv-flow-mgr 0.0.1.12992722023a1__tar.gz → 0.0.1.13468776985a1__tar.gz

{dv_flow_mgr-0.0.1.12992722023a1 → dv_flow_mgr-0.0.1.13468776985a1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: dv-flow-mgr
-Version: 0.0.1.12992722023a1
+Version: 0.0.1.13468776985a1
 Summary: DV Flow Manager is a build system for silicon design
 Author-email: Matthew Ballance <matt.ballance@gmail.com>
 License:                                  Apache License

dv_flow_mgr-0.0.1.13468776985a1/docs/KeyArchitecture.md

@@ -0,0 +1,65 @@
+
+# Tasks
+- A task has 0..N dependencies (references to tasks whose output
+  data must be available prior to execution of the task)
+- The input data available to a task includes
+  - Output data from its dependencies
+  - Memento data from its prior execution (a memento is a record of task execution)
+    - Makes sense to include markers here
+  - Locally-specified data (ie task parameters)
+- The core implementation of a task is invoked with a
+  consolidated set of data that is specified in the task definition.
+  - Example: select all FileSet that have kind systemVerilog, verilog, or VHDL 
+- The output of a task is comprised of (think of this as a filter?)
+  - Output data from its dependencies
+  - Memento data from the implementation, including marker information
+
+# Types
+- Types are named structures
+
+# Task Parameters
+- A task may have parameters. Parameters are singletons, and are
+  not extensible from outside. 
+- If a task needs to accept outside input, it must select that
+  by type from input parameter sets
+- Direct parameters
+- Task parameters are exposed to task implementation via a type with the task name
+- Do we really need this?
+- Using explicit types results in one extra layer of indirection
+- Still may have to deal with ambiguity...
+
+- name: RunSim
+  uses: SimRun
+  with:
+  - name: simargs
+    type: 
+      list:
+        item: SimArgs
+    value: ${{ jq in.[]}}
+  - uses: SimArgs
+    with:
+    - append-list
+
+So... Tasks do not have parameters. 
+- Tasks can inject parameter sets into the input set
+- Tasks can control what emerges from the task
+
+plusargs: .[] select(uses==SimArgs) | 
+
+# Cross-Task Dataflow
+- Cross-task dataflow is comprised of a collection of typed objects
+  containing typed fields.
+- Augmenting data is done by injecting new object instances into
+  the dataset. For example:
+  - The dataset contains an object for specifying simulation runtime
+    arguments. It contains a directive to append "+UVM_TEST=my_test" 
+    to the arguments
+  - I add a new runtime-arguments object that contains a directive
+    to append "+debug" to the arguments
+  - The consumer will see [+UVM_TEST=my_test +debug]
+
+
+# Data-Combination Rules
+- In most cases, data must be flattened in order to use it. For example,
+  
+- 

{dv_flow_mgr-0.0.1.12992722023a1 → dv_flow_mgr-0.0.1.13468776985a1}/docs/Roadmap.md

@@ -123,4 +123,9 @@ are evaluated.
 - Dependency strategy for Exec/Make
   - Specify dependency file created by task
   - When the timestamp is updated, task is known to have been rebuilt
-- 
+- 
+
+- Allow each task to emit a series of markers as part of the result
+  - Enables users to easily click on first N warnings/errors in each step
+    without needing to find and open a logfile
+- Allow files to be attached as part of the result

dv_flow_mgr-0.0.1.13468776985a1/docs/RundirLayout.md

@@ -0,0 +1,9 @@
+
+rundir/
+  - info/
+    - task-execution database
+    - execution logs
+  - tasks/
+    - per-task execution directory
+    - only for tasks that require persistent outputs
+

dv_flow_mgr-0.0.1.13468776985a1/docs/Steps.md

@@ -0,0 +1,68 @@
+
+# Tasks and Types
+- Load type definitions from YAML
+- Load task definitions from YAML
+
+# Data Selection and Extraction
+- Sort and select data
+- Need to support expressions
+- 
+
+# Task Implementation Source/Result Data
+
+Source Data
+- Task parameters
+- Upstream-change indication
+- Memento
+
+Result Data
+- List of output parameter sets
+- Change indication
+- Memento
+
+# Data Combination
+-
+
+# Day in the Life
+- Task Runner receives outputs from dependent tasks
+- ORs input changed' input flags to determine 'changed' flag to pass to task
+- Task Runner orders parameters using dependency information
+- Task Runner evaluates task-parameter creation code. Uses input data in this process
+  - Creates object of appropriate type
+  - Evalutes base-up to assign and augment parameter values
+- Retrieves memento (if available)
+- Passes accumulated data to task
+  - changed
+  - parameters
+  - 
+- Receives output from task
+  - list of parameter sets
+  - changed
+  - memento
+  - list of markers
+  - exit status (?)
+- Saves memento and markers for later inspection (central dir?)
+- Sets 'self' as source of parameter sets
+- Forms output data from
+  - changed
+  - list of parameter sets
+
+# Creating Task Parameters
+- 
+
+# Need execution support for tasks
+- Create parameters given the current inputs
+  - Need to follow inheritance
+  - Last (bottom-up) "value" wins
+  - Appends act bottom-up
+
+- Task holds handles to input data from dependencies
+  - 
+  - Make Task as simple as possible: scheduling item and place to store data
+
+- Something needs to prepare inputs (likely runner)
+  - Locate 
+- Something needs to process result
+  - Save memento in central store (map of task-execution records)
+    - Organize with start/finish times, etc
+- 

dv_flow_mgr-0.0.1.13468776985a1/docs/Usecases.md

@@ -0,0 +1,49 @@
+
+# Simple Initial Project Setup
+
+
+# Reconfigure Project Build
+
+# Global Configuration Data
+Some configuration data is global in nature -- in other words,
+it is relevant to multiple tools. Debug is one example. Enabling
+a debug flow impacts multiple simulation tools, and may impact
+how user-specified input behaves as well (eg adding +UVM_VERBOSITY)
+
+# Configure Package Usage
+I have a package that depends on UVM, as well as other packages (UVCs)
+that depend on UVM. By default, the UVM library is provided as a
+pre-compiled library (n simulators that support it). For "reasons",
+I want to switch to using the pure-source version. My choice must
+apply to all packages within my orbit -- in other words, having
+my package depend on source UVM while the UVC depends on pre-compiled
+will result in a conflict.
+
+# Configure Project Toolchain
+My package has external dependencies that may specify processing
+in addition to sources (eg the UVM library specifies how to 
+precompile it). I need a way to configure the toolchain that the
+external packages use the toolchain defined by my package.
+
+# Inline Specification of Inputs
+The simulation tool receives its inputs and controls via task data.
+This provides flexibility, by allowing multiple tasks to contribute 
+command-line arguments. While I could create a new task to output
+data that would add a command-line argument, I'd prefer to have
+a more-direct way to do so -- a sort of inline injection of task
+data that is combined with the task data of dependencies prior to
+being presented to the implementation.
+
+
+# Static Composition of Task Graphs (Introspection?)
+I have a collection of test definitions. I want to take a selection
+of them, connect my preferred simulation image, and run them.
+
+
+# Static Composition of Task Graphs (Introspection)
+I have collections of test definitions. I want to select tests that
+have a specific attribute / tag value, connect my preferred
+simulation image, and run them.
+
+
+

{dv_flow_mgr-0.0.1.12992722023a1 → dv_flow_mgr-0.0.1.13468776985a1}/ivpm.yaml

@@ -25,5 +25,9 @@ package:
       src: pypi
     - name: sphinxcontrib-mermaid
       src: pypi
+    - name: jq
+      src: pypi
+    - name: ply
+      src: pypi
 
 

{dv_flow_mgr-0.0.1.12992722023a1 → dv_flow_mgr-0.0.1.13468776985a1}/pyproject.toml

@@ -5,7 +5,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "dv-flow-mgr"
-version = "0.0.1.12992722023a1"
+version = "0.0.1.13468776985a1"
 dependencies = [
     'pydantic',
     'pyyaml',

dv_flow_mgr-0.0.1.13468776985a1/src/dv_flow/mgr/expr_eval.py

@@ -0,0 +1,50 @@
+
+import dataclasses as dc
+from typing import Any, Callable, Dict, List
+from .expr_parser import ExprVisitor, Expr, ExprBin, ExprBinOp, ExprCall, ExprId, ExprString, ExprInt
+
+@dc.dataclass
+class ExprEval(ExprVisitor):
+    methods : Dict[str, Callable] = dc.field(default_factory=dict)
+    variables : Dict[str, object] = dc.field(default_factory=dict)
+    value : Any = None
+
+    def eval(self, e : Expr):
+        self.value = None
+        e.accept(self)
+        return self.value
+
+    def visitExprId(self, e : ExprId):
+        if e.id in self.variables:
+            self.value = self.variables[e.id]
+        else:
+            raise Exception("Variable %s not found" % e.id)
+
+    def visitExprString(self, e : ExprString):
+        self.value = e.value
+    
+    def visitExprBin(self, e):
+        e.lhs.accept(self)
+
+        if e.op == ExprBinOp.Pipe:
+            # Value just goes over to the rhs
+            e.rhs.accept(self)
+        elif e.op == ExprBinOp.Plus:
+            pass
+    
+    def visitExprCall(self, e : ExprCall):
+        if e.id in self.methods:
+            # Need to gather up argument values
+            in_value = self.value
+            args = []
+            for arg in e.args:
+                self.value = None
+                arg.accept(self)
+                args.append(self.value)
+
+            self.value = self.methods[e.id](in_value, args)
+        else:
+            raise Exception("Method %s not found" % e.id)
+        
+    def visitExprInt(self, e : ExprInt):
+        self.value = e.value

dv_flow_mgr-0.0.1.13468776985a1/src/dv_flow/mgr/expr_parser.py

@@ -0,0 +1,233 @@
+import dataclasses as dc
+import enum
+import ply.lex as lex
+import ply.yacc as yacc
+from typing import ClassVar, List
+
+@dc.dataclass
+class Expr(object):
+    def accept(self, v):
+        raise NotImplementedError("Expr.accept for %s" % str(type(sepf)))
+
+@dc.dataclass
+class ExprId(Expr):
+    id : str
+
+    def accept(self, v):
+        v.visitExprId(self)
+
+class ExprBinOp(enum.Enum):
+    Pipe = enum.auto()
+    Plus = enum.auto()
+    Minus = enum.auto()
+    Times = enum.auto()
+    Divide = enum.auto()
+
+@dc.dataclass
+class ExprBin(Expr):
+    op : ExprBinOp
+    lhs : Expr
+    rhs : Expr
+
+    def accept(self, v):
+        v.visitExprBin(self)
+
+@dc.dataclass
+class ExprCall(Expr):
+    id : str
+    args : List[Expr]
+
+    def accept(self, v):
+        v.visitExprCall(self)
+
+@dc.dataclass
+class ExprString(Expr):
+    value : str
+
+    def accept(self, v):
+        v.visitExprString(self)
+
+@dc.dataclass
+class ExprInt(Expr):
+    value : int
+
+    def accept(self, v):
+        v.visitExprInt(self)
+
+class ExprVisitor(object):
+    def visitExprId(self, e : ExprId):
+        pass
+
+    def visitExprBin(self, e : ExprBin):
+        e.lhs.accept(self)
+        e.rhs.accept(self)
+
+    def visitExprCall(self, e : ExprCall):
+        for arg in e.args:
+            arg.accept(self)
+
+    def visitExprString(self, e : ExprString):
+        pass
+
+    def visitExprInt(self, e : ExprInt):
+        pass
+
+@dc.dataclass
+class ExprVisitor2String(ExprVisitor):
+    _ret : str = ""
+    _idx : int = 0
+
+    @staticmethod
+    def toString(e : Expr):
+        v = ExprVisitor2String()
+        e.accept(v)
+        return v._ret
+
+    def visitExprId(self, e : ExprId):
+        self._ret += e.id
+    
+    def visitExprBin(self, e):
+        e.lhs.accept(self)
+        self._ret += " "
+        self._ret += "op%d" % self._idx
+        self._idx += 1
+        self._ret += " "
+        e.rhs.accept(self)
+
+    def visitExprCall(self, e):
+        self._ret += e.id
+        self._ret += "("
+        for i, arg in enumerate(e.args):
+            if i > 0:
+                self._ret += ", "
+            arg.accept(self)
+        self._ret += ")"
+    
+    def visitExprString(self, e):
+        self._ret += e.value
+
+    def visitExprInt(self, e):
+        self._ret += str(e.value)
+
+
+class ExprParser(object):
+
+    _inst : ClassVar['ExprParser'] = None
+
+    def __init__(self):
+
+        # Build the lexer
+        self.lexer = lex.lex(module=self)
+        self.parser = yacc.yacc(module=self)
+
+    @classmethod
+    def inst(cls):
+        if cls._inst is None:
+            cls._inst = ExprParser()
+        return cls._inst
+
+    tokens = (
+        'ID','NUMBER','COMMA',
+        'PLUS','MINUS','TIMES','DIVIDE',
+        'LPAREN','RPAREN','PIPE','STRING1','STRING2'
+        )
+    
+    # Tokens
+
+    t_COMMA   = r',' 
+    t_PLUS    = r'\+'
+    t_MINUS   = r'-'
+    t_TIMES   = r'\*'
+    t_DIVIDE  = r'/'
+    t_LPAREN  = r'\('
+    t_RPAREN  = r'\)'
+    t_ID      = r'[a-zA-Z_][a-zA-Z0-9_]*'
+    t_PIPE    = r'\|'
+    t_STRING2 = r'\'.*\''
+    
+    def t_NUMBER(self, t):
+        r'\d+'
+        try:
+            t.value = ExprInt(int(t.value)) 
+        except ValueError:
+            print("Integer value too large %d", t.value)
+            t.value = ExprInt(0)
+        return t
+    
+    def t_STRING1(self, t):
+        r'(\'|\")([^\\\n]|(\\.))*?(\'|\")'
+        t.value = t.value[1:-1].replace('\\"', '"').replace("\\'", "'").replace('\\n', '\n').replace('\\t', '\t').replace('\\\\', '\\')
+        return t
+    
+    # Ignored characters
+    t_ignore = " \t"
+    
+    def t_newline(self, t):
+        r'\n+'
+        t.lexer.lineno += t.value.count("\n")
+        
+    def t_error(self, t):
+        print("Illegal character '%s'" % t.value[0])
+        t.lexer.skip(1)
+        
+    precedence = (
+        ('left','PLUS','MINUS','PIPE'),
+        ('left','TIMES','DIVIDE'),
+#        ('right','UMINUS'),
+        )
+    
+    def p_call(self, t):
+        """expression : ID LPAREN RPAREN 
+                      | ID LPAREN args RPAREN"""
+        t[0] = ExprCall(t[1], t[3] if len(t) == 5 else [])
+
+    def p_args(self, t):
+        """args : expression 
+                | args COMMA expression"""
+        if len(t) == 2:
+            t[0] = [t[1]]
+        else:
+            t[0] = t[1]
+            t[0].append(t[3])
+    
+    def p_expression_binop(self, t):
+        '''expression : expression PLUS expression
+                      | expression MINUS expression
+                      | expression TIMES expression
+                      | expression PIPE expression
+                      | expression DIVIDE expression'''
+        op_m = {
+            '+' : ExprBinOp.Plus,
+            '-' : ExprBinOp.Minus,
+            '*' : ExprBinOp.Times,
+            '|' : ExprBinOp.Pipe,
+            '/' : ExprBinOp.Divide
+        }
+        t[0] = ExprBin(op_m[t[2]], t[1], t[3])
+    
+    def p_expression_group(self, t):
+        'expression : LPAREN expression RPAREN'
+        t[0] = t[2]
+    
+    def p_expression_number(self, t):
+        'expression : NUMBER'
+        t[0] = t[1]
+    
+    def p_expression_name(self, t):
+        'expression : ID'
+        t[0] = ExprId(t[1])
+
+    def p_expression_string1(self, t):
+        'expression : STRING1'
+        t[0] = ExprString(t[1])
+
+    def p_expression_string2(self, t):
+        'expression : STRING2'
+        t[0] = ExprString(t[1])
+    
+    def p_error(self, t):
+        print("Syntax error at '%s'" % t.value)
+
+    def parse(self, input):
+        return self.parser.parse(input, lexer=self.lexer)
+    

{dv_flow_mgr-0.0.1.12992722023a1 → dv_flow_mgr-0.0.1.13468776985a1}/src/dv_flow/mgr/fragment_def.py

@@ -26,11 +26,13 @@ from typing import Any, Dict, List, Union
 from .package import Package
 from .package_import_spec import PackageImportSpec
 from .task_def import TaskDef
+from .type_def import TypeDef
 
 class FragmentDef(BaseModel):
     tasks : List[TaskDef] = dc.Field(default_factory=list)
     imports : List[Union[str,PackageImportSpec]] = dc.Field(default_factory=list, alias="imports")
     fragments: List[str] = dc.Field(default_factory=list)
+    types : List[TypeDef] = dc.Field(default_factory=list)
 
     basedir : str = None
 

dv_flow_mgr-0.0.1.13468776985a1/src/dv_flow/mgr/out

@@ -0,0 +1,12 @@
+	   __main__.py
+	    flow.py
+	   package.py
+	   package_def.py
+	   package_import_spec.py
+	    parameters.py
+	   pkg_rgy.py
+	   task.py
+	   task_graph_builder.py
+	   task_graph_runner.py
+	   util.py
+

{dv_flow_mgr-0.0.1.12992722023a1 → dv_flow_mgr-0.0.1.13468776985a1}/src/dv_flow/mgr/package.py

@@ -31,6 +31,7 @@ class Package(object):
     # Package holds constructors for tasks
     # - Dict holds the default parameters for the task
     tasks : Dict[str,TaskCtor] = dc.field(default_factory=dict)
+    types : Dict[str,Any] = dc.field(default_factory=dict)
     _log : ClassVar = logging.getLogger("Package")
 
     def getTaskCtor(self, name : str) -> TaskCtor:

{dv_flow_mgr-0.0.1.12992722023a1 → dv_flow_mgr-0.0.1.13468776985a1}/src/dv_flow/mgr/package_def.py

@@ -19,6 +19,7 @@
 #*     Author: 
 #*
 #****************************************************************************
+import io
 import os
 import json
 import yaml
@@ -35,6 +36,7 @@ from .package_import_spec import PackageImportSpec, PackageSpec
 from .task import TaskCtor, TaskCtorProxy, TaskCtorCls, TaskCtorParam, TaskCtorParamCls
 from .task_def import TaskDef, TaskSpec
 from .std.task_null import TaskNull
+from .type_def import TypeDef
 
 
 class PackageDef(BaseModel):
@@ -44,6 +46,7 @@ class PackageDef(BaseModel):
     tasks : List[TaskDef] = dc.Field(default_factory=list)
     imports : List[PackageImportSpec] = dc.Field(default_factory=list)
     fragments: List[str] = dc.Field(default_factory=list)
+    types : List[TypeDef] = dc.Field(default_factory=list)
 
     fragment_l : List['FragmentDef'] = dc.Field(default_factory=list, exclude=True)
 
@@ -314,6 +317,32 @@ class PackageDef(BaseModel):
         file_s.pop()
 
         return pkg
+
+    @staticmethod
+    def loads(data, exp_pkg_name=None):
+        return PackageDef._loadPkgDefS(data, exp_pkg_name)
+        pass
+
+    @staticmethod
+    def _loadPkgDefS(data, exp_pkg_name):
+        ret = None
+        doc = yaml.load(io.StringIO(data), Loader=yaml.FullLoader)
+        if "package" not in doc.keys():
+            raise Exception("Missing 'package' key in %s" % root)
+        pkg = PackageDef(**(doc["package"]))
+        pkg.basedir = None
+
+#            for t in pkg.tasks:
+#                t.basedir = os.path.dirname(root)
+
+        if exp_pkg_name is not None:
+            if exp_pkg_name != pkg.name:
+                raise Exception("Package name mismatch: %s != %s" % (exp_pkg_name, pkg.name))
+
+        if len(pkg.fragments) > 0:
+            raise Exception("Cannot load a package-def with fragments from a string")
+
+        return pkg
     
     @staticmethod
     def _loadFragmentSpec(pkg, spec, file_s):

dv_flow_mgr-0.0.1.13468776985a1/src/dv_flow/mgr/param_def.py

@@ -0,0 +1,25 @@
+
+from typing import Any, List, Union
+from pydantic import BaseModel, Field
+
+class ListType(BaseModel):
+    item : Union[str, 'ComplexType']
+
+class MapType(BaseModel):
+    key : Union[str, 'ComplexType']
+    item : Union[str, 'ComplexType']
+
+class ComplexType(BaseModel):
+    list : Union[ListType, None] = None
+    map : Union[MapType, None] = None
+
+class ParamDef(BaseModel):
+    name : str
+    doc : str = None
+    type : Union[str, 'ComplexType'] = None
+    value : Union[Any, None] = None
+    append : Union[Any, None] = None
+    prepend : Union[Any, None] = None
+    path_append : Union[Any, None] = Field(alias="path-append", default=None)
+    path_prepend : Union[Any, None] = Field(alias="path-prepend", default=None)
+

dv_flow_mgr-0.0.1.13468776985a1/src/dv_flow/mgr/parsetab.py

@@ -0,0 +1,44 @@
+
+# parsetab.py
+# This file is automatically generated. Do not edit.
+# pylint: disable=W,C,R
+_tabversion = '3.10'
+
+_lr_method = 'LALR'
+
+_lr_signature = 'leftPLUSMINUSPIPEleftTIMESDIVIDECOMMA DIVIDE ID LPAREN MINUS NUMBER PIPE PLUS RPAREN STRING1 STRING2 TIMESexpression : ID LPAREN RPAREN \n                      | ID LPAREN args RPARENargs : expression \n                | args COMMA expressionexpression : expression PLUS expression\n                      | expression MINUS expression\n                      | expression TIMES expression\n                      | expression PIPE expression\n                      | expression DIVIDE expressionexpression : LPAREN expression RPARENexpression : NUMBERexpression : IDexpression : STRING1expression : STRING2'
+    
+_lr_action_items = {'ID':([0,3,7,8,9,10,11,12,24,],[2,2,2,2,2,2,2,2,2,]),'LPAREN':([0,2,3,7,8,9,10,11,12,24,],[3,12,3,3,3,3,3,3,3,3,]),'NUMBER':([0,3,7,8,9,10,11,12,24,],[4,4,4,4,4,4,4,4,4,]),'STRING1':([0,3,7,8,9,10,11,12,24,],[5,5,5,5,5,5,5,5,5,]),'STRING2':([0,3,7,8,9,10,11,12,24,],[6,6,6,6,6,6,6,6,6,]),'$end':([1,2,4,5,6,14,15,16,17,18,19,22,23,],[0,-12,-11,-13,-14,-5,-6,-7,-8,-9,-1,-10,-2,]),'PLUS':([1,2,4,5,6,13,14,15,16,17,18,19,21,22,23,25,],[7,-12,-11,-13,-14,7,-5,-6,-7,-8,-9,-1,7,-10,-2,7,]),'MINUS':([1,2,4,5,6,13,14,15,16,17,18,19,21,22,23,25,],[8,-12,-11,-13,-14,8,-5,-6,-7,-8,-9,-1,8,-10,-2,8,]),'TIMES':([1,2,4,5,6,13,14,15,16,17,18,19,21,22,23,25,],[9,-12,-11,-13,-14,9,9,9,-7,9,-9,-1,9,-10,-2,9,]),'PIPE':([1,2,4,5,6,13,14,15,16,17,18,19,21,22,23,25,],[10,-12,-11,-13,-14,10,-5,-6,-7,-8,-9,-1,10,-10,-2,10,]),'DIVIDE':([1,2,4,5,6,13,14,15,16,17,18,19,21,22,23,25,],[11,-12,-11,-13,-14,11,11,11,-7,11,-9,-1,11,-10,-2,11,]),'RPAREN':([2,4,5,6,12,13,14,15,16,17,18,19,20,21,22,23,25,],[-12,-11,-13,-14,19,22,-5,-6,-7,-8,-9,-1,23,-3,-10,-2,-4,]),'COMMA':([2,4,5,6,14,15,16,17,18,19,20,21,22,23,25,],[-12,-11,-13,-14,-5,-6,-7,-8,-9,-1,24,-3,-10,-2,-4,]),}
+
+_lr_action = {}
+for _k, _v in _lr_action_items.items():
+   for _x,_y in zip(_v[0],_v[1]):
+      if not _x in _lr_action:  _lr_action[_x] = {}
+      _lr_action[_x][_k] = _y
+del _lr_action_items
+
+_lr_goto_items = {'expression':([0,3,7,8,9,10,11,12,24,],[1,13,14,15,16,17,18,21,25,]),'args':([12,],[20,]),}
+
+_lr_goto = {}
+for _k, _v in _lr_goto_items.items():
+   for _x, _y in zip(_v[0], _v[1]):
+       if not _x in _lr_goto: _lr_goto[_x] = {}
+       _lr_goto[_x][_k] = _y
+del _lr_goto_items
+_lr_productions = [
+  ("S' -> expression","S'",1,None,None,None),
+  ('expression -> ID LPAREN RPAREN','expression',3,'p_call','expr_parser.py',160),
+  ('expression -> ID LPAREN args RPAREN','expression',4,'p_call','expr_parser.py',161),
+  ('args -> expression','args',1,'p_args','expr_parser.py',165),
+  ('args -> args COMMA expression','args',3,'p_args','expr_parser.py',166),
+  ('expression -> expression PLUS expression','expression',3,'p_expression_binop','expr_parser.py',174),
+  ('expression -> expression MINUS expression','expression',3,'p_expression_binop','expr_parser.py',175),
+  ('expression -> expression TIMES expression','expression',3,'p_expression_binop','expr_parser.py',176),
+  ('expression -> expression PIPE expression','expression',3,'p_expression_binop','expr_parser.py',177),
+  ('expression -> expression DIVIDE expression','expression',3,'p_expression_binop','expr_parser.py',178),
+  ('expression -> LPAREN expression RPAREN','expression',3,'p_expression_group','expr_parser.py',189),
+  ('expression -> NUMBER','expression',1,'p_expression_number','expr_parser.py',193),
+  ('expression -> ID','expression',1,'p_expression_name','expr_parser.py',197),
+  ('expression -> STRING1','expression',1,'p_expression_string1','expr_parser.py',201),
+  ('expression -> STRING2','expression',1,'p_expression_string2','expr_parser.py',205),
+]