Deprecate types that have moved to fprime-gds repo (nasa#296)

* Allow StringType to use configurable SizeStore type

* Migrate types away and import for backwards compatibility

* Move fprime_gds imports to try/catch blocks

* remove TimeBase import

* Remove tests from deprecated types

* remove unused DATA_ENCODING constant

Author: thomas-bc

src/fprime/common/models/serialize/__init__.py

@@ -1,16 +1,7 @@
-"""Python implementations of built-in fprime types
+import warnings
 
-This package provides the modules necessary for the representation of fprime types (Fw/Types) package in a Python
-context. These standard types are represented as Python classes representing each individual type.
-
-Example:
-    U32 is represented by fprime.common.modules.serialize.numerical_types.U32Type
-
-Special autocoded types are represented by configurable classes: ArrayType, SerializableType, and EnumType. These
-represent a generic version of these classes whose designed properties are set as dynamic properties on the python
-class itself.
-
-Example:
-    Serializables are represented by fprime.common.modules.serialize.serializable_type.SerializableType
-    SerializableType(typename="MySerializable") is used to specify the Ai serializable's name
-"""
+warnings.warn(
+    "Ground type system has been migrated to the fprime-gds package, in fprime_gds.common.models.serialize. Change your imports accordingly.",
+    DeprecationWarning,
+    stacklevel=2,
+)

src/fprime/common/models/serialize/array_type.py

@@ -4,133 +4,20 @@
 @author: jishii
 """
 
-from .type_base import DictionaryType
-from .type_exceptions import (
-    ArrayLengthException,
-    NotInitializedException,
-    TypeMismatchException,
-    DeserializeException,
-)
-
-
-class ArrayType(DictionaryType):
-    """Generic fixed-size array type representation.
-
-    Represents a custom named type of a fixed number of like members, each of which are other types in the system.
-    """
-
-    @classmethod
-    def construct_type(cls, name, member_type, length, format):
-        """Constructs a sub-array type
-
-        Constructs a new sub-type of array to represent an array of the given name, member type, length, and format
-        string.
-
-        Args:
-            name: name of the array subtype
-            member_type: type of the members of the array subtype
-            length: length of the array subtype
-            format: format string for members of the array subtype
-        """
-        return DictionaryType.construct_type(
-            cls, name, MEMBER_TYPE=member_type, LENGTH=length, FORMAT=format
-        )
-
-    @classmethod
-    def validate(cls, val):
-        """Validates the values of the array"""
-        if not isinstance(val, (tuple, list)):
-            raise TypeMismatchException(list, type(val))
-        if len(val) != cls.LENGTH:
-            raise ArrayLengthException(cls.MEMBER_TYPE, cls.LENGTH, len(val))
-        for i in range(cls.LENGTH):
-            cls.MEMBER_TYPE.validate(val[i])
-
-    @property
-    def val(self) -> list:
-        """
-        The .val property typically returns the python-native type. This the python native type closes to a serializable
-        without generating full classes would be a dictionary (anonymous object). This returns such an object.
+import warnings
 
-        :return dictionary of member names to python values of member keys
-        """
-        return None if self._val is None else [item.val for item in self._val]
-
-    @property
-    def formatted_val(self) -> list:
-        """
-        Format all the elements of array according to the arr_format.
-        Note 1: All elements will be cast to str
-        Note 2: If a member is a serializable will call serializable formatted_val
-        :return a formatted array
-        """
-        result = []
-        for item in self._val:
-            if hasattr(item, "formatted_val"):
-                result.append(item.formatted_val)
-            else:
-                result.append(self.FORMAT.format(item.val))
-        return result
-
-    @val.setter
-    def val(self, val: list):
-        """
-        The .val property typically returns the python-native type. This the python native type closes to a serializable
-        without generating full classes would be a dictionary (anonymous object). This takes such an object and sets the
-        member val list from it.
-
-        :param val: dictionary containing python types to key names. This
-        """
-        self.validate(val)
-        items = [self.MEMBER_TYPE(item) for item in val]
-        self._val = items
-
-    def to_jsonable(self):
-        """
-        JSONable array object format
-        """
-        return {
-            "name": self.__class__.__name__,
-            "type": self.__class__.__name__,
-            "size": self.LENGTH,
-            "format": self.FORMAT,
-            "values": (
-                None
-                if self._val is None
-                else [member.to_jsonable() for member in self._val]
-            ),
-        }
-
-    def serialize(self):
-        """Serialize the array by serializing the elements one by one"""
-        if self.val is None:
-            raise NotInitializedException(type(self))
-        return b"".join([item.serialize() for item in self._val])
-
-    def deserialize(self, data, offset):
-        """Deserialize the members of the array"""
-        values = []
-        for field_index in range(self.LENGTH):
-            try:
-                item = self.MEMBER_TYPE()
-                item.deserialize(data, offset)
-                offset += item.getSize()
-                values.append(item)
-            except Exception as exc:
-                raise DeserializeException(
-                    f"Array index {field_index} failed to deserialize: {exc}"
-                )
-        self._val = values
-
-    def getSize(self):
-        """Return the size in bytes of the array"""
-        return sum(item.getSize() for item in self._val)
-
-    @classmethod
-    def getMaxSize(cls):
-        """Return the maximum size in bytes of the array"""
-        return cls.MEMBER_TYPE.getMaxSize() * cls.LENGTH
+warnings.warn(
+    "ArrayType is defined in fprime_gds.common.models.serialize.array_type. Change your imports accordingly.",
+    DeprecationWarning,
+    stacklevel=2,
+)
 
-    def __iter__(self):
-        """Allow the array object to be iterated"""
-        return iter(self._val)
+# Import from new location for backward compatibility - may be removed in future versions
+try:
+    from fprime_gds.common.models.serialize.array_type import ArrayType
+except ImportError as e:
+    raise ImportError(
+        "ArrayType has been moved to the fprime-gds package. "
+        "Please install fprime-gds and update your imports to use "
+        "`from fprime_gds.common.models.serialize.array_type import ArrayType`"
+    ) from e

src/fprime/common/models/serialize/bool_type.py

@@ -3,53 +3,20 @@
 @author: tcanham, reder
 """
 
-import struct
+import warnings
 
-from .type_base import ValueType
-from .type_exceptions import (
-    DeserializeException,
-    NotInitializedException,
-    TypeMismatchException,
-    TypeRangeException,
+warnings.warn(
+    "BoolType is defined in fprime_gds.common.models.serialize.bool_type. Change your imports accordingly.",
+    DeprecationWarning,
+    stacklevel=2,
 )
 
-
-class BoolType(ValueType):
-    """
-    Representation of a boolean type that will be stored for F prime. True values are stored as a U8 of 0xFF and False
-    is stored as a U8 of 0x00.
-    """
-
-    TRUE = 0xFF
-    FALSE = 0x00
-
-    @classmethod
-    def validate(cls, val):
-        """Validate the given class"""
-        if not isinstance(val, bool):
-            raise TypeMismatchException(bool, type(val))
-
-    def serialize(self):
-        """Serialize a boolean value"""
-        if self._val is None:
-            raise NotInitializedException(type(self))
-        return struct.pack("B", self.TRUE if self._val else self.FALSE)
-
-    def deserialize(self, data, offset):
-        """Deserialize boolean value"""
-        try:
-            int_val = struct.unpack_from("B", data, offset)[0]
-            if int_val not in [self.TRUE, self.FALSE]:
-                raise TypeRangeException(int_val)
-            self._val = int_val == self.TRUE
-        except struct.error:
-            raise DeserializeException("Not enough bytes to deserialize bool.")
-
-    @classmethod
-    def getSize(cls):
-        return struct.calcsize("B")
-
-    @classmethod
-    def getMaxSize(cls):
-        """Maximum size of type"""
-        return cls.getSize()  # Always the same as getSize
+# Import from new location for backward compatibility - may be removed in future versions
+try:
+    from fprime_gds.common.models.serialize.bool_type import BoolType
+except ImportError as e:
+    raise ImportError(
+        "BoolType has been moved to the fprime-gds package. "
+        "Please install fprime-gds and update your imports to use "
+        "`from fprime_gds.common.models.serialize.bool_type import BoolType`"
+    ) from e

src/fprime/common/models/serialize/enum_type.py

@@ -3,130 +3,23 @@
 @author: tcanham, reder
 """
 
-import struct
+import warnings
 
-from .type_base import DictionaryType
-from .type_exceptions import (
-    DeserializeException,
-    EnumMismatchException,
-    NotInitializedException,
-    TypeMismatchException,
-    TypeRangeException,
-    InvalidRepresentationTypeException,
-    RepresentationTypeRangeException,
+warnings.warn(
+    "EnumType is defined in fprime_gds.common.models.serialize.enum_type. Change your imports accordingly.",
+    DeprecationWarning,
+    stacklevel=2,
 )
-from .numerical_types import IntegerType
 
-REPRESENTATION_TYPE_MAP = {
-    cls.get_canonical_name(): cls for cls in IntegerType.__subclasses__()
-}
-
-
-class EnumType(DictionaryType):
-    """
-    Representation of the ENUM type.
-
-    The enumeration takes a dictionary that stores the enumeration members
-    and current value as a string. The member values will have to be computed
-    containing code based on C enum rules
-    """
-
-    @classmethod
-    def construct_type(cls, name, enum_dict, rep_type="I32"):
-        """Construct the custom enum type
-
-        Constructs the custom enumeration type, with the supplied enumeration dictionary.
-
-        Args:
-            name: name of the enumeration type
-            enum_dict: enumeration: value dictionary defining the enumeration
-            rep_type: representation type (standard Fprime integer types)
-        """
-        if not isinstance(enum_dict, dict):
-            raise TypeMismatchException(dict, type(enum_dict))
-        for member in enum_dict.keys():
-            if not isinstance(member, str):
-                raise TypeMismatchException(str, type(member))
-            if not isinstance(enum_dict[member], int):
-                raise TypeMismatchException(int, enum_dict[member])
-
-        if rep_type not in REPRESENTATION_TYPE_MAP.keys():
-            raise InvalidRepresentationTypeException(
-                rep_type, REPRESENTATION_TYPE_MAP.keys()
-            )
-
-        for member in enum_dict.keys():
-            type_range = REPRESENTATION_TYPE_MAP[rep_type].range()
-            if enum_dict[member] < type_range[0] or enum_dict[member] > type_range[1]:
-                raise RepresentationTypeRangeException(
-                    member, enum_dict[member], rep_type, type_range
-                )
-
-        return DictionaryType.construct_type(
-            cls, name, ENUM_DICT=enum_dict, REP_TYPE=rep_type
-        )
-
-    @classmethod
-    def validate(cls, val):
-        """Validate the value passed into the enumeration"""
-        if not isinstance(val, str):
-            raise TypeMismatchException(str, type(val))
-        if val not in cls.keys():
-            raise EnumMismatchException(cls.__class__.__name__, val)
-
-    @classmethod
-    def keys(cls):
-        """
-        Return all the enum key values.
-        """
-        return list(cls.ENUM_DICT.keys())
-
-    def serialize(self):
-        """
-        Serialize the enumeration type using an int type
-        """
-        # for enums, take the string value and convert it to
-        # the numeric equivalent
-        if self._val is None or (
-            self._val == "UNDEFINED" and "UNDEFINED" not in self.ENUM_DICT
-        ):
-            raise NotInitializedException(type(self))
-        return struct.pack(
-            REPRESENTATION_TYPE_MAP[self.REP_TYPE].get_serialize_format(),
-            self.ENUM_DICT[self._val],
-        )
-
-    def deserialize(self, data, offset):
-        """
-        Deserialize the enumeration using an int type
-        """
-        try:
-            int_val = struct.unpack_from(
-                REPRESENTATION_TYPE_MAP[self.REP_TYPE].get_serialize_format(),
-                data,
-                offset,
-            )[0]
-
-        except struct.error:
-            msg = f"Could not deserialize enum value. Needed: {self.getSize()} bytes Found: {len(data[offset:])}"
-            raise DeserializeException(msg)
-        for key, val in self.ENUM_DICT.items():
-            if int_val == val:
-                self._val = key
-                break
-        # Value not found, invalid enumeration value
-        else:
-            raise TypeRangeException(int_val)
-
-    def getSize(self):
-        """Calculates the size based on the size of an integer used to store it"""
-        return struct.calcsize(
-            REPRESENTATION_TYPE_MAP[self.REP_TYPE].get_serialize_format()
-        )
-
-    @classmethod
-    def getMaxSize(cls):
-        """Maximum size of type"""
-        return struct.calcsize(
-            REPRESENTATION_TYPE_MAP[cls.REP_TYPE].get_serialize_format()
-        )
+# Import from new location for backward compatibility - may be removed in future versions
+try:
+    from fprime_gds.common.models.serialize.enum_type import (
+        EnumType,
+        REPRESENTATION_TYPE_MAP,
+    )
+except ImportError as e:
+    raise ImportError(
+        "EnumType has been moved to the fprime-gds package. "
+        "Please install fprime-gds and update your imports to use "
+        "`from fprime_gds.common.models.serialize.enum_type import EnumType`"
+    ) from e