Working on AST Generation

Author: ftomassetti

Requirements.txt

@@ -5,7 +5,7 @@ charset-normalizer==3.4.1
 click==8.1.8
 flake8==7.1.2
 idna==3.10
-lionweb-python==0.1.8
+lionweb-python==0.1.14
 mccabe==0.7.0
 pycodestyle==2.12.1
 pyflakes==3.2.0

pylasu/lionweb/ast_generation.py

@@ -1,40 +1,42 @@
 import ast
 from pathlib import Path
-from symtable import Class
-from typing import cast
+from typing import cast, List, Dict
 
 import astor  # Install with `pip install astor`
 import click
-import os
-import sys
-
 from lionwebpython.language import Language, Concept, Interface
-from lionwebpython.language.classifier import Classifier
+from lionwebpython.language.enumeration import Enumeration
 from lionwebpython.language.primitive_type import PrimitiveType
 from lionwebpython.lionweb_version import LionWebVersion
 from lionwebpython.serialization.serialization_provider import SerializationProvider
 
-# Define the function AST
-func_def = ast.FunctionDef(
-    name="hello_world",
-    args=ast.arguments(
-        posonlyargs=[], args=[], kwonlyargs=[], kw_defaults=[], defaults=[]
-    ),
-    body=[
-        ast.Expr(value=ast.Call(
-            func=ast.Name(id="print", ctx=ast.Load()),
-            args=[ast.Constant(value="Hello, world!")], keywords=[]
-        ))
-    ],
-    decorator_list=[],
-)
-
-# # Convert AST to code
-# module = ast.Module(body=[func_def], type_ignores=[])
-# generated_code = astor.to_source(module)
-#
-# print(generated_code)
-#
+from pylasu.lionweb.starlasu import StarLasuBaseLanguage
+
+
+def topological_concepts_sort(concepts: List[Concept]) -> List[Concept]:
+    id_to_concept = {el.get_id(): el for el in concepts}
+
+    # Build graph edges: child -> [parents]
+    graph: Dict[str, List[str]] = {el.get_id(): [] for el in concepts}
+    for el in concepts:
+        if el.get_extended_concept() and el.get_extended_concept().get_id() in id_to_concept:
+            graph[el.get_id()].append(el.get_extended_concept().get_id())
+
+    visited = set()
+    sorted_list = []
+
+    def visit(name: str):
+        if name in visited:
+            return
+        visited.add(name)
+        for dep in graph[name]:
+            visit(dep)
+        sorted_list.append(id_to_concept[name])
+
+    for el in concepts:
+        visit(el.get_id())
+
+    return sorted_list
 
 @click.command()
 @click.argument("dependencies", nargs=-1, type=click.Path(exists=True, dir_okay=False, readable=True))
@@ -51,27 +53,54 @@ def main(dependencies, lionweb_language, output):
             language = cast(Language, serialization.deserialize_string_to_nodes(content)[0])
             serialization.register_language(language=language)
             serialization.classifier_resolver.register_language(language)
-            serialization.classifier_resolver.resolve_classifier(language)
+            serialization.instance_resolver.add_tree(language)
 
     click.echo(f"📄 Processing file: {lionweb_language}")
     with open(lionweb_language, "r", encoding="utf-8") as f:
         content = f.read()
         language = cast(Language, serialization.deserialize_string_to_nodes(content)[0])
 
-    module = ast.Module(body=[], type_ignores=[])
+    import_abc = ast.ImportFrom(
+        module='abc',
+        names=[ast.alias(name='ABC', asname=None)],
+        level=0
+    )
+    import_node = ast.ImportFrom(
+        module='pylasu.model',
+        names=[ast.alias(name='Node', asname=None)],
+        level=0
+    )
+    module = ast.Module(body=[import_abc, import_node], type_ignores=[])
+
+
     for element in language.get_elements():
         if isinstance(element, Concept):
-            classdef = ast.ClassDef(element.get_name(), bases=[],  # No parent classes
-                keywords=[],
-                body=[ast.Pass()],
-                decorator_list=[])
-            module.body.append(classdef)
+            pass
         elif isinstance(element, Interface):
             pass
         elif isinstance(element, PrimitiveType):
             pass
+        elif isinstance(element, Enumeration):
+            pass
         else:
             raise ValueError(f"Unsupported {element}")
