Remove the aggregation check from the public API

Author: pavel-kirienko

pydsdl/_serializable/_array.py

@@ -27,11 +27,11 @@ def __init__(self, element_type: SerializableType, capacity: int):
     def deprecated(self) -> bool:
         return self.element_type.deprecated
 
-    def check_aggregation(self, aggregate: "SerializableType") -> typing.Optional[AggregationFailure]:
-        af = self.element_type.check_aggregation(self)
+    def _check_aggregation(self, aggregate: "SerializableType") -> typing.Optional[AggregationFailure]:
+        af = self.element_type._check_aggregation(self)  # pylint: disable=protected-access
         if af is not None:
             return AggregationFailure(self, aggregate, "Element type of %r is not valid: %s" % (str(self), af.message))
-        return super().check_aggregation(aggregate)
+        return super()._check_aggregation(aggregate)
 
     @property
     def element_type(self) -> SerializableType:

pydsdl/_serializable/_composite.py

@@ -128,7 +128,7 @@ def __init__(  # pylint: disable=too-many-arguments
         #   - Types like utf8 and byte cannot be used outside of arrays.
         #   - A non-deprecated type cannot depend on a deprecated type.
         for a in self._attributes:
-            af = a.data_type.check_aggregation(self)
+            af = a.data_type._check_aggregation(self)
             if af is not None:
                 raise AggregationError("Type of %r is not a valid field type for %s: %s" % (str(a), self, af.message))
 
@@ -188,8 +188,8 @@ def bit_length_set(self) -> BitLengthSet:
         """
         raise NotImplementedError
 
-    def check_aggregation(self, aggregate: "SerializableType") -> typing.Optional[AggregationFailure]:
-        return super().check_aggregation(aggregate)
+    def _check_aggregation(self, aggregate: "SerializableType") -> typing.Optional[AggregationFailure]:
+        return super()._check_aggregation(aggregate)
 
     @property
     def deprecated(self) -> bool:
@@ -603,11 +603,11 @@ def iterate_fields_with_offsets(
         base_offset = base_offset + self.delimiter_header_type.bit_length_set
         return self.inner_type.iterate_fields_with_offsets(base_offset)
 
-    def check_aggregation(self, aggregate: "SerializableType") -> typing.Optional[AggregationFailure]:
-        af = self.inner_type.check_aggregation(aggregate)
+    def _check_aggregation(self, aggregate: "SerializableType") -> typing.Optional[AggregationFailure]:
+        af = self.inner_type._check_aggregation(aggregate)  # pylint: disable=protected-access
         if af is not None:
             return af
-        return super().check_aggregation(aggregate)
+        return super()._check_aggregation(aggregate)
 
     def __repr__(self) -> str:
         return "%s(inner=%r, extent=%r)" % (self.__class__.__name__, self.inner_type, self.extent)

pydsdl/_serializable/_primitive.py

@@ -56,8 +56,8 @@ def deprecated(self) -> bool:
         """Primitive types cannot be deprecated."""
         return False
 
-    def check_aggregation(self, aggregate: "SerializableType") -> typing.Optional[AggregationFailure]:
-        return super().check_aggregation(aggregate)
+    def _check_aggregation(self, aggregate: "SerializableType") -> typing.Optional[AggregationFailure]:
+        return super()._check_aggregation(aggregate)
 
     @property
     def bit_length(self) -> int:
@@ -178,12 +178,12 @@ class ByteType(UnsignedIntegerType):
     def __init__(self) -> None:
         super().__init__(bit_length=PrimitiveType.BITS_IN_BYTE, cast_mode=PrimitiveType.CastMode.TRUNCATED)
 
-    def check_aggregation(self, aggregate: "SerializableType") -> typing.Optional[AggregationFailure]:
+    def _check_aggregation(self, aggregate: "SerializableType") -> typing.Optional[AggregationFailure]:
         from ._array import ArrayType
 
         if not isinstance(aggregate, ArrayType):
             return AggregationFailure(self, aggregate, "The byte type can only be used as an array element type")
-        return super().check_aggregation(aggregate)
+        return super()._check_aggregation(aggregate)
 
     def __str__(self) -> str:
         return "byte"
@@ -197,14 +197,14 @@ class UTF8Type(UnsignedIntegerType):
     def __init__(self) -> None:
         super().__init__(bit_length=8, cast_mode=PrimitiveType.CastMode.TRUNCATED)
 
-    def check_aggregation(self, aggregate: "SerializableType") -> typing.Optional[AggregationFailure]:
+    def _check_aggregation(self, aggregate: "SerializableType") -> typing.Optional[AggregationFailure]:
         from ._array import VariableLengthArrayType
 
         if not isinstance(aggregate, VariableLengthArrayType):
             return AggregationFailure(
                 self, aggregate, "The utf8 type can only be used as a variable-length array element type"
             )
-        return super().check_aggregation(aggregate)
+        return super()._check_aggregation(aggregate)
 
     def __str__(self) -> str:
         return "utf8"

pydsdl/_serializable/_serializable.py

@@ -22,7 +22,7 @@ class TypeParameterError(_error.InvalidDefinitionError):
     ],
 )
 """
-This is returned by :meth:`SerializableType.check_aggregation()` to indicate the reason of the failure.
+This is returned by :meth:`SerializableType._check_aggregation()` to indicate the reason of the failure.
 Eventually this will need to be replaced with a dataclass (sadly no dataclasses in Python 3.6).
 """
 
@@ -80,7 +80,7 @@ def deprecated(self) -> bool:
         """
         raise NotImplementedError
 
-    def check_aggregation(self, aggregate: "SerializableType") -> Optional[AggregationFailure]:
+    def _check_aggregation(self, aggregate: "SerializableType") -> Optional[AggregationFailure]:
         """
         Returns None iff the argument is a suitable aggregate type for this element type;
         otherwise, returns an instance of :class:`AggregationFailure` describing the reason of the failure.

pydsdl/_serializable/_void.py

@@ -30,12 +30,12 @@ def deprecated(self) -> bool:
         """Void types cannot be deprecated."""
         return False
 
-    def check_aggregation(self, aggregate: "SerializableType") -> typing.Optional[AggregationFailure]:
+    def _check_aggregation(self, aggregate: "SerializableType") -> typing.Optional[AggregationFailure]:
         from ._composite import StructureType, CompositeType
 
         if not isinstance(aggregate, CompositeType) or not isinstance(aggregate.inner_type, StructureType):
             return AggregationFailure(self, aggregate, "Void types can only be aggregated into structures")
-        return super().check_aggregation(aggregate)
+        return super()._check_aggregation(aggregate)
 
     @property
     def bit_length(self) -> int: