Reference class refactoring

- Enable implicit casting between reference types
- Extract reference classes to new submodule

Author: cogu

src/autosar/xml/base.py

@@ -0,0 +1,199 @@
+"""
+AUTOSAR XML base classes
+"""
+
+import abc
+import re
+from typing import Any, Type
+from enum import Enum
+import autosar.xml.enumeration as ar_enum
+
+
+class ARObject:
+    """
+    Base class for all AUTOSAR objects
+    """
+
+    @property
+    def is_empty(self) -> bool:
+        """
+        True if no value has been set (everything is None)
+        """
+        for value in vars(self).values():
+            if isinstance(value, list):
+                if len(value) > 0:
+                    return False
+            else:
+                if value is not None:
+                    return False
+        return True
+
+    def is_empty_with_ignore(self, ignore_set: set) -> bool:
+        """
+        Same as is_empty but the caller can give
+        a list of property names to ignore during
+        check
+        """
+        for key in vars(self).keys():
+            if key not in ignore_set:
+                value = getattr(self, key)
+                if isinstance(value, list):
+                    if len(value) > 0:
+                        return False
+                else:
+                    if value is not None:
+                        return False
+        return True
+
+    def _assign_optional(self, attr_name: str, value: Any, type_name: type) -> None:
+        """
+        Same as _assign but with a None-check
+        """
+        if value is not None:
+            self._assign(attr_name, value, type_name)
+
+    def _assign(self, attr_name: str, value: Any, type_name: type) -> None:
+        """
+        Assign single value to attribute with type check.
+        """
+        if issubclass(type_name, Enum):
+            self._set_attr_with_strict_type(attr_name, value, type_name)
+        elif issubclass(type_name, BaseRef):
+            self._check_and_set_reference(attr_name, value, type_name)
+        else:
+            self._set_attr_with_type_cast(attr_name, value, type_name)
+
+    def _assign_int_or_str_pattern_optional(self, attr_name: str, value: int | str | None, pattern: re.Pattern) -> None:
+        """
+        Same as _assign_int_or_str_pattern but with a None-check
+        """
+        if value is not None:
+            self._assign_int_or_str_pattern(attr_name, value, pattern)
+
+    def _assign_int_or_str_pattern(self, attr_name: str, value: int | str, pattern: re.Pattern) -> None:
+        """
+        Special assignment-function for values that can be either int or conforms
+        to a specific regular expression
+        """
+        if isinstance(value, int):
+            pass
+        elif isinstance(value, str):
+            match = pattern.match(value)
+            if match is None:
+                raise ValueError(f"Invalid parameter '{value}' for '{attr_name}'")
+        else:
+            raise TypeError(f"{attr_name}: Invalid type. Expected (int, str), got '{str(type(value))}'")
+        setattr(self, attr_name, value)
+
+    def _assign_optional_strict(self, attr_name: str, value: Any, type_name: type) -> None:
+        """
+        Sets object attribute with strict type check
+        """
+        if value is not None:
+            self._set_attr_with_strict_type(attr_name, value, type_name)
+
+    def _assign_optional_positive_int(self, attr_name, value: int) -> None:
+        """
+        Checks that the optional value is a positive integer before assignment
+        """
+        if value is not None:
+            self._set_attr_positive_int(attr_name, value)
+
+    def _set_attr_with_strict_type(self, attr_name: str, value: Any, type_class: type) -> None:
+        """
+        Sets object attribute only if the value is matches given type-class
+        """
+        if isinstance(value, type_class):
+            setattr(self, attr_name, value)
+        else:
+            raise TypeError(
+                f"Invalid type for parameter '{attr_name}'. Expected type {str(type_class)}, got {str(type(value))}")
+
+    def _check_and_set_reference(self, attr_name: str, value: Any, ref_type: Type["BaseRef"]):
+        """
+        Checks reference type compatibility and on success updates the value
+        """
+        accepted_sub_types: set = ref_type.accepted_sub_types()
+        if (len(accepted_sub_types) == 0) or not isinstance(accepted_sub_types, set):
+            msg = f"Error in reference type '{str(type(ref_type))}', it doesn't seem to have a valid set of sub-types."
+            raise RuntimeError(msg)
+        if isinstance(value, str):
+            if len(accepted_sub_types) == 1:
+                new_value = ref_type(value, list(accepted_sub_types)[0])
+            else:
+                raise TypeError("Ambigious value for DEST. Unable to create reference directly from string")
+        elif isinstance(value, BaseRef):
+            if type(value) is ref_type or value.dest in accepted_sub_types:  # pylint: disable=C0123
+                new_value = ref_type(value.value, value.dest)
+            else:
+                raise TypeError(f"'{attr_name}': Reference type {str(type(value))}"
+                                f"isn't combatible with {str(ref_type)}")
+        else:
+            raise TypeError(f"'{attr_name}': Invalid type. "
+                            f"Expected one of (str, {str(ref_type)}), got '{str(type(value))}'")
+        setattr(self, attr_name, new_value)
+
+    def _set_attr_with_type_cast(self, attr_name: str, value: Any, type_class: type) -> None:
+        """
+        Sets object attribute only if it can be converted to given type.
+        """
+        if type_class in {bool, int, str, float}:
+            new_value = type_class(value)
+        else:
+            raise NotImplementedError(type_class)
+        setattr(self, attr_name, new_value)
+
+    def _set_attr_positive_int(self, attr_name: str, value: int) -> None:
+        """
+        Checks that value is non-negative before updating attribute
+        """
+        if not isinstance(value, int):
+            raise TypeError(f"Invalid type for '{attr_name}'. Expected int, got '{str(type(value))}'")
+        if value < 0:
+            raise ValueError(f"Positive integer expected: {value}")
+        setattr(self, attr_name, value)
+
+    def _find_by_name(self, elements: list, name: str):
+        """
+        Iterates through list of elements and return the first whose
+        name matches the name argument
+        """
+        for elem in elements:
+            if elem.name == name:
+                return elem
+        return None
+
+
+class BaseRef(ARObject, abc.ABC):
+    """
+    Base type for all reference classes
+    """
+
+    def __init__(self,
+                 value: str,
+                 dest: ar_enum.IdentifiableSubTypes = None) -> None:
+        self.value = value
+        self.dest: ar_enum.IdentifiableSubTypes = None
+        if dest is None:
+            if len(self.accepted_sub_types()) == 1:
+                dest = list(self.accepted_sub_types())[0]
+            else:
+                msg_part1 = "Value of dest cannot be None. Accepted values are: "
+                msg_part2 = ",".join([str(x) for x in sorted(list(self.accepted_sub_types()))])
+                raise ValueError(msg_part1 + msg_part2)
+        if dest in self.accepted_sub_types():
+            self.dest = dest
+        else:
+            raise ValueError(f"{str(dest)} is not a valid sub-type for {str(type(self))}")
+
+    @classmethod
+    @abc.abstractmethod
+    def accepted_sub_types(cls) -> list[ar_enum.IdentifiableSubTypes]:
+        """
+        Subset of ar_enum.IdentifiableSubTypes defining
+        which enum values are acceptable for dest
+        """
+
+    def __str__(self) -> str:
+        """Returns reference as string"""
+        return self.value