npm - dal-ast-js - Versions diffs - 0.0.1-dev - Mend

dal-ast-js 0.0.1-dev

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (35) hide show

package/LICENSE +201 -0
package/README.md +26 -0
package/dist/index.cjs +696 -0
package/dist/index.esm.js +694 -0
package/docs/notes.md +36 -0
package/package.json +28 -0
package/rollup.config.js +18 -0
package/src/ArgsParser.js +152 -0
package/src/DalAstGenerator.js +35 -0
package/src/DesignValidator.js +37 -0
package/src/KEYWORDS.js +11 -0
package/src/Lexer.js +174 -0
package/src/Parser.js +281 -0
package/src/TOKENS.js +13 -0
package/src/Untokenizer.js +34 -0
package/src/docs/DesignValidatorNotes.md +6 -0
package/src/grammar.json +57 -0
package/synthesizer/Synthesizer.py +88 -0
package/synthesizer/asts/lib_manager_ast.json +842 -0
package/synthesizer/dal_ast_synthesizer.py +31 -0
package/synthesizer/docs/commands.json +8 -0
package/synthesizer/getSynthesizedNode.py +362 -0
package/synthesizer/helper.py +13 -0
package/synthesizer/output/LoggingHelper.py +57 -0
package/synthesizer/output/synthesized.py +76 -0
package/synthesizer/output_helpers/LoggingHelper.py +57 -0
package/synthesizer/output_helpers/readme.md +3 -0
package/synthesizer/readme.md +9 -0
package/tests/Lexer.test.js +45 -0
package/tests/designs/library_manager.dal +79 -0
package/tests/designs/test.dal +19 -0
package/tests/designs/test3.dal +16 -0
package/tests/output/ast.json +842 -0
package/tests/output/ast_direct_gen.json +842 -0
package/tests/output/test_tokens.json +3628 -0

package/synthesizer/dal_ast_synthesizer.py ADDED Viewed

@@ -0,0 +1,31 @@
+import sys
+import json
+import argparse
+from Synthesizer import Synthesizer
+def main(argv):
+    args_parser = argparse.ArgumentParser(
+        description="Synthesizes a python program given the AST"
+    )
+    args_parser.add_argument(
+        "--ast",
+        required=True,
+        help="Path to ast file"
+    )
+    parsed_args = args_parser.parse_args(argv[1:])
+    try:
+        with open(parsed_args.ast, 'r') as f:
+            tree = json.loads(f.read())
+    except Exception as e:
+        print(f"Invalid arguments: {str(e)}", file=sys.stderr)
+        return -1
+    synth = Synthesizer(tree)
+    synth.run()
+if __name__ == "__main__":
+    sys.exit(main(sys.argv))

package/synthesizer/docs/commands.json ADDED Viewed

@@ -0,0 +1,8 @@
+{
+    "set": {
+        "description": "set(<target>,<keys>,<value>)"
+    },
+    "create": {
+        "description": "create(<name>,<type>,<role>)"
+    }
+}

package/synthesizer/getSynthesizedNode.py ADDED Viewed

