linkml 1.8.2__py3-none-any.whl → 1.8.4__py3-none-any.whl

linkml/generators/pydanticgen/array.py

@@ -1,7 +1,7 @@
 import sys
 from abc import ABC, abstractmethod
 from enum import Enum
-from typing import TYPE_CHECKING, Any, ClassVar, Generic, Iterable, Optional, Type, TypeVar, Union, get_args
+from typing import TYPE_CHECKING, Any, ClassVar, Generic, Iterable, List, Optional, Type, TypeVar, Union, get_args
 
 from linkml_runtime.linkml_model import Element
 from linkml_runtime.linkml_model.meta import ArrayExpression, DimensionExpression
@@ -26,11 +26,12 @@ else:
 
 from linkml.generators.pydanticgen.build import RangeResult
 from linkml.generators.pydanticgen.template import ConditionalImport, Import, Imports, ObjectImport
+from linkml.utils.exceptions import ValidationError
 
 
 class ArrayRepresentation(Enum):
     LIST = "list"
-    NPARRAY = "nparray"  # numpy and nptyping must be installed to use this
+    NUMPYDANTIC = "numpydantic"  # numpydantic must be installed to use this
 
 
 _BOUNDED_ARRAY_FIELDS = ("exact_number_dimensions", "minimum_number_dimensions", "maximum_number_dimensions")
@@ -44,17 +45,18 @@ class AnyShapeArrayType(Generic[_T]):
     def __get_pydantic_core_schema__(cls, source_type: Any, handler: "GetCoreSchemaHandler") -> "CoreSchema":
         # double-nested parameterized types here
         # source_type: List[Union[T,List[...]]]
-        item_type = Any if get_args(get_args(source_type)[0])[0] is _T else get_args(get_args(source_type)[0])[0]
+        item_type = (Any,) if get_args(get_args(source_type)[0])[0] is _T else get_args(get_args(source_type)[0])[:-1]
 
-        item_schema = handler.generate_schema(item_type)
-        if item_schema.get("type", "any") != "any":
+        if len(item_type) == 1:
+            item_schema = handler.generate_schema(item_type[0])
+        else:
+            item_schema = core_schema.union_schema([handler.generate_schema(i) for i in item_type])
+
+        if all([getattr(i, "__module__", "") == "builtins" and i is not Any for i in item_type]):
             item_schema["strict"] = True
 
-        if item_type is Any:
-            # Before python 3.11, `Any` type was a special object without a __name__
-            item_name = "Any"
-        else:
-            item_name = item_type.__name__
+        # Before python 3.11, `Any` type was a special object without a __name__
+        item_name = "_".join(["Any" if i is Any else i.__name__ for i in item_type])
 
         array_ref = f"any-shape-array-{item_name}"
 
