Modify attributes_validation CHECK function to allow 'ref.ref_list_filter.is_type' to accept either a string or an array of strings as a schema input

Author: cwang39403

.vscode/launch.json

@@ -0,0 +1,15 @@
+{
+    // Use IntelliSense to learn about possible attributes.
+    // Hover to view descriptions of existing attributes.
+    // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
+    "version": "0.2.0",
+    "configurations": [
+        {
+            "name": "Python Debugger: Current File",
+            "type": "debugpy",
+            "request": "launch",
+            "program": "${file}",
+            "console": "integratedTerminal"
+        }
+    ]
+}

README.md

@@ -431,7 +431,7 @@ and return a result (for every entry) which will be returned by the service, che
 errors based on how the check is configured in the validation schema. New functions can be added easily, by
 adding ```@FunctionFactory.register``` to the class, giving it a name and extending the appropriate function type the
 function will be discovered automatically by the FunctionFactory. To use a function simply reference the function by
-it's name in the validation schema i.e ```"function": "not_null"```
+it's name in the validation schema i.e ```"function": "attributes_validation"```
 
 #### Select
 

esdlvalidator/validation/functions/check_attributes_not_null_or_valid.py

@@ -78,7 +78,15 @@ def get_function_definition(self):
                         "type": "object",
                         "required": ["is_type"],
                         "properties": {
-                            "is_type": {"type": "string"},
+                            "is_type": {
+                                "anyOf": [
+                                    {"type": "string"},
+                                    {
+                                        "type": "array",
+                                        "items": {"type": "string"}
+                                    }
+                                ]
+                            },
                             "match": {
                                 "type": "object",
                                 "description": "Optional attribute filters",
@@ -192,8 +200,17 @@ def _resolve_reference(self, entity: object, ref: dict, results: list):
             if entity_to_check is None:
                 match_str = ", ".join(f"[{k}] = '{v}'" for k, v in ref["ref_list_filter"].get("match", {}).items())
                 match_str = f" ({match_str})" if match_str else ""
+                
+                ref_type = ref['ref_list_filter']['is_type']
+                type_list = ref_type if isinstance(ref_type, list) else [ref_type]
+                # Join with " or " for readability
+                if len(type_list) == 1:
+                    type_str = type_list[0]
+                else:
+                    type_str = " or ".join(type_list)
+                
                 results.append(
-                    f"[{ref_path}] should contain a [{ref['ref_list_filter']['is_type']}]{match_str}, but not found."
+                    f"[{ref_path}] should contain a [{type_str}]{match_str}, but not found."
                 )
             return entity_to_check
 

esdlvalidator/validation/functions/check_reference_attributes_comparison.py

@@ -156,6 +156,7 @@ def _resolve_reference(self, entity: object, ref: dict, results: list):
 
         if isinstance(reference, EOrderedSet):
             if len(reference) > 1 and ref.get("ref_list_filter"):
+                # NOTE: Only the first matching entity is returned.
                 entity_to_check = utils.get_ref(reference, ref["ref_list_filter"])
             else:
                 entity_to_check = reference[0]

esdlvalidator/validation/functions/utils.py

@@ -54,12 +54,21 @@ def get_ref(references: EOrderedSet, ref_filter: dict):
     Returns:
         The first matching entity, or None if no match is found.
     """
-    ref_type = ref_filter["is_type"]
+    raw_types = ref_filter["is_type"]
     match_dict = ref_filter.get("match", {})
-    esdl_type = esdlUtils.get_esdl_class_from_string(ref_type)[0]
+
+    if isinstance(raw_types, str):
+        type_list = [raw_types]
+    else:
+        type_list = list(raw_types)
+
+    esdl_classes = []
+    for t in type_list:
+        esdl_cls = esdlUtils.get_esdl_class_from_string(t)[0]
+        esdl_classes.append(esdl_cls)
 
     for entity in references:
-        if not isinstance(entity, esdl_type):
+        if not any(isinstance(entity, cls) for cls in esdl_classes):
             continue
         if all(get_attr_or_ref_attr(entity, key) == value for key, value in match_dict.items()):
             return entity