@@ -0,0 +1,362 @@
+import ast
+from helper import getVariableNameWithKeys
+def getSynthesizedNode(node):
+    '''
+        Get the AST node given the dalAST metadata.
+        DAL Identifiers: get<Identifier>Ast
+        Commands: getCmd<CommandName>Ast
+    '''
+    type = node["type"]
+    if (type == "cmd"):
+        cmd = node["command"]
+        funcName = f"getCmd{cmd[0].upper() +cmd[1:]}Ast"
+    else:
+        funcName = f"get{type[0].upper() +type[1:]}Ast"
+    if (funcName in globals()):
+        return globals()[funcName](node)
+def getCmdLogAst(node):
+    '''
+        log(<behavior>, <name>, <type>, <value>)
+        semanticLogger.logParticipant(<behavior>, <name>, <type>, <value>)
+    '''
+    behavior = node["args"][0]["value"]
+    name = node["args"][1]["value"]
+    type = node["args"][2]["value"]
+    value = node["args"][3]["value"]
+    return ast.Expr(
+        value=ast.Call(
+            func=ast.Attribute(
+                value=ast.Name(id="semanticLogger", ctx=ast.Load()),
+                attr="logParticipant",
+                ctx=ast.Load(),
+            ),
+            args=[
+                ast.Constant(value=behavior),
+                ast.Constant(value=name),
+                ast.Constant(value=type),
+                ast.Name(id=value, ctx=ast.Load()),
+            ],
+            keywords=[],
+        )
+    )
+def getBehaviorAst(node):
+    '''
+        def <behaviorName>():
+            global worldState
+    '''
+    return ast.FunctionDef(
+        name=node["behaviorName"],
+        args=ast.arguments(
+            posonlyargs=[],
+            args=[],
+            kwonlyargs=[],
+            kw_defaults=[],
+            defaults=[],
+            vararg=None,
+            kwarg=None
+        ),
+        body=[
+            ast.Global(
+                names=["worldState"]
+            )
+        ],
+        decorator_list=[]
+    )
+def getDesignAst(node):
+    '''
+        design = <design_Name>
+    '''
+    return ast.Assign(
+        targets=[
+            ast.Name(id="design", ctx=ast.Store())
+        ],
+        value=ast.Constant(value=node["design_name"][0]["value"])
+    )
+def getWhileAst(node):
+    '''
+        while <condition>:
+            <body>
+    '''
+    return ast.While(
+        test=ast.Name(id=node["args"][0]["value"], ctx=ast.Load()),
+        body=[],
+        orelse=[]
+    )
+def getIfAst(node):
+    '''
+        if <condition>:
+            <body>
+    '''
+    condition = node["args"][0]["value"]
+    return ast.If(
+        test=ast.Name(id=condition, ctx=ast.Load()),
+        body=[],
+        orelse=[],
+    )
+def getCmdGetInputAst(node):
+    '''
+        This is a registered synthesis. I am claiming
+        that input() realises the meaning of the behavior
+        defined by getInput()
+        <output> = input()
+    '''
+    name = node["args"][0]["value"]
+    prompt = node["args"][1]["value"]
+    return  ast.Assign(
+        targets=[
+            ast.Name(id=name, ctx=ast.Store())
+        ],
+        value=ast.Call(
+            func=ast.Name(id="input", ctx=ast.Load()),
+            args=[ast.Constant(value=prompt)],
+            keywords=[]
+        )
+    )
+def getCmdSetAst(node):
+    '''
+        <name>[<keys>] = <value>
+    '''
+    name = node["args"][0]["value"]
+    keys = node["args"][1]["value"]
+    rawValue = node["args"][2]["value"]
+    if (node["args"][2]["type"] == "name"):
+        value = ast.Name(id=rawValue, ctx=ast.Load())
+    else:
+        value = ast.Constant(value=rawValue)
+    return ast.Assign(
+        targets=[
+            getVariableNameWithKeys(name, keys)
+        ],
+        value=value,
+    )
+def getCmdInsertAst(node):
+    '''
+        Command: insert(<target>, <keys>,  <value>, <index>)
+        Synthesized: <target>[<keys>].insert(<index>, <value>)
+    '''
+    target = node["args"][0]["value"]
+    keys = node["args"][1]["value"]
+    value = node["args"][2]["value"]
+    index = node["args"][3]["value"]
+    return ast.Expr(
+        value=ast.Call(
+            func=ast.Attribute(
+                value= getVariableNameWithKeys(target, keys),
+                attr="insert",
+                ctx=ast.Load()
+            ),
+            args=[
+                ast.Constant(index),
+                ast.Name(id=value, ctx=ast.Load()),
+            ],
+            keywords=[]
+        )
+    )
+def getCmdGetAst(node):
+    '''
+        Command: get(<target>, <source>, <keys>)
+        Synthesized: <target> = <source>[<keys>]
+    '''
+    target = node["args"][0]["value"]
+    source = node["args"][1]["value"]
+    keys = node["args"][2]["value"]
+    return ast.Assign(
+        value=getVariableNameWithKeys(source, keys),
+        targets=[ast.Name(id=target, ctx=ast.Store())]
+    )
+def getCmdSelectAst(node):
+    '''
+        Command: select(<nextBehavior>)
+        Synthesized: return <nextBehavior>
+    '''
+    returnValue = node["args"][0]["value"]
+    return ast.Return(
+        value=ast.Constant(value=returnValue)
+    )
+def getCmdDisplayAst(node):
+    '''
+        Command: display(<prompt>)
+        Synthesized: print(<prompt>)
+    '''
+    display = node["args"][0]["value"]
+    return ast.Expr(
+        value=ast.Call(
+            func=ast.Name(id="print", ctx=ast.Load()),
+            args=[
+                ast.parse(display, mode="eval").body
+            ],
+            keywords=[]
+        )
+    )
+def getCmdIsEqualAst(node):
+    '''
+        Command: isEqual(choice, "a", isAdd)
+        Synthesized: isAdd = choice == "a"
+    '''
+    output = node["args"][2]["value"]
+    if (node["args"][0]["type"] == "name"):
+        cmp1 = ast.Name(id=node["args"][0]["value"], ctx=ast.Load())
+    else:
+        cmp1 = ast.Constant(value=node["args"][0]["value"])
+    if (node["args"][1]["type"] == "name"):
+        cmp2 = ast.Name(id=node["args"][1]["value"], ctx=ast.Load())
+    else:
+        cmp2 = ast.Constant(value=node["args"][1]["value"])
+    return ast.Assign(
+        targets=[
+            ast.Name(id=output, ctx=ast.Store())
+        ],
+        value=ast.Compare(
+            left=cmp1,
+            ops=[ast.Eq()],
+            comparators=[cmp2],
+        ),
+    )
+def getCmdGetFromPosAst(node):
+    '''
+        Command: getFromPos(book, basket, 0)
+        Synthesized:
+        book = basket[0]
+    '''
+    target = node["args"][0]["value"]
+    source = node["args"][1]["value"]
+    index = node["args"][2]["value"]
+    return ast.Assign(
+        targets=[
+            ast.Name(id=target, ctx=ast.Store())
+        ],
+        value=ast.Subscript(
+            value=ast.Name(id=source, ctx=ast.Load()),
+            slice=ast.Constant(value=index),
+            ctx=ast.Load()
+        )
+    )
+def getCmdRemoveFromPosAst(node):
+    '''
+        Command: removeFromPos(book, basket, 0)
+        Synthesized:
+        book = basket(0)
+    '''
+    target = node["args"][0]["value"]
+    source = node["args"][1]["value"]
+    index = node["args"][2]["value"]
+    return ast.Assign(
+        targets=[
+            ast.Name(id=target, ctx=ast.Store())
+        ],
+        value=ast.Call(
+            func=ast.Attribute(
+                value=ast.Name(id=source, ctx=ast.Load()),
+                attr="pop",
+                ctx=ast.Load()
+            ),
+            args=[ast.Constant(value=index)],
+            keywords=[]
+        )
+    )
+def getCmdRunAst(node):
+    '''
+        Command: run(<startBehavior>)
+        Synthesized:
+        if __name__ == "__main__":
+            nextBehavior = <startBehavior>
+            while nextBehavior:
+                nextBehavior = globals()[nextBehavior]()
+    '''
+    nextBehavior = node["args"][0]["value"]
+    return ast.If(
+        test=ast.Compare(
+            left=ast.Name(id="__name__", ctx=ast.Load()),
+            ops=[ast.Eq()],
+            comparators=[
+                ast.Constant(value="__main__")
+            ],
+        ),
+        body=[
+            ast.Assign(
+                targets=[
+                    ast.Name(id="nextBehavior", ctx=ast.Store())
+                ],
+                value=ast.Constant(value=nextBehavior),
+            ),
+            ast.Assign(
+                targets=[
+                    ast.Name(id="worldState", ctx=ast.Store())
+                ],
+                value=ast.Dict(
+                    keys=[],
+                    values=[]
+                )
+            ),
+            ast.While(
+                test=ast.Name(id="nextBehavior", ctx=ast.Load()),
+                body=[
+                    ast.Assign(
+                        targets=[
+                            ast.Name(id="nextBehavior", ctx=ast.Store())
+                        ],
+                        value=ast.Call(
+                            func=ast.Subscript(
+                                value=ast.Call(
+                                    func=ast.Name(
+                                        id="globals",
+                                        ctx=ast.Load(),
+                                    ),
+                                    args=[],
+                                    keywords=[],
+                                ),
+                                slice=ast.Name(
+                                    id="nextBehavior",
+                                    ctx=ast.Load(),
+                                ),
+                                ctx=ast.Load(),
+                            ),
+                            args=[],
+                            keywords=[],
+                        ),
+                    )
+                ],
+                orelse=[],
+            ),
+        ],
+        orelse=[],
+    )

