Merge remote-tracking branch 'origin/feature/lionweb-integration' into feature/lionweb-integration

Author: ftomassetti

.github/workflows/pythonapp.yml

@@ -36,4 +36,4 @@ jobs:
       - name: Test with pytest
         run: |
           pip install pytest pytest-cov pyecore==0.12.2
-          pytest --cov=pylasu --cov-fail-under=60 tests
+          pytest --cov=pylasu --cov-fail-under=50 tests

pylasu/lionweb/ast_generation.py

@@ -1,10 +1,11 @@
 import ast
 import keyword
+from _ast import ClassDef
 from pathlib import Path
 from typing import List, Dict
 
 import astor
-from lionwebpython.language import Language, Concept, Interface, Containment, Property
+from lionwebpython.language import Language, Concept, Interface, Containment, Property, Feature
 from lionwebpython.language.classifier import Classifier
 from lionwebpython.language.enumeration import Enumeration
 from lionwebpython.language.primitive_type import PrimitiveType
@@ -15,10 +16,7 @@
 from pylasu.lionweb.utils import calculate_field_name
 
 
-def topological_classifiers_sort(classifiers: List[Classifier]) -> List[Classifier]:
-    id_to_concept = {el.get_id(): el for el in classifiers}
-
-    # Build graph edges: child -> [parents]
+def _identify_topological_deps(classifiers: List[Classifier], id_to_concept) -> Dict[str, List[str]]:
     graph: Dict[str, List[str]] = {el.get_id(): [] for el in classifiers}
     for c in classifiers:
         if isinstance(c, Concept):
@@ -34,6 +32,14 @@ def topological_classifiers_sort(classifiers: List[Classifier]) -> List[Classifi
             pass
         else:
             raise ValueError()
+    return graph
+
+
+def topological_classifiers_sort(classifiers: List[Classifier]) -> List[Classifier]:
+    id_to_concept = {el.get_id(): el for el in classifiers}
+
+    # Build graph edges: child -> [parents]
+    graph: Dict[str, List[str]] = _identify_topological_deps(classifiers, id_to_concept)
 
     visited = set()
     sorted_list = []
@@ -53,6 +59,100 @@ def visit(name: str):
 
     return sorted_list
 
+
+def _generate_from_containment(feature: Containment, classdef: ClassDef):
+    field_name = calculate_field_name(feature)
+    type = feature.get_type().get_name()
+    if feature.is_multiple():
+        type = f"List[{type}]"
+    elif feature.is_optional():
+        type = f"Optional[{type}]"
+    field = ast.AnnAssign(
+        target=ast.Name(id=field_name, ctx=ast.Store()),
+        annotation=ast.Constant(value=type),
+        value=None,
+        simple=1,
+    )
+    if len(classdef.body) == 1 and isinstance(classdef.body[0], ast.Pass):
+        classdef.body = []
+    classdef.body.append(field)
+
+
+def _generate_from_feature(feature: Feature, classdef: ClassDef):
+    if isinstance(feature, Containment):
+        _generate_from_containment(feature, classdef)
+    elif isinstance(feature, Reference):
+        field_name = feature.get_name()
+        if field_name in keyword.kwlist:
+            field_name = f"{field_name}_"
+        type = f"ReferenceByName[{feature.get_type().get_name()}]"
+        if feature.is_optional():
+            type = f"Optional[{type}]"
+        field = ast.AnnAssign(
+            target=ast.Name(id=field_name, ctx=ast.Store()),
+            annotation=ast.Constant(value=type),
+            value=None,
+            simple=1,
+        )
+        if len(classdef.body) == 1 and isinstance(classdef.body[0], ast.Pass):
+            classdef.body = []
+        classdef.body.append(field)
+    elif isinstance(feature, Property):
+        field_name = feature.get_name()
+        if field_name in keyword.kwlist:
+            field_name = f"{field_name}_"
+        type = feature.get_type().get_name()
+        if feature.is_optional():
+            type = f"Optional[{type}]"
+        field = ast.AnnAssign(
+            target=ast.Name(id=field_name, ctx=ast.Store()),
+            annotation=ast.Constant(value=type),
+            value=None,
+            simple=1,
+        )
+        if len(classdef.body) == 1 and isinstance(classdef.body[0], ast.Pass):
+            classdef.body = []
+        classdef.body.append(field)
+    else:
+        raise ValueError()
+
+
+def _generate_from_concept(classifier: Concept) -> ClassDef:
+    bases = []
+    if classifier.get_extended_concept().id == StarLasuBaseLanguage.get_astnode(LionWebVersion.V2023_1).id:
+        if len(classifier.get_implemented()) == 0:
+            bases.append('Node')
+    else:
+        bases.append(classifier.get_extended_concept().get_name())
+    special_interfaces = {
+        'com-strumenta-StarLasu-Expression-id': 'StarLasuExpression',
+        'com-strumenta-StarLasu-Statement-id': 'StarLasuStatement',
+        'com-strumenta-StarLasu-PlaceholderElement-id': 'StarLasuPlaceholderElement',
+        'com-strumenta-StarLasu-Parameter-id': 'StarLasuParameter',
+        'com-strumenta-StarLasu-Documentation-id': 'StarLasuDocumentation',
+        'com-strumenta-StarLasu-BehaviorDeclaration-id': 'StarLasuBehaviorDeclaration',
+        'com-strumenta-StarLasu-EntityDeclaration-id': 'StarLasuEntityDeclaration',
+        'LionCore-builtins-INamed': 'StarLasuNamed'
+    }
+    for i in classifier.get_implemented():
+        if i.get_id() in special_interfaces:
+            bases.append(special_interfaces[i.get_id()])
+        else:
+            bases.append(i.get_name())
+    # if classifier.is_abstract():
+    #    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])
+
+    for feature in classifier.get_features():
+        _generate_from_feature(feature, classdef)
+
+    return classdef
+
+
 def ast_generation(click, language: Language, output):
     import_abc = ast.ImportFrom(
         module='abc',
@@ -126,98 +226,12 @@ def ast_generation(click, language: Language, output):
 
     for classifier in sorted_classifier:
         if isinstance(classifier, Concept):
-            bases = []
-            if classifier.get_extended_concept().id == StarLasuBaseLanguage.get_astnode(LionWebVersion.V2023_1).id:
-                bases.append('Node')
-            else:
-                bases.append(classifier.get_extended_concept().get_name())
-            for i in classifier.get_implemented():
-                if i.get_id() == 'com-strumenta-StarLasu-Expression-id':
-                    bases.append('StarLasuExpression')
-                elif i.get_id() == 'com-strumenta-StarLasu-Statement-id':
-                    bases.append('StarLasuStatement')
-                elif i.get_id() == 'com-strumenta-StarLasu-PlaceholderElement-id':
-                    bases.append('StarLasuPlaceholderElement')
-                elif i.get_id() == 'com-strumenta-StarLasu-Parameter-id':
-                    bases.append('StarLasuParameter')
-                elif i.get_id() == 'com-strumenta-StarLasu-Documentation-id':
-                    bases.append('StarLasuDocumentation')
-                elif i.get_id() == 'com-strumenta-StarLasu-TypeAnnotation-id':
-                    bases.append('StarLasuTypeAnnotation')
-                elif i.get_id() == 'com-strumenta-StarLasu-BehaviorDeclaration-id':
-                    bases.append('StarLasuBehaviorDeclaration')
-                elif i.get_id() == 'com-strumenta-StarLasu-EntityDeclaration-id':
-                    bases.append('StarLasuEntityDeclaration')
-                elif i.get_id() == 'LionCore-builtins-INamed':
-                    bases.append('StarLasuNamed')
-                else:
-                    bases.append(i.get_name())
-            if classifier.is_abstract():
-                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])
-
-            for feature in classifier.get_features():
-                if isinstance(feature, Containment):
-                    field_name = calculate_field_name(feature)
-                    type = feature.get_type().get_name()
-                    if feature.is_multiple():
-                        type = f"List[{type}]"
-                    elif feature.is_optional():
-                        type = f"Optional[{type}]"
-                    field = ast.AnnAssign(
-                        target=ast.Name(id=field_name, ctx=ast.Store()),
-                        annotation=ast.Constant(value=type),
-                        value=None,
-                        simple=1,
-                    )
-                    if len(classdef.body) == 1 and isinstance(classdef.body[0], ast.Pass):
-                        classdef.body = []
-                    classdef.body.append(field)
-                elif isinstance(feature, Reference):
-                    field_name = feature.get_name()
-                    if field_name in keyword.kwlist:
-                        field_name = f"{field_name}_"
-                    type = f"ReferenceByName[{feature.get_type().get_name()}]"
-                    if feature.is_optional():
-                        type = f"Optional[{type}]"
-                    field = ast.AnnAssign(
-                        target=ast.Name(id=field_name, ctx=ast.Store()),
-                        annotation=ast.Constant(value=type),
-                        value=None,
-                        simple=1,
-                    )
-                    if len(classdef.body) == 1 and isinstance(classdef.body[0], ast.Pass):
-                        classdef.body = []
-                    classdef.body.append(field)
-                elif isinstance(feature, Property):
-                    field_name = feature.get_name()
-                    if field_name in keyword.kwlist:
-                        field_name = f"{field_name}_"
-                    type = feature.get_type().get_name()
-                    if feature.is_optional():
-                        type = f"Optional[{type}]"
-                    field = ast.AnnAssign(
-                        target=ast.Name(id=field_name, ctx=ast.Store()),
-                        annotation=ast.Constant(value=type),
-                        value=None,
-                        simple=1,
-                    )
-                    if len(classdef.body) == 1 and isinstance(classdef.body[0], ast.Pass):
-                        classdef.body = []
-                    classdef.body.append(field)
-                else:
-                    raise ValueError()
-
-            module.body.append(classdef)
+            module.body.append(_generate_from_concept(classifier))
         elif isinstance(classifier, Interface):
             bases = []
             if len(classifier.get_extended_interfaces()) == 0:
                 bases.append("Node")
