Primitives, enum and CIM_datatype

.gitignore

@@ -9,3 +9,4 @@ __pycache__/
 .vscode/*
 */.DS_Store
 .DS_Store
+tests/

cimgen/languages/modernpython/lang_pack.py

@@ -35,9 +35,12 @@ def location(version):  # NOSONAR
 base = {"base_class": "Base", "class_location": location}
 
 # These are the files that are used to generate the python files.
-template_files = [{"filename": "cimpy_class_template.mustache", "ext": ".py"}]
-constants_template_files = [{"filename": "cimpy_constants_template.mustache", "ext": ".py"}]
-profile_template_files = [{"filename": "cimpy_cgmesProfile_template.mustache", "ext": ".py"}]
+class_template_file = {"filename": "class_template.mustache", "ext": ".py"}
+constants_template_file = {"filename": "constants_template.mustache", "ext": ".py"}
+profile_template_file = {"filename": "profile_template.mustache", "ext": ".py"}
+enum_template_file = {"filename": "enum_template.mustache", "ext": ".py"}
+primitive_template_file = {"filename": "primitive_template.mustache", "ext": ".py"}
+datatype_template_file = {"filename": "datatype_template.mustache", "ext": ".py"}
 
 
 def get_class_location(class_name, class_map, version):  # NOSONAR
@@ -76,23 +79,100 @@ def _get_type_and_default(text, render) -> tuple[str, str]:
         return ("str", 'default=""')
 
 
+def _primitive_to_data_type(datatype):
+    if datatype.lower() == "integer":
+        return "int"
+    if datatype.lower() == "float":
+        return "float"
+    if datatype.lower() == "boolean":
+        return "bool"
+    if datatype.lower() == "datetime":
+        return "datetime"
+    if datatype.lower() == "date":
+        return "date"
+    if datatype.lower() == "time":
+        return "time"
+    if datatype.lower() == "monthday":
+        return "str"  # TO BE FIXED? I could not find a datatype in python that holds only month and day.
+    if datatype.lower() == "string":
+        return "str"
+    else:
+        # this actually never happens
+        return "float"
+
+
+def _set_imports(attributes):
+    classes = set()
+    for attribute in attributes:
+        if attribute["is_datatype_attribute"] or attribute["is_primitive_attribute"]:
+            classes.add(attribute["attribute_class"])
+
+    result = ""
+    for val in sorted(classes):
+        result += "from ." + val + " import " + val + "\n"
+    return result + "\n"
+
+
+def _set_datatype_attributes(attributes) -> dict:
+    datatype_attributes = {}
+    datatype_attributes["python_type"] = "None"
+    datatype_attributes["unit"] = "UnitSymbol.none"
+    datatype_attributes["multiplier"] = "UnitMultiplier.none"
+
+    for attribute in attributes:
+        if (
+            "about" in attribute
+            and attribute["about"]
+            and "value" in attribute["about"]
+            and "attribute_class" in attribute
+        ):
+            datatype_attributes["python_type"] = _primitive_to_data_type(attribute["attribute_class"])
+        if (
+            "about" in attribute
+            and attribute["about"]
+            and "multiplier" in attribute["about"]
+            and "isFixed" in attribute
+        ):
+            datatype_attributes["multiplier"] = "UnitMultiplier." + attribute["isFixed"]
+        if "about" in attribute and attribute["about"] and "unit" in attribute["about"] and "isFixed" in attribute:
+            datatype_attributes["unit"] = "UnitSymbol." + attribute["isFixed"]
+    return datatype_attributes
+
+
 def run_template(output_path, class_details):