package/synthesizer/helper.py ADDED Viewed

@@ -0,0 +1,13 @@
+import ast
+def getVariableNameWithKeys(name, keys):
+    current = ast.Name(id=name, ctx=ast.Load())
+    for key in keys:
+        current = ast.Subscript(
+            value=current,
+            slice=ast.Constant(value=key),
+            ctx=ast.Store()
+        )
+    return current

package/synthesizer/output/LoggingHelper.py ADDED Viewed

@@ -0,0 +1,57 @@
+import logging
+from pathlib import Path
+from clp_logging.handlers import ClpKeyValuePairStreamHandler
+import os, uuid
+ADLI_EXECUTION_ID = str(uuid.uuid4())
+path = Path(os.path.dirname(__file__)) / f"{ADLI_EXECUTION_ID}.clp.zst"
+clp_handler = ClpKeyValuePairStreamHandler(open(path, "wb"))
+logger = logging.getLogger("semanticLogger")
+logger.setLevel(logging.INFO)
+logger.addHandler(clp_handler)
+class LoggingHelper:
+    '''
+        This class holds all the logging functions used by the
+        instrumented code during runtime.
+    '''
+    def logParticipant(self, behaviorId, participantName, participantType, participantValue):
+        entry = {}
+        entry["type"] = "participant"
+        entry["behaviorName"] = behaviorId
+        entry["participantName"] = participantName
+        entry["participantType"] = participantType
+        entry["participantValue"] = participantValue
+        logger.info(entry)
+    def logArgument(self, behaviorId, argumentName, argumentValue):
+        entry = {}
+        entry["type"] = "argument"
+        entry["behaviorName"] = behaviorId
+        entry["argumentName"] = argumentName
+        entry["argumentValue"] = argumentValue
+        logger.info(entry)
+    def logInput(self, behaviorId, inputName, inputValue):
+        entry = {}
+        entry["type"] = "behavior"
+        entry["behaviorName"] = behaviorId
+        entry["inputName"] = inputName
+        entry["inputValue"] = inputValue
+        logger.info(entry)
+    def logBehavior(self, behaviorId):
+        entry = {}
+        entry["type"] = "behavior"
+        entry["behaviorName"] = behaviorId
+        logger.info(entry)
+    def logFailure(self, behaviorId):
+        entry = {}
+        entry["type"] = "failure"
+        entry["behaviorName"] = behaviorId
+        logger.info(entry)
+semanticLogger = LoggingHelper()