-                bases.append("ABC")
+                # bases.append("ABC")
 
             classdef = ast.ClassDef(classifier.get_name(), bases=bases,
                                     keywords=[],
@@ -232,4 +246,4 @@ def ast_generation(click, language: Language, output):
     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)
+        f.write(generated_code)

pylasu/lionweb/deserializer_generation.py

@@ -1,17 +1,11 @@
 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 import Language, Concept
 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, calculate_field_name
 
 
@@ -32,6 +26,7 @@ def make_cond(enumeration_name: str, member_name: str):
         ]
     )
 
+
 # The return: return AssignmentType.Add
 def make_return(enumeration_name: str, member_name: str):
     return ast.Return(
@@ -42,6 +37,7 @@ def make_return(enumeration_name: str, member_name: str):
         )
     )
 
+
 def generate_register_deserializers_func(language: Language) -> ast.FunctionDef:
     fd = ast.FunctionDef(
         name="register_deserializers",
@@ -100,6 +96,7 @@ def generate_register_deserializers_func(language: Language) -> ast.FunctionDef:
             ))
     return fd
 
+
 def generate_concept_deserializer(concept: Concept) -> ast.FunctionDef:
     constructor_assignments = []
     for f in concept.all_features():
@@ -132,6 +129,7 @@ def generate_concept_deserializer(concept: Concept) -> ast.FunctionDef:
         returns=ast.Name(id=concept.get_name(), ctx=ast.Load())
     )
 
+
 def deserializer_generation(click, language: Language, output):
     import_abc = ast.ImportFrom(
         module='abc',
@@ -172,13 +170,15 @@ def deserializer_generation(click, language: Language, output):
         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)],
+        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)],
+        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(
@@ -256,4 +256,4 @@ def deserializer_generation(click, language: Language, 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)
+        f.write(generated_code)

pylasu/lionweb/generator.py

@@ -34,4 +34,4 @@ def main(dependencies, lionweb_language, output):
 
 
 if __name__ == "__main__":
-    main()
+    main()