-    if class_details["is_a_primitive_class"] or class_details["is_a_datatype_class"]:
-        return
-    for template_info in template_files:
-        resource_file = Path(
-            os.path.join(
-                output_path,
-                "resources",
-                class_details["class_name"] + template_info["ext"],
-            )
-        )
-        if not resource_file.exists():
-            if not (parent := resource_file.parent).exists():
-                parent.mkdir()
+    if class_details["is_a_primitive_class"]:
+        # Primitives are never used in the in memory representation but only for
+        # the schema
+        template = primitive_template_file
+        class_details["python_type"] = _primitive_to_data_type(class_details["class_name"])
+    elif class_details["is_a_datatype_class"]:
+        # Datatypes based on primitives are never used in the in memory
+        # representation but only for the schema
+        template = datatype_template_file
+        class_details.update(_set_datatype_attributes(class_details["attributes"]))
+    elif class_details["is_an_enum_class"]:
+        template = enum_template_file
+    else:
+        template = class_template_file
         class_details["setDefault"] = _set_default
         class_details["setType"] = _set_type
-        _write_templated_file(resource_file, class_details, template_info["filename"])
+        class_details["setImports"] = _set_imports(class_details["attributes"])
+    resource_file = _create_file(output_path, class_details, template)
+    _write_templated_file(resource_file, class_details, template["filename"])
+
+
+def _create_file(output_path, class_details, template) -> str:
+    resource_file = Path(
+        os.path.join(
+            output_path,
+            "resources",
+            class_details["class_name"] + template["ext"],
+        )
+    )
+    if not resource_file.exists():
+        if not (parent := resource_file.parent).exists():
+            parent.mkdir()
+    return str(resource_file)
 
 
 def _write_templated_file(class_file, class_details, template_filename):
@@ -109,17 +189,15 @@ def _write_templated_file(class_file, class_details, template_filename):
 
 
 def _create_constants(output_path: str, cim_namespace: str):
-    for template_info in constants_template_files:
-        class_file = os.path.join(output_path, "utils", "constants" + template_info["ext"])
-        class_details = {"cim_namespace": cim_namespace}
-        _write_templated_file(class_file, class_details, template_info["filename"])
+    class_file = os.path.join(output_path, "utils", "constants" + constants_template_file["ext"])
+    class_details = {"cim_namespace": cim_namespace}
+    _write_templated_file(class_file, class_details, constants_template_file["filename"])
 
 
 def _create_cgmes_profile(output_path: str, profile_details: list):
-    for template_info in profile_template_files:
-        class_file = os.path.join(output_path, "utils", "profile" + template_info["ext"])
-        class_details = {"profiles": profile_details}
-        _write_templated_file(class_file, class_details, template_info["filename"])
+    class_file = os.path.join(output_path, "utils", "profile" + profile_template_file["ext"])
+    class_details = {"profiles": profile_details}
+    _write_templated_file(class_file, class_details, profile_template_file["filename"])
 
 
 def resolve_headers(path: str, version: str):

cimgen/languages/modernpython/templates/cimpy_class_template.mustache → cimgen/languages/modernpython/templates/class_template.mustache

@@ -10,8 +10,7 @@ from pydantic.dataclasses import dataclass
 
 from ..utils.profile import BaseProfile, Profile
 from {{class_location}} import {{sub_class_of}}