package/synthesizer/output/synthesized.py ADDED Viewed

@@ -0,0 +1,76 @@
+from LoggingHelper import semanticLogger
+design = 'library_manager'
+def createBasket():
+    global worldState
+    basket = []
+    worldState['basket'] = basket
+    return 'getChoice'
+def getChoice():
+    global worldState
+    choice = input('\nGet user choice (a for add book, g for get book, else exit): ')
+    semanticLogger.logParticipant('getChoice', 'choice', 'string', choice)
+    isAdd = choice == 'a'
+    isGet = choice == 'g'
+    worldState['choice'] = choice
+    if isAdd:
+        return 'getName'
+    if isGet:
+        return 'getBookFromBasket'
+def getBookFromBasket():
+    global worldState
+    basket = worldState['basket']
+    book = basket.pop(0)
+    worldState['book'] = book
+    return 'getFirstLetterOfBookName'
+def getFirstLetterOfBookName():
+    global worldState
+    book = worldState['book']
+    name = book['name']
+    firstLetter = name[0]
+    print(f'Got book named {name} and it has first letter {firstLetter}')
+    worldState['firstLetter'] = firstLetter
+    return 'getChoice'
+def displayChoice():
+    global worldState
+    choice = worldState['choice']
+    print(f'User Choice: {choice}')
+    return 'getChoice'
+def getName():
+    global worldState
+    name = input('\nPlease enter book name: ')
+    semanticLogger.logParticipant('getName', 'name', 'string', name)
+    worldState['name'] = name
+    return 'createBook'
+def createBook():
+    global worldState
+    name = worldState['name']
+    book = {}
+    book['name'] = name
+    worldState['book'] = book
+    return 'addBookToBasket'
+def addBookToBasket():
+    global worldState
+    book = worldState['book']
+    basket = worldState['basket']
+    basket.insert(0, book)
+    worldState['basket'] = basket
+    return 'showBasket'
+def showBasket():
+    global worldState
+    basket = worldState['basket']
+    print(f'Basket Contents: {basket}')
+    return 'getChoice'
+if __name__ == '__main__':
+    nextBehavior = 'createBasket'
+    worldState = {}
+    while nextBehavior:
+        nextBehavior = globals()[nextBehavior]()

