Refactor BNF package: 1:1 match JS/Python, add rollup, clean dependencies

Co-authored-by: hzhangxyz <11623447+hzhangxyz@users.noreply.github.com>

Author: Copilot

bnf/apyds_bnf/__init__.py

@@ -1,12 +1,91 @@
-"""
-BNF Parser and Unparsers for DS
+from antlr4 import InputStream, CommonTokenStream
 
-This package provides bidirectional conversion between:
-- Ds: The lisp-like syntax currently used in DS
-- Dsp: A traditional readable syntax
-"""
+from .DspLexer import DspLexer
+from .DspParser import DspParser
+from .DspVisitor import DspVisitor
+from .DsLexer import DsLexer
+from .DsParser import DsParser
+from .DsVisitor import DsVisitor
 
-from .unparse import unparse
-from .parse import parse
 
-__all__ = ["unparse", "parse"]
+class ParseVisitor(DspVisitor):
+    def visitRule_pool(self, ctx):
+        return "\n\n".join(self.visit(r) for r in ctx.rule_())
+
+    def visitRule(self, ctx):
+        result = [self.visit(t) for t in ctx.term()]
+        if len(result) == 1:
+            return f"----\n{result[0]}"
+        else:
+            conclusion = result.pop()
+            length = max(len(premise) for premise in result)
+            result.append("-" * max(length, 4))
+            result.append(conclusion)
+            return "\n".join(result)
+
+    def visitSymbol(self, ctx):
+        return ctx.SYMBOL().getText()
+
+    def visitParentheses(self, ctx):
+        return self.visit(ctx.term())
+
+    def visitSubscript(self, ctx):
+        return f"(subscript {' '.join(self.visit(t) for t in ctx.term())})"
+
+    def visitFunction(self, ctx):
+        return f"(function {' '.join(self.visit(t) for t in ctx.term())})"
+
+    def visitUnary(self, ctx):
+        return f"(unary {ctx.getChild(0).getText()} {self.visit(ctx.term())})"
+
+    def visitBinary(self, ctx):
+        return f"(binary {ctx.getChild(1).getText()} {self.visit(ctx.term(0))} {self.visit(ctx.term(1))})"
+
+
+class UnparseVisitor(DsVisitor):
+    def visitRule_pool(self, ctx):
+        return "\n".join(self.visit(r) for r in ctx.rule_())
+
+    def visitRule(self, ctx):
+        result = [self.visit(t) for t in ctx.term()]
+        conclusion = result.pop()
+        length = max(len(premise) for premise in result)
+        return ", ".join(result) + " -> " + conclusion
+
+    def visitSymbol(self, ctx):
+        return ctx.SYMBOL().getText()
+
+    def visitSubscript(self, ctx):
+        terms = ctx.term()
+        return f"{self.visit(terms[0])}[{', '.join(self.visit(t) for t in terms[1:])}]"
+
+    def visitFunction(self, ctx):
+        terms = ctx.term()
+        return f"{self.visit(terms[0])}({', '.join(self.visit(t) for t in terms[1:])})"
+
+    def visitUnary(self, ctx):
+        return f"({ctx.getChild(0).getText()} {self.visit(ctx.term())})"
+
+    def visitBinary(self, ctx):
+        return f"({self.visit(ctx.term(0))} {ctx.getChild(1).getText()} {self.visit(ctx.term(1))})"
+
+
+def parse(input):
+    chars = InputStream(input)
+    lexer = DspLexer(chars)
+    tokens = CommonTokenStream(lexer)
+    parser = DspParser(tokens)
+    tree = parser.rule_pool()
+    visitor = ParseVisitor()
+    return visitor.visit(tree)
+
+
+def unparse(input):
+    chars = InputStream(input)
+    lexer = DsLexer(chars)
+    tokens = CommonTokenStream(lexer)
+    parser = DsParser(tokens)
+    tree = parser.rule_pool()
+    visitor = UnparseVisitor()
+    return visitor.visit(tree)
+

bnf/apyds_bnf/parse.py

@@ -1,28 +1,33 @@
 {
     "name": "atsds-bnf",
-    "version": "0.1.0",
     "description": "BNF parser and unparsers for DS - conversion between lisp-like and traditional syntax",
     "author": "Hao Zhang <hzhangxyz@outlook.com>",
     "license": "AGPL-3.0-or-later",
-    "type": "module",
-    "exports": {
-        ".": "./atsds_bnf/index.js"
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/USTC-KnowledgeComputingLab/ds.git"
     },
-    "main": "atsds_bnf/index.js",
-    "module": "atsds_bnf/index.js",
+    "type": "module",
+    "exports": "./dist/bnf.mjs",
+    "main": "dist/bnf.mjs",
+    "module": "dist/bnf.mjs",
     "files": [
-        "atsds_bnf/**/*.js"
+        "dist/bnf.mjs"
     ],
     "scripts": {
-        "ds": "antlr4 -Dlanguage=JavaScript grammars/Ds.g4 -visitor -no-listener -o atsds_bnf/generated",
-        "dsp": "antlr4 -Dlanguage=JavaScript grammars/Dsp.g4 -visitor -no-listener -o atsds_bnf/generated",
+        "ds": "antlr4 -Dlanguage=JavaScript grammars/Ds.g4 -visitor -no-listener -o atsds_bnf",
+        "dsp": "antlr4 -Dlanguage=JavaScript grammars/Dsp.g4 -visitor -no-listener -o atsds_bnf",
         "prepare": "npm-run-all ds dsp",
-        "clean": "rm -rf atsds_bnf/generated"
+        "rollup": "rollup --config rollup.config.mjs",
+        "build": "npm-run-all prepare rollup"
     },
     "dependencies": {
         "antlr4": "^4.13.2"
     },
     "devDependencies": {
-        "npm-run-all": "^4.1.5"
+        "@rollup/plugin-node-resolve": "^16.0.3",
+        "@rollup/plugin-terser": "^0.4.4",
+        "npm-run-all": "^4.1.5",
+        "rollup": "^4.53.3"
     }
 }

bnf/apyds_bnf/unparse.py

@@ -1,5 +1,5 @@
 [build-system]
-requires = ["setuptools>=61.0", "wheel", "antlr4-tools>=0.2.1", "setuptools-scm>=8.0"]
+requires = ["setuptools>=61.0", "setuptools-scm>=8.0"]
 build-backend = "setuptools.build_meta"
 
 [project]
@@ -14,10 +14,8 @@ dependencies = [
     "antlr4-python3-runtime>=4.13.2",
 ]
 
-[project.optional-dependencies]
-dev = [
-    "antlr4-tools>=0.2.1",
-]
+[project.urls]
+Repository = "https://github.com/USTC-KnowledgeComputingLab/ds.git"
 
 [tool.setuptools.packages.find]
 where = ["."]

bnf/package.json

@@ -0,0 +1,16 @@
+import terser from "@rollup/plugin-terser";
+import nodeResolve from "@rollup/plugin-node-resolve";
+
+export default [
+    {
+        input: "atsds_bnf/index.js",
+        output: {
+            file: "dist/bnf.mjs",
+            format: "es",
+        },
+        plugins: [
+            terser(),
+            nodeResolve(),
+        ],
+    },
+];