-
-
+{{setImports}}
 @dataclass
 class {{class_name}}({{sub_class_of}}):
     """
@@ -37,6 +36,12 @@ class {{class_name}}({{sub_class_of}}):
             "is_enum_attribute": {{#is_enum_attribute}}True{{/is_enum_attribute}}{{^is_enum_attribute}}False{{/is_enum_attribute}},
             "is_list_attribute": {{#is_list_attribute}}True{{/is_list_attribute}}{{^is_list_attribute}}False{{/is_list_attribute}},
             "is_primitive_attribute": {{#is_primitive_attribute}}True{{/is_primitive_attribute}}{{^is_primitive_attribute}}False{{/is_primitive_attribute}},
+{{#is_datatype_attribute}}
+            "attribute_class": {{attribute_class}},
+{{/is_datatype_attribute}}
+{{#is_primitive_attribute}}
+            "attribute_class": {{attribute_class}},
+{{/is_primitive_attribute}}
         },
     )
 

cimgen/languages/modernpython/templates/datatype_template.mustache

@@ -0,0 +1,22 @@
+"""
+Generated from the CGMES files via cimgen: https://github.com/sogno-platform/cimgen
+"""
+
+from ..utils.datatypes import CIMDatatype
+from ..utils.profile import Profile
+from .UnitMultiplier import UnitMultiplier
+from .UnitSymbol import UnitSymbol
+
+{{class_name}} = CIMDatatype(
+    name="{{class_name}}",
+    type={{python_type}},
+    symbol={{unit}},
+    multiplier={{multiplier}},
+    profiles=[{{#class_origin}}
+        Profile.{{origin}},{{/class_origin}}
+    ],
+)
+
+"""
+{{{wrapped_class_comment}}}
+"""

cimgen/languages/modernpython/templates/enum_template.mustache

@@ -0,0 +1,15 @@
+"""
+Generated from the CGMES files via cimgen: https://github.com/sogno-platform/cimgen
+"""
+
+from enum import Enum
+
+
+class {{class_name}}(str, Enum):
+    """
+    {{{class_comment}}}  # noqa: E501
+    """
+
+    {{#enum_instances}}
+    {{label}} = "{{label}}"{{#comment}}  # {{comment}}{{/comment}}  # noqa: E501
+    {{/enum_instances}}

cimgen/languages/modernpython/templates/primitive_template.mustache

@@ -0,0 +1,19 @@
+"""
+Generated from the CGMES files via cimgen: https://github.com/sogno-platform/cimgen
+"""
+
+from datetime import date, datetime, time
+from ..utils.datatypes import Primitive
+from ..utils.profile import Profile
+
+{{class_name}} = Primitive(
+    name="{{class_name}}",
+    type={{python_type}},
+    profiles=[{{#class_origin}}
+        Profile.{{origin}},{{/class_origin}}
+    ],
+)
+
+"""
+{{{wrapped_class_comment}}}
+"""

cimgen/languages/modernpython/templates/cimpy_cgmesProfile_template.mustache → cimgen/languages/modernpython/templates/profile_template.mustache

@@ -10,7 +10,7 @@ class BaseProfile(str, Enum):
     """
     Profile parent. Use it if you need your own profiles.
 
-    All pycgmes objects requiring a Profile are actually asking for a `BaseProfile`. As
+    All CGMES objects requiring a Profile are actually asking for a `BaseProfile`. As
     Enum with fields cannot be inherited or composed, just create your own CustomProfile without
     trying to extend Profile. It will work.
     """

cimgen/languages/modernpython/utils/base.py

@@ -6,9 +6,9 @@
 
 from pydantic.dataclasses import dataclass
 
-from pycgmes.utils.constants import NAMESPACES
+from .constants import NAMESPACES
 
-from ..utils.config import cgmes_resource_config
+from .config import cgmes_resource_config
 from .profile import BaseProfile
 
 

cimgen/languages/modernpython/utils/chevron_writer.py

@@ -3,9 +3,9 @@
 
 import chevron
 
-from pycgmes.utils.base import Base
-from pycgmes.utils.constants import NAMESPACES
-from pycgmes.utils.profile import BaseProfile, Profile
+from .base import Base
+from .constants import NAMESPACES
+from .profile import BaseProfile, Profile
 
 
 class ChevronWriter:

cimgen/languages/modernpython/utils/datatypes.py

@@ -0,0 +1,26 @@
+from pydantic import Field
+from typing import List
+
+from .constants import NAMESPACES
+from pydantic.dataclasses import dataclass
+
+from .config import cgmes_resource_config
+from .profile import BaseProfile
+from ..resources.UnitMultiplier import UnitMultiplier
+from ..resources.UnitSymbol import UnitSymbol
+
+
+@dataclass(config=cgmes_resource_config)
+class Primitive:
+
+    name: str = Field(frozen=True)
+    type: object = Field(frozen=True)
+    namespace: str = Field(frozen=True, default=NAMESPACES["cim"])
+    profiles: List[BaseProfile] = Field(frozen=True)
+
+
+@dataclass(config=cgmes_resource_config)
+class CIMDatatype(Primitive):
+
+    multiplier: UnitMultiplier = Field(frozen=True)
+    symbol: UnitSymbol = Field(frozen=True)