package/synthesizer/output_helpers/LoggingHelper.py ADDED Viewed

@@ -0,0 +1,57 @@
+import logging
+from pathlib import Path
+from clp_logging.handlers import ClpKeyValuePairStreamHandler
+import os, uuid
+ADLI_EXECUTION_ID = str(uuid.uuid4())
+path = Path(os.path.dirname(__file__)) / f"{ADLI_EXECUTION_ID}.clp.zst"
+clp_handler = ClpKeyValuePairStreamHandler(open(path, "wb"))
+logger = logging.getLogger("semanticLogger")
+logger.setLevel(logging.INFO)
+logger.addHandler(clp_handler)
+class LoggingHelper:
+    '''
+        This class holds all the logging functions used by the
+        instrumented code during runtime.
+    '''
+    def logParticipant(self, behaviorId, participantName, participantType, participantValue):
+        entry = {}
+        entry["type"] = "participant"
+        entry["behaviorName"] = behaviorId
+        entry["participantName"] = participantName
+        entry["participantType"] = participantType
+        entry["participantValue"] = participantValue
+        logger.info(entry)
+    def logArgument(self, behaviorId, argumentName, argumentValue):
+        entry = {}
+        entry["type"] = "argument"
+        entry["behaviorName"] = behaviorId
+        entry["argumentName"] = argumentName
+        entry["argumentValue"] = argumentValue
+        logger.info(entry)
+    def logInput(self, behaviorId, inputName, inputValue):
+        entry = {}
+        entry["type"] = "behavior"
+        entry["behaviorName"] = behaviorId
+        entry["inputName"] = inputName
+        entry["inputValue"] = inputValue
+        logger.info(entry)
+    def logBehavior(self, behaviorId):
+        entry = {}
+        entry["type"] = "behavior"
+        entry["behaviorName"] = behaviorId
+        logger.info(entry)
+    def logFailure(self, behaviorId):
+        entry = {}
+        entry["type"] = "failure"
+        entry["behaviorName"] = behaviorId
+        logger.info(entry)
+semanticLogger = LoggingHelper()

package/synthesizer/output_helpers/readme.md ADDED Viewed

@@ -0,0 +1,3 @@
+Contains helpers used by the synthesized output.
+- LoggingHelper: Creates CLP logging instance and makes it available to the synthesized program.

package/synthesizer/readme.md ADDED Viewed

@@ -0,0 +1,9 @@
+This contains a synthesizer (written in python) that will synthesize an implementation of a design specified in the Design Abstraction Language.
+I am writing it in python because the AST library is very convenient and I will invoke it from the workbench using the nodejs runner.
+# Example Usage
+```bash
+python3 dal_ast_synthesizer.py --ast ./asts/lib_manager_ast.json
+```

package/tests/Lexer.test.js ADDED Viewed

@@ -0,0 +1,45 @@
+import {describe, expect, it} from "vitest";
+import {resolve} from "path"
+import {readFile, unlink, writeFile} from "fs/promises"
+import { DesignValidator } from "../src/DesignValidator";
+import { DalParser } from "../src/Parser";
+import { DalLexer} from "../src/Lexer";
+import { DalAstGenerator } from "../src/DalAstGenerator";
+describe("Lexer", () => {
+    it("basic source", async () => {
+        const filePath = resolve(__dirname, "./designs/library_manager.dal")
+        const source = await readFile(filePath)
+        const lexer = new DalLexer(source.toString());
+        const tokens_output_path = resolve(__dirname, "./output/test_tokens.json")
+        await writeFile(
+            tokens_output_path,
+            JSON.stringify(lexer.scannedTokens, null, 4)
+        );
+        const parser = new DalParser(lexer.scannedTokens);
+        const ast_output_path = resolve(__dirname, "./output/ast.json")
+        await writeFile(
+            ast_output_path,
+            JSON.stringify(parser.ast, null, 4)
+        );
+        const validator = new DesignValidator(parser.ast);
+        validator.run();
+    });
+    it("tests direct ast generation", async () => {
+        const filePath = resolve(__dirname, "./designs/library_manager.dal")
+        const source = await readFile(filePath)
+        const ast = new DalAstGenerator().run(source.toString());
+        const ast_output_path = resolve(__dirname, "./output/ast_direct_gen.json")
+        await writeFile(
+            ast_output_path,
+            JSON.stringify(ast, null, 4)
+        );
+    });
+});