+
+    sorted_concepts = topological_concepts_sort([c for c in language.get_elements() if isinstance(c, Concept)])
+
+    for concept in sorted_concepts:
+        bases = []
+        if concept.get_extended_concept().id == StarLasuBaseLanguage.get_astnode(LionWebVersion.V2023_1).id:
+            bases.append('Node')
+        else:
+            bases.append(concept.get_extended_concept().get_name())
+        if concept.is_abstract():
+            bases.append('ABC')
+        classdef = ast.ClassDef(concept.get_name(), bases=bases,
+            keywords=[],
+            body=[ast.Pass()],
+            decorator_list=[])
+        module.body.append(classdef)
+
     click.echo(f"📂 Saving results to: {output}")
     generated_code = astor.to_source(module)
     output_path = Path(output)

pylasu/lionweb/starlasu.py

@@ -0,0 +1,72 @@
+from typing import TYPE_CHECKING, Dict, Optional, cast
+
+from lionwebpython.language import Language, Concept
+from lionwebpython.language.lioncore_builtins import LionCoreBuiltins
+from lionwebpython.language.primitive_type import PrimitiveType
+from lionwebpython.lionweb_version import LionWebVersion
+
+class StarLasuBaseLanguage(Language):
+    if TYPE_CHECKING:
+        from lionwebpython.language.concept import Concept
+        from lionwebpython.language.interface import Interface
+        from lionwebpython.language.primitive_type import PrimitiveType
+        from lionwebpython.language.property import Property
+        from lionwebpython.lionweb_version import LionWebVersion
+        from lionwebpython.utils.id_utils import IdUtils
+
+    _instances: Dict["LionWebVersion", "LionCoreBuiltins"] = {}
+
+    def __init__(self, lion_web_version: "LionWebVersion"):
+        super().__init__(lion_web_version=lion_web_version, name="com.strumenta.StarLasu")
+        from lionwebpython.lionweb_version import LionWebVersion
+        from lionwebpython.utils.id_utils import IdUtils
+
+        version_id_suffix = (
+            f"-{IdUtils.clean_string(lion_web_version.value)}"
+            if lion_web_version != LionWebVersion.V2023_1
+            else ""
+        )
+
+        if lion_web_version == LionWebVersion.V2023_1:
+            version = "1"
+        elif lion_web_version == LionWebVersion.V2024_1:
+            version = "2"
+        else:
+            raise ValueError()
+
+        self.set_id(f"com-strumenta-StarLasu{version_id_suffix}")
+        self.set_key("com_strumenta_starlasu")
+        self.set_version(version)
+
+        self.char = PrimitiveType(lion_web_version=lion_web_version, language=self,
+                                  name="Char", id=f"com-strumenta-StarLasu-Char-id{version_id_suffix}",
+                                  key="com_strumenta_starlasu-Char-key")
+        self.point = PrimitiveType(lion_web_version=lion_web_version, language=self,
+                                  name="Point", id=f"com-strumenta-StarLasu-Point-id{version_id_suffix}",
+                                  key="com_strumenta_starlasu-Point-key")
+        self.position = PrimitiveType(lion_web_version=lion_web_version, language=self,
+                                   name="Position", id=f"com-strumenta-StarLasu-Position-id{version_id_suffix}",
+                                   key="com_strumenta_starlasu-Position-key")
+        self.astnode = Concept(lion_web_version=lion_web_version, language=self,
+                               name="ASTNode", key="com_strumenta_starlasu-ASTNode-key",
+                               id="com-strumenta-StarLasu-ASTNode-id")
+
+    @classmethod
+    def get_astnode(
+        cls, lion_web_version: LionWebVersion = LionWebVersion.current_version()
+    ) -> "Concept":
+        return cls.get_instance(lion_web_version).astnode
+
+    @classmethod
+    def get_instance(
+        cls, lion_web_version: Optional["LionWebVersion"] = None
+    ) -> "StarLasuBaseLanguage":
+        if lion_web_version is None:
+            from lionwebpython.lionweb_version import LionWebVersion
+
+            lion_web_version = LionWebVersion.current_version()
+
+        if lion_web_version not in cls._instances:
+            cls._instances[lion_web_version] = StarLasuBaseLanguage(lion_web_version)
+
+        return cls._instances[lion_web_version]