Working on Deserializer Generation

ftomassetti · ftomassetti · commit 686c566b8eab · 2025-03-21T16:24:21.000+01:00
diff --git a/pylasu/lionweb/ast_generation.py b/pylasu/lionweb/ast_generation.py
@@ -1,17 +1,15 @@
 import ast
 import keyword
 from pathlib import Path
-from typing import cast, List, Dict
+from typing import List, Dict
 
-import astor  # Install with `pip install astor`
-import click
+import astor
 from lionwebpython.language import Language, Concept, Interface, Containment, Property
 from lionwebpython.language.classifier import Classifier
 from lionwebpython.language.enumeration import Enumeration
 from lionwebpython.language.primitive_type import PrimitiveType
 from lionwebpython.language.reference import Reference
 from lionwebpython.lionweb_version import LionWebVersion
-from lionwebpython.serialization.serialization_provider import SerializationProvider
 
 from pylasu.lionweb.starlasu import StarLasuBaseLanguage
 
@@ -54,28 +52,7 @@ def visit(name: str):
 
     return sorted_list
 
-@click.command()
-@click.argument("dependencies", nargs=-1, type=click.Path(exists=True, dir_okay=False, readable=True))
-@click.argument("lionweb-language", type=click.Path(exists=True, dir_okay=False, readable=True))
-@click.argument("output", type=click.Path(exists=False, file_okay=False, writable=True))
-def main(dependencies, lionweb_language, output):
-    """Simple CLI that processes a file and writes results to a directory."""
-    serialization = SerializationProvider.get_standard_json_serialization(LionWebVersion.V2023_1)
-
-    for dep in dependencies:
-        click.echo(f"Processing dependency {dep}")
-        with open(dep, "r", encoding="utf-8") as f:
-            content = f.read()
-            language = cast(Language, serialization.deserialize_string_to_nodes(content)[0])
-            serialization.register_language(language=language)
-            serialization.classifier_resolver.register_language(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])
-
+def ast_generation(click, language: Language, output):
     import_abc = ast.ImportFrom(
         module='abc',
         names=[ast.alias(name='ABC', asname=None)],
@@ -114,8 +91,8 @@ def main(dependencies, lionweb_language, output):
         names=[ast.alias(name='Node', asname=None)],
         level=0
     )
-    module = ast.Module(body=[import_abc, import_dataclass, import_typing, import_enum, import_starlasu, import_node], type_ignores=[])
-
+    module = ast.Module(body=[import_abc, import_dataclass, import_typing, import_enum, import_starlasu, import_node],
+                        type_ignores=[])
 
     for element in language.get_elements():
         if isinstance(element, Concept):
@@ -178,9 +155,9 @@ def main(dependencies, lionweb_language, output):
                 bases.append('ABC')
             dataclass_decorator = ast.Name(id="dataclass", ctx=ast.Load())
             classdef = ast.ClassDef(classifier.get_name(), bases=bases,
-                keywords=[],
-                body=[ast.Pass()],
-                decorator_list=[dataclass_decorator])
+                                    keywords=[],
+                                    body=[ast.Pass()],
+                                    decorator_list=[dataclass_decorator])
 
             for feature in classifier.get_features():
                 if isinstance(feature, Containment):
@@ -238,25 +215,22 @@ def main(dependencies, lionweb_language, output):
 
             module.body.append(classdef)
         elif isinstance(classifier, Interface):
-            bases=[]
+            bases = []
             if len(classifier.get_extended_interfaces()) == 0:
                 bases.append("Node")
                 bases.append("ABC")
 
             classdef = ast.ClassDef(classifier.get_name(), bases=bases,
-                keywords=[],
-                body=[ast.Pass()],
-                decorator_list=[])
+                                    keywords=[],
+                                    body=[ast.Pass()],
+                                    decorator_list=[])
             module.body.append(classdef)
         else:
             raise ValueError()
 
-    click.echo(f"📂 Saving results to: {output}")
+    click.echo(f"📂 Saving ast to: {output}")
     generated_code = astor.to_source(module)
     output_path = Path(output)
     output_path.mkdir(parents=True, exist_ok=True)
     with Path(f"{output}/ast.py").open("w", encoding="utf-8") as f:
