Working on Deserializer Generation

Author: ftomassetti

pylasu/lionweb/ast_generation.py

@@ -12,6 +12,7 @@
 from lionwebpython.lionweb_version import LionWebVersion
 
 from pylasu.lionweb.starlasu import StarLasuBaseLanguage
+from pylasu.lionweb.utils import calculate_field_name
 
 
 def topological_classifiers_sort(classifiers: List[Classifier]) -> List[Classifier]:
@@ -161,9 +162,7 @@ def ast_generation(click, language: Language, output):
 
             for feature in classifier.get_features():
                 if isinstance(feature, Containment):
-                    field_name = feature.get_name()
-                    if field_name in keyword.kwlist:
-                        field_name = f"{field_name}_"
+                    field_name = calculate_field_name(feature)
                     type = feature.get_type().get_name()
                     if feature.is_multiple():
                         type = f"List[{type}]"

pylasu/lionweb/deserializer_generation.py

@@ -12,7 +12,7 @@
 from lionwebpython.lionweb_version import LionWebVersion
 
 from pylasu.lionweb.starlasu import StarLasuBaseLanguage
-from pylasu.lionweb.utils import to_snake_case
+from pylasu.lionweb.utils import to_snake_case, calculate_field_name
 
 
 def make_cond(enumeration_name: str, member_name: str):
@@ -42,6 +42,95 @@ def make_return(enumeration_name: str, member_name: str):
         )
     )
 
+def generate_register_deserializers_func(language: Language) -> ast.FunctionDef:
+    fd = ast.FunctionDef(
+        name="register_deserializers",
+        args=ast.arguments(
+            posonlyargs=[],
+            args=[
+                ast.arg(arg="json_serialization", annotation=ast.Name(id="JsonSerialization", ctx=ast.Load()))
+            ],
+            kwonlyargs=[],
+            kw_defaults=[],
+            defaults=[]
+        ),
+        body=[
+        ],
+        decorator_list=[],
+        returns=None
+    )
+    for e in language.get_elements():
+        if isinstance(e, Enumeration):
+            fd.body.append(ast.Expr(
+                value=ast.Call(
+                    func=ast.Attribute(
+                        value=ast.Attribute(
+                            value=ast.Name(id="json_serialization", ctx=ast.Load()),
+                            attr="primitive_values_serialization",
+                            ctx=ast.Load()
+                        ),
+                        attr="register_deserializer",
+                        ctx=ast.Load()
+                    ),
+                    args=[
+                        ast.Constant(value=e.get_id()),
+                        ast.Name(id=f"_deserialize_{to_snake_case(e.get_name())}", ctx=ast.Load())
+                    ],
+                    keywords=[]
+                )
+            ))
+        elif isinstance(e, Concept):
+            fd.body.append(ast.Expr(
+                value=ast.Call(
+                    func=ast.Attribute(
+                        value=ast.Attribute(
+                            value=ast.Name(id="json_serialization", ctx=ast.Load()),
+                            attr="instantiator",
+                            ctx=ast.Load()
+                        ),
+                        attr="register_custom_deserializer",
+                        ctx=ast.Load()
+                    ),
+                    args=[
+                        ast.Constant(value=e.get_id()),
+                        ast.Name(id=f"_deserialize_{to_snake_case(e.get_name())}", ctx=ast.Load())
+                    ],
+                    keywords=[]
+                )
+            ))
+    return fd
+
+def generate_concept_deserializer(concept: Concept) -> ast.FunctionDef:
+    constructor_assignments = []
+    for f in concept.all_features():
+        field_name = calculate_field_name(f)
+        constructor_assignments.append(ast.keyword(arg=field_name, value=ast.Constant(value=f.get_name())))
+    return ast.FunctionDef(
+        name=f"_deserialize_{to_snake_case(concept.get_name())}",
+        args=ast.arguments(
+            posonlyargs=[],
+            args=[
+                ast.arg(arg="classifier"),
+                ast.arg(arg="serialized_instance"),
+                ast.arg(arg="deserialized_instances_by_id"),
+                ast.arg(arg="properties_values")
+            ],
+            kwonlyargs=[],
+            kw_defaults=[],
+            defaults=[]
+        ),
+        body=[
+            ast.Return(
+                value=ast.Call(
+                    func=ast.Name(id=concept.get_name(), ctx=ast.Load()),
+                    args=[],
+                    keywords=constructor_assignments
+                )
+            )
+        ],
+        decorator_list=[],
+        returns=ast.Name(id=concept.get_name(), ctx=ast.Load())
+    )
 
 def deserializer_generation(click, language: Language, output):
     import_abc = ast.ImportFrom(
@@ -92,12 +181,15 @@ def deserializer_generation(click, language: Language, output):
         names=[ast.alias(name=e.get_name(), asname=None) for e in language.get_elements() if isinstance(e, PrimitiveType)],
         level=0
     )
+    import_json_serialization = ast.ImportFrom(
+        module='lionwebpython.serialization.json_serialization',
+        names=[ast.alias(name='JsonSerialization', asname=None)],
+        level=0
+    )
     module = ast.Module(body=[import_abc, import_dataclass, import_typing, import_enum, import_starlasu, import_node,
-                              import_ast, import_primitives],
+                              import_ast, import_primitives, import_json_serialization],
                         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()))
@@ -154,6 +246,10 @@ def deserializer_generation(click, language: Language, output):
                 returns=ast.Constant(value=e.get_name())
             )
             module.body.append(func_def)
+        elif isinstance(e, Concept):
+            module.body.append(generate_concept_deserializer(e))
+
+    module.body.append(generate_register_deserializers_func(language))
 
     generated_code = astor.to_source(module)
     output_path = Path(output)

pylasu/lionweb/utils.py

@@ -1,7 +1,17 @@
+import keyword
 import re
 
+from lionwebpython.language import Feature
+
+
 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()
+    return name.lower()
+
+def calculate_field_name(feature: Feature) -> str:
+    field_name = feature.get_name()
+    if field_name in keyword.kwlist:
+        field_name = f"{field_name}_"
+    return field_name