Add a util function get_attr_or_ref_attr() for retrieving (nested) attribute value; Improve attributes_not_null function

Author: cwang39403

esdlvalidator/validation/functions/check_attributes_not_null.py

@@ -1,5 +1,12 @@
 from esdlvalidator.validation.functions import utils
-from esdlvalidator.validation.functions.function import FunctionFactory, FunctionCheck, FunctionDefinition, ArgDefinition, FunctionType, CheckResult
+from esdlvalidator.validation.functions.function import (
+    FunctionFactory,
+    FunctionCheck,
+    FunctionDefinition,
+    ArgDefinition,
+    FunctionType,
+    CheckResult,
+)
 
 
 @FunctionFactory.register(FunctionType.CHECK, "attributes_not_null")
@@ -8,11 +15,16 @@ class AttributesNotSet(FunctionCheck):
     def get_function_definition(self):
         return FunctionDefinition(
             "attributes_not_null",
-            "Check if required attributes are all set (not null).",
+            "Check if attributes or nested reference attributes are all set (not as a default value or count_as_null value).",
             [
-                ArgDefinition("checks", "A list of dictionaries with structure as {attribute: str, count_as_null: list[Any]} to be checked", True),
-                ArgDefinition("resultMsgJSON", "Display output in JSON format", False)
-            ]
+                ArgDefinition(
+                    "checks",
+                    "A list of dictionaries with structure as {attribute: str, count_as_null: list[Any]} to be checked" \
+                    "count_as_null can be an empty list.",
+                    True,
+                ),
+                ArgDefinition("resultMsgJSON", "Display output in JSON format", False),
+            ],
         )
 
     def execute(self):
@@ -23,47 +35,40 @@ def execute(self):
 
         if not isinstance(checks, list):
             raise TypeError(f"Invalid function argument. Argument 'checks' should be a list, got {type(checks)}.")
-        
+
         results = []
         for dict in checks:
-            if 'attribute' not in dict or 'count_as_null' not in dict:
+            if "attribute" not in dict or "count_as_null" not in dict:
                 raise ValueError("Missing required keys: 'attribute' and/or 'count_as_null'.")
-            
-            attr = dict['attribute']
-            count_as_null = dict['count_as_null']
+
+            attr = dict["attribute"]
+            count_as_null = dict["count_as_null"]
 
             if not isinstance(attr, str):
                 raise TypeError("'attribute' must be a string")
             if not isinstance(count_as_null, list):
                 raise TypeError("'count_as_null' must be a list")
-        
-            if not utils.has_attribute(value, attr):
-                r = f"Attribute '{attr}' not found."
-                results.append(r)
-            else:
-                # if attribute and value is set, eIsSet() returns True
-                attrValueIsSet = self.value.eIsSet(attr)
 
-                if not attrValueIsSet:
-                    r = f"Attribute value of '{attr}' should be defined."
-                    results.append(r)
-                # Handle the case when attribute value is set, but should still be considered as undefined.
-                else:
-                    attrValue = utils.get_attribute(value, attr)
-
-                    for nullValue in count_as_null:
-                        if (isinstance(nullValue, str) and str(nullValue).lower() == str(attrValue).lower()) \
-                            or (nullValue == attrValue):
-                            # TODO: more explicit message?
-                            r = f"'{attr}' value cannot be null."
-                            results.append(r)
-                            break
+            attr_value = utils.get_attr_or_ref_attr(value, attr)
+            if attr_value == "Not found":
+                raise ValueError(f"Attribute [{attr}] not found.")
+            elif attr_value == "Unset":
+                results.append(f"[{attr}] value should be defined.")
+            else:
+                # Handle the case when attribute value is set, but should still be considered as unset.
+                for nullValue in count_as_null:
+                    if (isinstance(nullValue, str) and str(nullValue).lower() == str(attr_value).lower()) or (
+                        nullValue == attr_value
+                    ):
+                        r = f"[{attr}] value cannot be {nullValue}."
+                        results.append(r)
+                        break
 
         if len(results) > 0:
-            if 'resultMsgJSON' in self.args and self.args['resultMsgJSON']:
-                msg["message"] = "; ".join(results)
+            if "resultMsgJSON" in self.args and self.args["resultMsgJSON"]:
+                msg["message"] = results
                 return CheckResult(False, msg)
             else:
                 return CheckResult(False, results)
         else:
-            return CheckResult(True)
+            return CheckResult(True)

esdlvalidator/validation/functions/utils.py

@@ -3,6 +3,38 @@
 from pyecore.ecore import EValue
 
 
+def get_attr_or_ref_attr(obj, attr_path: str):
+    """
+    Retrieves an attribute value or a nested reference attribute value from an ESDL object.
+
+    Args:
+        obj: The ESDL object to query.
+        attr_path (str): A dot-separated string representing the attribute path.
+                         For instance, 'power' or 'costInformation.investmentCosts.value'.
+                         The attr_path string is case sensitive.
+
+    Returns:
+        The attribute value if found and set.
+        'Not found' if the attribute does not exist.
+        'Unset' if the attribute exists but is not set.
+    """
+    attr, *remaining = attr_path.split(".", 1)
+
+    not_found_keyword = "Not found"
+    if getattr(obj, attr, not_found_keyword) == not_found_keyword:
+        return not_found_keyword
+
+    if not obj.eIsSet(attr):
+        return "Unset"
+
+    value = obj.eGet(attr)
+
+    if not remaining:
+        return value
+
+    return get_attr_or_ref_attr(value, remaining[0])
+
+
 def has_attribute(obj, name: str) -> bool:
     # give a default "nothing_found" since None can be the actual returned value
     result = get_attribute(obj, name, "nothing_found")