-        f.write(generated_code)
-
-if __name__ == "__main__":
-    main()
+        f.write(generated_code)
diff --git a/pylasu/lionweb/deserializer_generation.py b/pylasu/lionweb/deserializer_generation.py
@@ -0,0 +1,163 @@
+import ast
+import keyword
+from pathlib import Path
+from typing import List, Dict
+
+import astor
+from lionwebpython.language import Language, Concept, Interface, Containment, Property
+from lionwebpython.language.classifier import Classifier
+from lionwebpython.language.enumeration import Enumeration
+from lionwebpython.language.primitive_type import PrimitiveType
+from lionwebpython.language.reference import Reference
+from lionwebpython.lionweb_version import LionWebVersion
+
+from pylasu.lionweb.starlasu import StarLasuBaseLanguage
+from pylasu.lionweb.utils import to_snake_case
+
+
+def make_cond(enumeration_name: str, member_name: str):
+    return ast.Compare(
+        left=ast.Name(id="serialized", ctx=ast.Load()),
+        ops=[ast.Eq()],
+        comparators=[
+            ast.Attribute(
+                value=ast.Attribute(
+                    value=ast.Name(id=enumeration_name, ctx=ast.Load()),
+                    attr=member_name,
+                    ctx=ast.Load()
+                ),
+                attr="value",
+                ctx=ast.Load()
+            )
+        ]
+    )
+
+# The return: return AssignmentType.Add
+def make_return(enumeration_name: str, member_name: str):
+    return ast.Return(
+        value=ast.Attribute(
+            value=ast.Name(id=enumeration_name, ctx=ast.Load()),
+            attr=member_name,
+            ctx=ast.Load()
+        )
+    )
+
+
+def deserializer_generation(click, language: Language, output):
+    import_abc = ast.ImportFrom(
+        module='abc',
+        names=[ast.alias(name='ABC', asname=None)],
+        level=0
+    )
+    import_dataclass = ast.ImportFrom(
+        module='dataclasses',
+        names=[ast.alias(name='dataclass', asname=None)],
+        level=0
+    )
+    import_enum = ast.ImportFrom(
+        module="enum",
+        names=[ast.alias(name="Enum", asname=None)],
+        level=0
+    )
+    import_typing = ast.ImportFrom(
+        module='typing',
+        names=[ast.alias(name='Optional', asname=None)],
+        level=0
+    )
+    import_starlasu = ast.ImportFrom(
+        module='pylasu.model.metamodel',
+        names=[ast.alias(name='Expression', asname='StarLasuExpression'),
+               ast.alias(name='PlaceholderElement', asname='StarLasuPlaceholderElement'),
+               ast.alias(name='Named', asname='StarLasuNamed'),
+               ast.alias(name='TypeAnnotation', asname='StarLasuTypeAnnotation'),
+               ast.alias(name='Parameter', asname='StarLasuParameter'),
+               ast.alias(name='Statement', asname='StarLasuStatement'),
+               ast.alias(name='EntityDeclaration', asname='StarLasuEntityDeclaration'),
+               ast.alias(name='BehaviorDeclaration', asname='StarLasuBehaviorDeclaration'),
+               ast.alias(name='Documentation', asname='StarLasuDocumentation')],
+        level=0
+    )
+    import_node = ast.ImportFrom(
+        module='pylasu.model',
+        names=[ast.alias(name='Node', asname=None)],
+        level=0
+    )
+    import_ast = ast.ImportFrom(
+        module='ast',
+        names=[ast.alias(name=e.get_name(), asname=None) for e in language.get_elements() if not isinstance(e, PrimitiveType)],
+        level=0
+    )
+    import_primitives = ast.ImportFrom(
+        module='primitive_types',
+        names=[ast.alias(name=e.get_name(), asname=None) for e in language.get_elements() if isinstance(e, PrimitiveType)],
+        level=0
+    )
+    module = ast.Module(body=[import_abc, import_dataclass, import_typing, import_enum, import_starlasu, import_node,
+                              import_ast, import_primitives],
+                        type_ignores=[])
+
+
+
+    for e in language.get_elements():
+        if isinstance(e, Enumeration):
+            arg_serialized = ast.arg(arg="serialized", annotation=ast.Name(id="str", ctx=ast.Load()))
+            # The raise: raise ValueError(f"...")
+            raise_stmt = ast.Raise(
+                exc=ast.Call(
+                    func=ast.Name(id="ValueError", ctx=ast.Load()),
+                    args=[
+                        ast.JoinedStr(values=[
+                            ast.Constant(value=f"Invalid value for {e.get_name()}: "),
+                            ast.FormattedValue(
+                                value=ast.Name(id="serialized", ctx=ast.Load()),
+                                conversion=-1
+                            )
+                        ])
+                    ],
+                    keywords=[]
+                ),
+                cause=None
+            )
+            # The function body
+            literals = e.get_literals()
+            current_if = ast.If(
+                test=make_cond(e.get_name(), literals[0].get_name()),
+                body=[make_return(e.get_name(), literals[0].get_name())],
+                orelse=[]
+            )
+            root_if = current_if
+
+            for literal in literals[1:]:
+                next_if = ast.If(
+                    test=make_cond(e.get_name(), literal.get_name()),
+                    body=[make_return(e.get_name(), literal.get_name())],
+                    orelse=[]
+                )
+                current_if.orelse = [next_if]
+                current_if = next_if
+
+            # Final else
+            current_if.orelse = [raise_stmt]
+
+            # Function definition
+            func_def = ast.FunctionDef(
+                name=f"_deserialize_{to_snake_case(e.get_name())}",
+                args=ast.arguments(
+                    posonlyargs=[],
+                    args=[arg_serialized],
+                    kwonlyargs=[],
+                    kw_defaults=[],
+                    defaults=[]
+                ),
+                body=[root_if],
+                decorator_list=[],
+                returns=ast.Constant(value=e.get_name())
+            )
+            module.body.append(func_def)
+
+    generated_code = astor.to_source(module)
+    output_path = Path(output)
+    output_path.mkdir(parents=True, exist_ok=True)
+    click.echo(f"📂 Saving deserializer to: {output}")
+    with Path(f"{output}/deserializer.py").open("w", encoding="utf-8") as f:
+        f.write(generated_code)
diff --git a/pylasu/lionweb/generator.py b/pylasu/lionweb/generator.py
@@ -0,0 +1,37 @@
+from typing import cast
+
+import click
+from lionwebpython.language import Language
+from lionwebpython.lionweb_version import LionWebVersion
+from lionwebpython.serialization.serialization_provider import SerializationProvider
+
+
+@click.command()
+@click.argument("dependencies", nargs=-1, type=click.Path(exists=True, dir_okay=False, readable=True))
+@click.argument("lionweb-language", type=click.Path(exists=True, dir_okay=False, readable=True))
+@click.argument("output", type=click.Path(exists=False, file_okay=False, writable=True))
+def main(dependencies, lionweb_language, output):
+    from pylasu.lionweb.ast_generation import ast_generation
+    from pylasu.lionweb.deserializer_generation import deserializer_generation
+    """Simple CLI that processes a file and writes results to a directory."""
+    serialization = SerializationProvider.get_standard_json_serialization(LionWebVersion.V2023_1)
+
+    for dep in dependencies:
+        click.echo(f"Processing dependency {dep}")
+        with open(dep, "r", encoding="utf-8") as f:
+            content = f.read()
+            language = cast(Language, serialization.deserialize_string_to_nodes(content)[0])
+            serialization.register_language(language=language)
+            serialization.classifier_resolver.register_language(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])
+    ast_generation(click, language, output)
+    deserializer_generation(click, language, output)
+
+
+if __name__ == "__main__":
+    main()
diff --git a/pylasu/lionweb/utils.py b/pylasu/lionweb/utils.py
@@ -0,0 +1,7 @@
+import re
+
+def to_snake_case(name: str) -> str:
+    # Replace capital letters with _lowercase, except at the beginning
+    name = re.sub(r'(.)([A-Z][a-z]+)', r'\1_\2', name)
+    name = re.sub(r'([a-z0-9])([A-Z])', r'\1_\2', name)
+    return name.lower()
