Primitives, enum and CIM_datatype

.gitignore

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

cimgen/languages/modernpython/lang_pack.py

@@ -1,6 +1,7 @@
 import logging
 import os
 import re
+import ast
 from distutils.dir_util import copy_tree
 from pathlib import Path
 from importlib.resources import files
@@ -35,9 +36,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"}]
+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"}
+enum_template_files = {"filename": "enum_class_template.mustache", "ext": ".py"}
+primitive_template_files = {"filename": "primitive_template.mustache", "ext": ".py"}
+cimdatatype_template_files = {"filename": "cimdatatype_template.mustache", "ext": ".py"}
 
 
 def get_class_location(class_name, class_map, version):  # NOSONAR
@@ -76,23 +80,124 @@ 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 _set_attribute_class(text, render) -> str:
+    attribute = eval(render(text))
+    attribute_class = ""
+    if attribute["is_datatype_attribute"] or attribute["is_primitive_attribute"]:
+        attribute_class += "\n            "
+        attribute_class += """"attribute_class": """ + attribute["attribute_class"] + ","
+    return attribute_class
+
+
+# called by chevron, text contains the label {{dataType}}, which is evaluated by the renderer (see class template)
+def _set_instances(text, render):
+    instance = None
+    instance = ast.literal_eval(render(text).replace(""", '"'))
+    if "label" in instance:
+        value = instance["label"] + ' = "' + instance["label"] + '"'
+        if "comment" in instance:
+            value += "  # " + instance["comment"] + " noqa: E501"
+        return value
+    else:
+        return ""
+
+
 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_files
+        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 = cimdatatype_template_files
+        class_details.update(_set_datatype_attributes(class_details["attributes"]))
+    elif class_details["is_an_enum_class"]:
+        template = enum_template_files
+        class_details["setInstances"] = _set_instances
+    else:
+        template = template_files
         class_details["setDefault"] = _set_default
         class_details["setType"] = _set_type
-        _write_templated_file(resource_file, class_details, template_info["filename"])
+        class_details["setAttributeClass"] = _set_attribute_class
+        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 resource_file
 
 
 def _write_templated_file(class_file, class_details, template_filename):
@@ -109,17 +214,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_files["ext"])
+    class_details = {"cim_namespace": cim_namespace}
+    _write_templated_file(class_file, class_details, constants_template_files["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_files["ext"])
+    class_details = {"profiles": profile_details}
+    _write_templated_file(class_file, class_details, profile_template_files["filename"])
 
 
 def resolve_headers(path: str, version: str):

cimgen/languages/modernpython/templates/cimdatatype_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/cimpy_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}}):
     """
@@ -36,7 +35,7 @@ class {{class_name}}({{sub_class_of}}):
             "is_datatype_attribute": {{#is_datatype_attribute}}True{{/is_datatype_attribute}}{{^is_datatype_attribute}}False{{/is_datatype_attribute}},
             "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_primitive_attribute": {{#is_primitive_attribute}}True{{/is_primitive_attribute}}{{^is_primitive_attribute}}False{{/is_primitive_attribute}},{{#setAttributeClass}}{{.}}{{/setAttributeClass}}
         },
     )
 

cimgen/languages/modernpython/templates/enum_class_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}}}
+    """
+
+    {{#enum_instances}}
+    {{#setInstances}}{{.}}{{/setInstances}}
+    {{/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/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)