@@ -109,6 +111,124 @@ _AnyShapeArrayInjects = [
 _ConListImports = Imports() + Import(module="pydantic", objects=[ObjectImport(name="conlist")])
 
 
+class ArrayValidator:
+    """
+    Validate the specification of a LinkML Array
+
+    .. todo::
+
+        It looks like :mod:`linkml.validator` is for validating instances against schema, rather
+        than validating the schema itself, so am not subclassing/writing as a plugin.
+        Unsure if there is a more general means of validating schema, but for now this is
+        an independent class
+    """
+
+    @classmethod
+    def validate(cls, array: ArrayExpression):
+        """
+        Validate an array expression.
+
+        Raises:
+            :class:`.ValidationError` if invalid
+        """
+        cls.array_exact_dimensions(array)
+        cls.array_consistent_n_dimensions(array)
+        cls.array_explicitly_unbounded(array)
+        cls.array_dimensions_ordinal(array)
+
+        if array.dimensions:
+            for dimension in array.dimensions:
+                cls.validate_dimension(dimension)
+
+    @classmethod
+    def validate_dimension(cls, dimension: DimensionExpression):
+        """
+        Validate a single array dimension
+
+        Raises:
+            :class:`.ValidationError` if invalid
+        """
+        cls.dimension_exact_cardinality(dimension)
+        cls.dimension_ordinal(dimension)
+
+    @staticmethod
+    def array_exact_dimensions(array: ArrayExpression):
+        """Arrays can have exact_number_dimensions OR min/max_number_dimensions, but not both"""
+        if array.exact_number_dimensions is not None and (
+            array.minimum_number_dimensions is not None or array.maximum_number_dimensions is not None
+        ):
+            raise ValidationError(
+                f"Can only specify EITHER exact_number_dimensions OR minimum/maximum dimensions, got: {array}"
+            )
+
+    @staticmethod
+    def array_consistent_n_dimensions(array: ArrayExpression):
+        """
+        Complex arrays with both exact/min/max_number_dimensions and parameterized dimensions
+        need to have the exact/min/max_number_dimensions greater than the number of parameterized dimensions!
+        """
+        if not array.dimensions:
+            return
+
+        for field_name in _BOUNDED_ARRAY_FIELDS:
+            field = getattr(array, field_name, None)
+            if field and field < len(array.dimensions):
+                raise ValidationError(
+                    "if exact/minimum/maximum_number_dimensions is provided, "
+                    "it must be greater than the parameterized dimensions. "
+                    f"got\n- {field_name}: {field}\n- dimensions: {array.dimensions}"
+                )
+
+    @staticmethod
+    def array_dimensions_ordinal(array: ArrayExpression):
+        """
+        minimum_number_dimensions needs to be less than maximum_number_dimensions when both are set
+        """
+        if array.minimum_number_dimensions is not None and array.maximum_number_dimensions:
+            if array.minimum_number_dimensions > array.maximum_number_dimensions:
+                raise ValidationError(
+                    "minimum_number_dimensions must be lesser than maximum_number_dimensions when both are set. "
+                    f"got minimum: {array.minimum_number_dimensions}, maximum: {array.maximum_number_dimensions}"
+                )
+
+    @staticmethod
+    def array_explicitly_unbounded(array: ArrayExpression):
+        """
+        Complex arrays with a minimum_number_dimensions and parameterized dimensions
+        need to either use exact_number_dimensions to specify extra anonymous dimensions
+        or set maximum_number_dimensions to ``False`` to specify unbounded extra anonymous
+        dimensions to avoid ambiguity.
+        """
+        if array.minimum_number_dimensions is not None and array.maximum_number_dimensions is None and array.dimensions:
+            raise ValidationError(
+                (
+                    "Cannot specify a minimum_number_dimensions while maximum is None while using labeled dimensions - "
+                    "either use exact_number_dimensions > len(dimensions) for extra parameterized dimensions or set "
+                    "maximum_number_dimensions explicitly to False for unbounded dimensions"
+                )
+            )
+
+    @staticmethod
+    def dimension_exact_cardinality(dimension: DimensionExpression):
+        """Dimensions can only have exact_cardinality OR min/max_cardinality, but not both"""
+        if dimension.exact_cardinality is not None and (
+            dimension.minimum_cardinality is not None or dimension.maximum_cardinality is not None
+        ):
+            raise ValidationError(
+                f"Can only specify EITHER exact_cardinality OR minimum/maximum cardinality, got: {dimension}"
+            )
+
+    @staticmethod
+    def dimension_ordinal(dimension: DimensionExpression):
+        """minimum_cardinality must be less than maximum_cardinality when both are set"""
+        if dimension.minimum_cardinality is not None and dimension.maximum_cardinality is not None:
+            if dimension.minimum_cardinality > dimension.maximum_cardinality:
+                raise ValidationError(
+                    "minimum_cardinality must be lesser than maximum_cardinality when both are set. "
+                    f"got minimum: {dimension.minimum_cardinality}, maximum: {dimension.maximum_cardinality}"
+                )
+
+
 class ArrayRangeGenerator(ABC):
     """
     Metaclass for generating a given format of array range.
@@ -142,16 +262,33 @@ class ArrayRangeGenerator(ABC):
         self.dtype = dtype
 
     def make(self) -> RangeResult:
-        """Create the string form of the array representation"""
+        """
+        Create the string form of the array representation, validating first
+        """
+        self.validate()
+
         if not self.array.dimensions and not self.has_bounded_dimensions:
-            # any-shaped array
-            return self.any_shape(self.array)
+            return self._any_shape(self.array)
         elif not self.array.dimensions and self.has_bounded_dimensions:
-            return self.bounded_dimensions(self.array)
+            return self._bounded_dimensions(self.array)
         elif self.array.dimensions and not self.has_bounded_dimensions:
-            return self.parameterized_dimensions(self.array)
+            return self._parameterized_dimensions(self.array)
         else:
-            return self.complex_dimensions(self.array)
+            return self._complex_dimensions(self.array)
+
+    def validate(self):
+        """
+        Ensure that the given ArrayExpression is valid using :class:`.ArrayValidator`
+
+        .. todo::
+
+            Integrate with more general schema validation that happens when a schema is loaded,
+            rather than when an array is generated
+
+        Raises:
+            :class:`.ValidationError` if the schema is invalid
+        """
+        ArrayValidator.validate(self.array)
 
     @property
     def has_bounded_dimensions(self) -> bool:
@@ -167,22 +304,22 @@ class ArrayRangeGenerator(ABC):
         raise ValueError(f"Generator for array representation {repr} not found!")
 
     @abstractmethod
-    def any_shape(self, array: Optional[ArrayRepresentation] = None) -> RangeResult:
+    def _any_shape(self, array: Optional[ArrayRepresentation] = None) -> RangeResult:
         """Any shaped array!"""
         pass
 
     @abstractmethod
-    def bounded_dimensions(self, array: ArrayExpression) -> RangeResult:
+    def _bounded_dimensions(self, array: ArrayExpression) -> RangeResult:
         """Array shape specified numerically, without axis parameterization"""
         pass
 
     @abstractmethod
-    def parameterized_dimensions(self, array: ArrayExpression) -> RangeResult:
+    def _parameterized_dimensions(self, array: ArrayExpression) -> RangeResult:
         """Array shape specified with ``dimensions`` without additional parameterized dimensions"""
         pass
 
     @abstractmethod
-    def complex_dimensions(self, array: ArrayExpression) -> RangeResult:
+    def _complex_dimensions(self, array: ArrayExpression) -> RangeResult:
         """Array shape with both ``parameterized`` and ``bounded`` dimensions"""
         pass
 
@@ -190,9 +327,6 @@ class ArrayRangeGenerator(ABC):
 class ListOfListsArray(ArrayRangeGenerator):
     """
     Represent arrays as lists of lists!
-
-    TODO: Move all validation of values (eg. anywhere we raise a ValueError) to the ArrayExpression
-    dataclass and out of the generator class
     """
 
     REPR = ArrayRepresentation.LIST
@@ -204,9 +338,7 @@ class ListOfListsArray(ArrayRangeGenerator):
     @staticmethod
     def _parameterized_dimension(dimension: DimensionExpression, dtype: str) -> RangeResult:
         # TODO: Preserve label representation in some readable way! doing the MVP now of using conlist
-        if dimension.exact_cardinality and (dimension.minimum_cardinality or dimension.maximum_cardinality):
-            raise ValueError("Can only specify EITHER exact_cardinality OR minimum/maximum cardinality")
-        elif dimension.exact_cardinality:
+        if dimension.exact_cardinality:
             dmin = dimension.exact_cardinality
             dmax = dimension.exact_cardinality
         elif dimension.minimum_cardinality or dimension.maximum_cardinality:
@@ -228,7 +360,7 @@ class ListOfListsArray(ArrayRangeGenerator):
 
         return RangeResult(range=range, imports=_ConListImports)
 
-    def any_shape(self, array: Optional[ArrayExpression] = None, with_inner_union: bool = False) -> RangeResult:
+    def _any_shape(self, array: Optional[ArrayExpression] = None, with_inner_union: bool = False) -> RangeResult:
         """
         An AnyShaped array (using :class:`.AnyShapeArray` )
 
@@ -247,7 +379,7 @@ class ListOfListsArray(ArrayRangeGenerator):
             range = f"Union[{range}, {self.dtype}]"
         return RangeResult(range=range, injected_classes=_AnyShapeArrayInjects, imports=_AnyShapeArrayImports)
 
-    def bounded_dimensions(self, array: ArrayExpression) -> RangeResult:
+    def _bounded_dimensions(self, array: ArrayExpression) -> RangeResult:
         """
         A nested series of ``List[]`` ranges with :attr:`.dtype` at the center.
 
@@ -263,23 +395,22 @@ class ListOfListsArray(ArrayRangeGenerator):
         elif not array.maximum_number_dimensions and (
             array.minimum_number_dimensions is None or array.minimum_number_dimensions == 1
         ):
-            return self.any_shape()
+            return self._any_shape()
         elif array.maximum_number_dimensions:
             # e.g., if min = 2, max = 3, range = Union[List[List[dtype]], List[List[List[dtype]]]]
             min_dims = array.minimum_number_dimensions if array.minimum_number_dimensions is not None else 1
             ranges = [self._list_of_lists(i, self.dtype) for i in range(min_dims, array.maximum_number_dimensions + 1)]
-            # TODO: Format this nicely!
             return RangeResult(range="Union[" + ", ".join(ranges) + "]")
         else:
             # min specified with no max
             # e.g., if min = 3, range = List[List[AnyShapeArray[dtype]]]
             return RangeResult(
-                range=self._list_of_lists(array.minimum_number_dimensions - 1, self.any_shape().range),
+                range=self._list_of_lists(array.minimum_number_dimensions - 1, self._any_shape().range),
                 injected_classes=_AnyShapeArrayInjects,
                 imports=_AnyShapeArrayImports,
             )
 
-    def parameterized_dimensions(self, array: ArrayExpression) -> RangeResult:
+    def _parameterized_dimensions(self, array: ArrayExpression) -> RangeResult:
         """
         Constrained shapes using :func:`pydantic.conlist`
 
@@ -296,12 +427,13 @@ class ListOfListsArray(ArrayRangeGenerator):
 
         return RangeResult(range=range, imports=_ConListImports)
 
-    def complex_dimensions(self, array: ArrayExpression) -> RangeResult:
+    def _complex_dimensions(self, array: ArrayExpression) -> RangeResult:
         """
         Mixture of parameterized dimensions with a max or min (or both) shape for anonymous dimensions.
 
         A mixture of ``List`` , :class:`.conlist` , and :class:`.AnyShapeArray` .
         """
+        res = None
         # first process any unlabeled dimensions which must be the innermost level of the range,
         # then wrap that with labeled dimensions
         if array.exact_number_dimensions or (
@@ -314,39 +446,29 @@ class ListOfListsArray(ArrayRangeGenerator):
                 res = RangeResult(range=self._list_of_lists(exact_dims - len(array.dimensions), self.dtype))
             elif exact_dims == len(array.dimensions):
                 # equivalent to labeled shape
-                return self.parameterized_dimensions(array)
-            else:
-                raise ValueError(
-                    "if exact_number_dimensions is provided, it must be greater than the parameterized dimensions"
-                )
+                return self._parameterized_dimensions(array)
+            # else is invalid, see: ArrayValidator.array_consistent_n_dimensions
 
         elif array.maximum_number_dimensions is not None and not array.maximum_number_dimensions:
             # unlimited n dimensions, so innermost is AnyShape with dtype
-            res = self.any_shape(with_inner_union=True)
+            res = self._any_shape(with_inner_union=True)
 
-            if array.minimum_number_dimensions and array.minimum_number_dimensions > len(array.dimensions):
+            if array.minimum_number_dimensions:
                 # some minimum anonymous dimensions but unlimited max dimensions
                 # e.g., if min = 3, len(dim) = 2, then res.range = List[Union[AnyShapeArray[dtype], dtype]]
                 # res.range will be wrapped with the 2 labeled dimensions later
                 res.range = self._list_of_lists(array.minimum_number_dimensions - len(array.dimensions), res.range)
 
-        elif array.minimum_number_dimensions and array.maximum_number_dimensions is None:
-            raise ValueError(
-                (
-                    "Cannot specify a minimum_number_dimensions while maximum is None while using labeled dimensions - "
-                    "either use exact_number_dimensions > len(dimensions) for extra parameterized dimensions or set "
-                    "maximum_number_dimensions explicitly to False for unbounded dimensions"
-                )
-            )
         elif array.maximum_number_dimensions:
             initial_min = array.minimum_number_dimensions if array.minimum_number_dimensions is not None else 0
             dmin = max(len(array.dimensions), initial_min) - len(array.dimensions)
             dmax = array.maximum_number_dimensions - len(array.dimensions)
 
-            res = self.bounded_dimensions(
+            res = self._bounded_dimensions(
                 ArrayExpression(minimum_number_dimensions=dmin, maximum_number_dimensions=dmax)
             )
-        else:
+
+        if res is None:
             raise ValueError("Unsupported array specification! this is almost certainly a bug!")  # pragma: no cover
 
         # Wrap inner dimension with labeled dimension
@@ -366,13 +488,175 @@ class ListOfListsArray(ArrayRangeGenerator):
         return res
 
 
-class NPTypingArray(ArrayRangeGenerator):
+class NumpydanticArray(ArrayRangeGenerator):
+    """
+    Represent array range with :class:`numpydantic.NDArray` annotations,
+    allowing an abstract array specification to be used with many different array
+    libraries.
+    """
+
+    REPR = ArrayRepresentation.NUMPYDANTIC
+    MIN_NUMPYDANTIC_VERSION = "1.6.1"
     """
-    Represent array range with nptyping, and serialization/loading with an ArrayProxy
+    Minimum numpydantic version needed to be installed in the environment using
+    the generated models
     """
+    IMPORTS = Imports() + Import(
+        module="numpydantic", objects=[ObjectImport(name="NDArray"), ObjectImport(name="Shape")]
+    )
+    INJECTS = [f'MIN_NUMPYDANTIC_VERSION = "{MIN_NUMPYDANTIC_VERSION}"']
+
+    def make(self) -> RangeResult:
+        result = super().make()
+        result.imports = self.IMPORTS.model_copy()
+        result.injected_classes = self.INJECTS.copy()
+        return result
+
+    @staticmethod
+    def ndarray_annotation(shape: Optional[List[Union[int, str]]] = None, dtype: Optional[str] = None) -> str:
+        """
+        Make a stringified :class:`numpydantic.NDArray` annotation for a given shape
+        and dtype.
+
+        If either ``shape`` or ``dtype`` is ``None`` , use ``Any``
+        """
+        if shape is None:
+            shape = "Any"
+        else:
+            shape_expression = ", ".join([str(i) for i in shape])
+            shape = f'Shape["{shape_expression}"]'
+
+        if dtype is None or dtype in ("Any", "AnyType"):
+            dtype = "Any"
+
+        if shape == "Any" and dtype == "Any":
+            return "NDArray"
+        else:
+            return f"NDArray[{shape}, {dtype}]"
+
+    @staticmethod
+    def _dimension_shape(dimension: DimensionExpression) -> str:
+        if dimension.exact_cardinality:
+            shape = str(dimension.exact_cardinality)
+        elif dimension.minimum_cardinality and not dimension.maximum_cardinality:
+            shape = f"{dimension.minimum_cardinality}-*"
+        elif dimension.maximum_cardinality and not dimension.minimum_cardinality:
+            shape = f"*-{dimension.maximum_cardinality}"
+        elif dimension.minimum_cardinality and dimension.maximum_cardinality:
+            shape = f"{dimension.minimum_cardinality}-{dimension.maximum_cardinality}"
+        else:
+            shape = "*"
+
+        return shape
+
+    @classmethod
+    def _parameterized_dimension(cls, dimension: DimensionExpression) -> str:
+        shape = cls._dimension_shape(dimension)
+        if dimension.alias is not None:
+            return f"{shape} {dimension.alias}"
+        else:
+            return shape
+
+    def _any_shape(self, array: Optional[ArrayRepresentation] = None) -> RangeResult:
+        """
+        Any shaped array, either an unparameterized :class:`numpydantic.NDArray`
+        if dtype is :class:`typing.Any` , or like ``NDArray[Any, {self.dtype}]``
+        otherwise.
+        """
+        if self.dtype in ("Any", "AnyType"):
+            range = "NDArray"
+        else:
+            range = f"NDArray[Any, {self.dtype}]"
+
+        return RangeResult(range=range)
+
+    def _bounded_dimensions(self, array: ArrayExpression) -> RangeResult:
+        """
+        Number of dimensions specified without shape
+        """
+        if array.exact_number_dimensions or (
+            array.minimum_number_dimensions
+            and array.maximum_number_dimensions
+            and array.minimum_number_dimensions == array.maximum_number_dimensions
+        ):
+            exact_dims = array.exact_number_dimensions or array.minimum_number_dimensions
+
+            return RangeResult(range=self.ndarray_annotation(["*"] * exact_dims, self.dtype))
+        elif not array.maximum_number_dimensions and (
+            array.minimum_number_dimensions is None or array.minimum_number_dimensions == 1
+        ):
+            return self._any_shape()
+        elif array.maximum_number_dimensions:
+            # e.g., if min = 2, max = 3, range = Union[NDArray[Shape["*, *"], dtype], NDArray[Shape["*, *, *"], dtype]]
+            min_dims = array.minimum_number_dimensions if array.minimum_number_dimensions is not None else 1
+            ranges = [
+                self.ndarray_annotation(["*"] * i, self.dtype)
+                for i in range(min_dims, array.maximum_number_dimensions + 1)
+            ]
+            return RangeResult(range="Union[" + ", ".join(ranges) + "]")
+        else:
+            # min specified with no max
+            # e.g., if min = 3, range = NDArray[Shape[*, *, *, ...], dtype]
+            shape_inner = ["*"] * array.minimum_number_dimensions
+            shape_inner.append("...")
+            return RangeResult(range=self.ndarray_annotation(shape_inner, self.dtype))
+
+    def _parameterized_dimensions(self, array: ArrayExpression) -> RangeResult:
+        """
+        Arrays with constrained shapes or labels
+        """
+        dims = [self._parameterized_dimension(d) for d in array.dimensions]
+        range = self.ndarray_annotation(dims, self.dtype)
+        return RangeResult(range=range)
+
+    def _complex_dimensions(self, array: ArrayExpression) -> RangeResult:
+        """
+        Mixture of parameterized dimensions with a max or min (or both) shape for anonymous dimensions.
+        """
+        dims = [self._parameterized_dimension(d) for d in array.dimensions]
+        res = None
+
+        if array.exact_number_dimensions or (
+            array.minimum_number_dimensions
+            and array.maximum_number_dimensions
+            and array.minimum_number_dimensions == array.maximum_number_dimensions
+        ):
+            exact_dims = array.exact_number_dimensions or array.minimum_number_dimensions
+            if exact_dims > len(array.dimensions):
+                dims.extend(["*"] * (exact_dims - len(dims)))
+                res = self.ndarray_annotation(dims, self.dtype)
+            elif exact_dims == len(array.dimensions):
+                # equivalent to labeled shape
+                return self._parameterized_dimensions(array)
+            # else is invalid, see: ArrayValidator.array_consistent_n_dimensions(array)
+
+        elif array.maximum_number_dimensions is not None and not array.maximum_number_dimensions:
+            # unlimited n dimensions
+
+            if array.minimum_number_dimensions:
+                # some minimum anonymous dimensions but unlimited max dimensions
+                dims.extend(["*"] * (array.minimum_number_dimensions - len(dims)))
+
+            dims.append("...")
+            res = self.ndarray_annotation(dims, self.dtype)
+
+        elif array.maximum_number_dimensions:
+            # some res of anonymous dimensions
+
+            if array.minimum_number_dimensions:
+                min_dim = array.minimum_number_dimensions
+            else:
+                min_dim = len(dims)
+
+            dim_union = []
+            for i in range(min_dim, array.maximum_number_dimensions + 1):
+                this_dims = dims.copy()
+                this_dims.extend(["*"] * (i - len(dims)))
+                dim_union.append(self.ndarray_annotation(this_dims, self.dtype))
+            dim_union = ", ".join(dim_union)
+            res = f"Union[{dim_union}]"
 
-    REPR = ArrayRepresentation.NPARRAY
+        if res is None:
+            raise ValueError(f"Unhandled range case! {array}")
 
-    def __init__(self, **kwargs):
-        super(self).__init__(**kwargs)
-        raise NotImplementedError("NPTyping array ranges are not implemented yet :(")
+        return RangeResult(range=res)

linkml/generators/pydanticgen/build.py

@@ -59,8 +59,10 @@ class PydanticBuildResult(BuildResult):
                 self_copy.imports = other.imports
         if other.injected_classes:
             if self_copy.injected_classes is not None:
-                self_copy.injected_classes.extend(other.injected_classes)
-                self_copy.injected_classes = list(dict.fromkeys(self_copy.injected_classes))
+                # only combine and dedupe when injected_classes don't match
+                if self_copy.injected_classes != other.injected_classes:
+                    self_copy.injected_classes.extend(other.injected_classes)
+                    self_copy.injected_classes = list(dict.fromkeys(self_copy.injected_classes))
             else:
                 self_copy.injected_classes = other.injected_classes
         return self_copy