Use instances instead of structs for object instantiations

Author: maxhoerstr

pfdl_scheduler/model/instance.py

@@ -7,7 +7,7 @@
 """Contains Instance class."""
 
 # standard libraries
-import uuid
+import copy
 from numbers import Number
 from typing import Dict, Union
 
@@ -16,6 +16,8 @@
 
 # local sources
 ## PFDL base sources
+from pfdl_scheduler.model.array import Array
+from pfdl_scheduler.pfdl_base_classes import PFDLBaseClasses
 from pfdl_scheduler.validation.error_handler import ErrorHandler
 
 
@@ -56,39 +58,61 @@ def __init__(
         self.context: ParserRuleContext = context
         self.attribute_contexts: Dict = {}
 
+    def __deepcopy__(self, memo):
+        cls = self.__class__
+        result = cls.__new__(cls)
+        memo[id(self)] = result
+        for attr, value in self.__dict__.items():
+            try:
+                setattr(result, attr, copy.deepcopy(value, memo))
+            except Exception:
+                setattr(result, attr, value)
+        return result
+
     @classmethod
     def from_json(
         cls,
         json_object: Dict,
         error_handler: ErrorHandler,
         struct_context: ParserRuleContext,
-        instance_class="Instance",
+        pfdl_base_classes=PFDLBaseClasses,
     ):
-        return parse_json(json_object, error_handler, struct_context, instance_class)
+        return parse_json(json_object, error_handler, struct_context, pfdl_base_classes)
 
 
 def parse_json(
     json_object: Dict,
     error_handler: ErrorHandler,
     instance_context: ParserRuleContext,
-    instance_class=Instance,
+    pfdl_base_classes=PFDLBaseClasses,
 ) -> Instance:
     """Parses the JSON Struct initialization.
 
     Returns:
         An Instance object representing the initialized instance.
     """
-    instance = instance_class()
+    instance = pfdl_base_classes.get_class("Instance")()
     instance.context = instance_context
     for identifier, value in json_object.items():
         if isinstance(value, (int, str, bool)):
             instance.attributes[identifier] = value
         elif isinstance(value, list):
-            if error_handler and instance_context:
-                error_msg = "Array definition in JSON are not supported in the PFDL."
-                error_handler.print_error(error_msg, context=instance_context)
+            array = pfdl_base_classes.get_class("Array")()
+            instance.attributes[identifier] = array
+            for element in value:
+                if isinstance(element, (int, float, str, bool)):
+                    if isinstance(element, bool):
+                        array.type_of_elements = "boolean"
+                    elif isinstance(element, (int, float)):
+                        array.type_of_elements = "number"
+                    else:
+                        array.type_of_elements = "string"
+                    array.append_value(element)
+                elif isinstance(element, dict):
+                    inner_struct = parse_json(element, error_handler)
+                    array.append_value(inner_struct)
         elif isinstance(value, dict):
-            inner_struct = parse_json(value, error_handler, instance_context, instance_class)
+            inner_struct = parse_json(value, error_handler, instance_context, pfdl_base_classes)
             instance.attributes[identifier] = inner_struct
 
     return instance

pfdl_scheduler/model/service.py

@@ -14,6 +14,7 @@
 from antlr4.ParserRuleContext import ParserRuleContext
 
 # local sources
+from pfdl_scheduler.model.instance import Instance
 from pfdl_scheduler.model.struct import Struct
 from pfdl_scheduler.model.array import Array
 
@@ -36,7 +37,7 @@ class Service:
     def __init__(
         self,
         name: str = "",
-        input_parameters: List[Union[str, List[str], Struct]] = None,
+        input_parameters: List[Union[str, List[str], Instance]] = None,
         output_parameters: Dict[str, Union[str, Array]] = None,
         context: ParserRuleContext = None,
     ) -> None:
@@ -51,9 +52,9 @@ def __init__(
         self.name: str = name
 
         if input_parameters:
-            self.input_parameters: List[Union[str, List[str], Struct]] = input_parameters
+            self.input_parameters: List[Union[str, List[str], Instance]] = input_parameters
         else:
-            self.input_parameters: List[Union[str, List[str], Struct]] = []
+            self.input_parameters: List[Union[str, List[str], Instance]] = []
 
         if output_parameters:
             self.output_parameters: OrderedDict[str, Union[str, Array]] = output_parameters

pfdl_scheduler/model/struct.py

@@ -9,7 +9,7 @@
 # standard libraries
 import copy
 from dataclasses import dataclass
-from typing import Dict, Union
+from typing import Dict, Type, Union
 import json
 
 # 3rd party libraries
@@ -91,7 +91,11 @@ def __deepcopy__(self, memo):
 
     @classmethod
     def from_json(
-        cls, json_string: str, error_handler: ErrorHandler, struct_context: ParserRuleContext
+        cls,
+        json_string: str,
+        error_handler: ErrorHandler,
+        struct_context: ParserRuleContext,
+        struct_class: Type,
     ) -> "Struct":
         """Creates a Struct instance out of the given JSON string.
 
@@ -103,24 +107,28 @@ def from_json(
             The Struct which was created from the JSON string.
         """
         json_object = json.loads(json_string)
-        struct = parse_json(json_object, error_handler, struct_context)
+        struct = parse_json(json_object, error_handler, struct_context, struct_class)
         return struct
 
 
 def parse_json(
-    json_object: Dict, error_handler: ErrorHandler, struct_context: ParserRuleContext
+    json_object: Dict,
+    error_handler: ErrorHandler,
+    struct_context: ParserRuleContext,
+    struct_class: Type,
 ) -> Struct:
     """Parses the JSON Struct initialization.
 
     Args:
         json_object: A JSON object describing the Struct.
         error_handler: An ErrorHandler instance used for printing errors.
         struct_context: The ANTLR struct context the struct corresponds to.
+        struct_class: The class of the struct from which the struct object is created.
 
     Returns:
         A Struct object representing the initialized Struct.
     """
-    struct = Struct()
+    struct = struct_class()
     struct.context = struct_context
 
     for identifier, value in json_object.items():
@@ -140,9 +148,9 @@ def parse_json(
                         array.type_of_elements = "string"
                     array.append_value(element)
                 elif isinstance(element, dict):
-                    inner_struct = parse_json(element, error_handler, struct_context)
+                    inner_struct = parse_json(element, error_handler, struct_context, struct_class)
                     array.append_value(inner_struct)
         elif isinstance(value, dict):
-            inner_struct = parse_json(value, error_handler, struct_context)
+            inner_struct = parse_json(value, error_handler, struct_context, struct_class)
             struct.attributes[identifier] = inner_struct
     return struct

pfdl_scheduler/parser/pfdl_tree_visitor.py

@@ -7,6 +7,7 @@
 """Contains PFDLTreeVisitor class."""
 
 # standard libraries
+import json
 from typing import Dict, List, OrderedDict, Tuple, Union
 from pfdl_scheduler.model.instance import Instance
 from pfdl_scheduler.pfdl_base_classes import PFDLBaseClasses
@@ -213,7 +214,7 @@ def visitInstance(self, ctx: PFDLParser.InstanceContext) -> Instance:
                     attribute_value,
                     self.error_handler,
                     ctx,
-                    self.pfdl_base_classes.get_class("Instance"),
+                    self.pfdl_base_classes,
                 )
             instance.attributes[attribute_name] = attribute_value
             instance.attribute_contexts[attribute_name] = attribute_assignment_ctx
@@ -294,12 +295,15 @@ def visitCall_input(
         self, ctx: PFDLParser.Call_inputContext
     ) -> List[Union[str, List[str], Struct]]:
         input_params = []
-        for child in ctx.parameter():
-            parameter = self.visitParameter(child)
-            input_params.append(parameter)
-        for child in ctx.struct_initialization():
-            struct = self.visitStruct_initialization(child)
-            input_params.append(struct)
+        for child in ctx.children:
+            if isinstance(child, self.pfdl_base_classes.get_class("PFDLParser").ParameterContext):
+                parameter = self.visitParameter(child)
+                input_params.append(parameter)
+            elif isinstance(
+                child, self.pfdl_base_classes.get_class("PFDLParser").Struct_initializationContext
+            ):
+                instance = self.visitStruct_initialization(child)
+                input_params.append(instance)
         return input_params
 
     def visitCall_output(self, ctx: PFDLParser.Call_outputContext) -> Dict[str, Union[str, Array]]:
@@ -320,15 +324,18 @@ def visitParameter(self, ctx: PFDLParser.ParameterContext) -> Union[str, List[st
             return ctx.STARTS_WITH_LOWER_C_STR().getText()
         return self.visitAttribute_access(ctx.attribute_access())
 
-    def visitStruct_initialization(self, ctx: PFDLParser.Struct_initializationContext) -> Struct:
+    def visitStruct_initialization(self, ctx: PFDLParser.Struct_initializationContext) -> Instance:
         json_string = ctx.json_object().getText()
 
-        struct = self.pfdl_base_classes.get_class("Struct").from_json(
-            json_string, self.error_handler, ctx.json_object()
+        instance = self.pfdl_base_classes.get_class("Instance").from_json(
+            json.loads(json_string),
+            self.error_handler,
+            ctx.json_object(),
+            self.pfdl_base_classes,
         )
-        struct.name = ctx.STARTS_WITH_UPPER_C_STR().getText()
-        struct.context = ctx
-        return struct
+        instance.name = ctx.STARTS_WITH_UPPER_C_STR().getText()
+        instance.context = ctx
+        return instance
 
     def visitTask_call(self, ctx: PFDLParser.Task_callContext) -> TaskCall:
         task_call = self.pfdl_base_classes.get_class("TaskCall")()

pfdl_scheduler/validation/semantic_error_checker.py

@@ -577,7 +577,7 @@ def check_call_input_parameters(
         valid = True
 
         for input_parameter in called_entity.input_parameters:
-            if isinstance(input_parameter, self.pfdl_base_classes.get_class("Struct")):
+            if isinstance(input_parameter, self.pfdl_base_classes.get_class("Instance")):
                 if not self.check_instantiated_struct_attributes(input_parameter):
                     valid = False
             elif isinstance(input_parameter, list):
@@ -660,7 +660,7 @@ def check_call_output_parameters(self, called_entity: Union[Service, TaskCall])
                 valid = False
         return valid
 
-    def check_instantiated_struct_attributes(self, struct_instance: Struct) -> bool:
+    def check_instantiated_struct_attributes(self, instance: Instance) -> bool:
         """Calls multiple check methods to validate an instantiated Struct.
 
         Multiple Checks are done:
@@ -670,25 +670,26 @@ def check_instantiated_struct_attributes(self, struct_instance: Struct) -> bool:
             (4) Check if attributes in the instance do not match with attributes in the definition.
 
         Args:
-            struct_instance: The instantiated struct that is checked.
+            instance: The instantiated struct that is checked.
 
         Returns:
             True if the instantiated Struct is valid.
         """
         valid = True
-        if self.check_if_struct_exists(struct_instance):
-            struct_definition = self.structs[struct_instance.name]
+        if self.check_if_struct_exists(instance):
+            struct_definition = self.structs[instance.name]
 
-            if not self.check_for_missing_attribute_in_struct(struct_instance, struct_definition):
+            if not self.check_for_missing_attribute_in_struct(instance, struct_definition):
                 valid = False
 
-            for identifier in struct_instance.attributes:
+            # Create a copy of the struct instance attributes and remove default attributes
+            for identifier in instance.attributes:
                 if not (
                     self.check_for_unknown_attribute_in_struct(
-                        struct_instance, identifier, struct_definition
+                        instance, identifier, struct_definition
                     )
-                    and self.check_for_wrong_attribute_type_in_struct(
-                        struct_instance, identifier, struct_definition
+                    and self.check_for_wrong_attribute_type_in_instance(
+                        instance, identifier, struct_definition
                     )
                 ):
                     valid = False
@@ -732,7 +733,7 @@ def check_for_unknown_attribute_in_struct(
             return False
         return True
 
-    def check_for_wrong_attribute_type_in_struct(
+    def check_for_wrong_attribute_type_in_instance(
         self, struct_instance: Struct, identifier: str, struct_definition: Struct
     ) -> bool:
         """Calls check methods for the attribute assignments in an instantiated Struct.
@@ -757,7 +758,7 @@ def check_for_wrong_attribute_type_in_struct(
                     struct_def = self.structs[correct_attribute_type]
                     struct_correct = True
                     for identifier in attribute.attributes:
-                        if not self.check_for_wrong_attribute_type_in_struct(
+                        if not self.check_for_wrong_attribute_type_in_instance(
                             attribute, identifier, struct_def
                         ):
                             struct_correct = False

tests/unit_test/model/test_struct.py

@@ -71,7 +71,9 @@ def test_struct_from_json(self):
         context = ParserRuleContext()
 
         json_string = '{"attr1": "value1", "attr2": [1, 2, 3], "attr3": {"attr4": "value4"}}'
-        struct = Struct.from_json(json_string, ErrorHandler("", False), context)
+        struct = Struct.from_json(
+            json_string, ErrorHandler("", False), context, struct_class=Struct
+        )
         self.assertEqual(struct.name, "")
 
         attributes = {
@@ -88,7 +90,7 @@ def test_parse_json(self):
         context = ParserRuleContext()
 
         # empty
-        struct = parse_json({}, ErrorHandler("", False), context)
+        struct = parse_json({}, ErrorHandler("", False), context, Struct)
         self.assertEqual(struct.name, "")
         self.assertEqual(struct.attributes, {})
         self.assertEqual(struct.context, context)
@@ -97,7 +99,10 @@ def test_parse_json(self):
         # simple attributes
         attributes = {"attr1": "value1", "attr2": 123, "attr3": True}
         struct = parse_json(
-            {"attr1": "value1", "attr2": 123, "attr3": True}, ErrorHandler("", False), context
+            {"attr1": "value1", "attr2": 123, "attr3": True},
+            ErrorHandler("", False),
+            context,
+            Struct,
         )
         self.assertEqual(struct.name, "")
 
@@ -114,7 +119,7 @@ def test_parse_json(self):
             "attr7": {"attr8": {"attr9": True}},
             "attr10": [True, True, False],
         }
-        struct = parse_json(struct_dict, ErrorHandler("", False), None)
+        struct = parse_json(struct_dict, ErrorHandler("", False), None, Struct)
         self.assertEqual(struct.name, "")
         self.assertEqual(
             struct.attributes,
@@ -144,7 +149,7 @@ def test_parse_json(self):
                 },
             ]
         }
-        struct = parse_json(struct_dict, ErrorHandler("", False), None)
+        struct = parse_json(struct_dict, ErrorHandler("", False), None, Struct)
         self.assertEqual(struct.name, "")
         array = Array("", [Struct("", {"attr2": 5}), Struct("", {"attr3": "string"})])
         self.assertEqual(struct.attributes, {"attr1": array})