amulet-core 2.0.4a1.post250728120836__cp311-cp311-win_amd64.whl → 2.0.5a1__cp311-cp311-win_amd64.whl

amulet/core/selection/{group.pyi → box_group.pyi}

@@ -5,10 +5,12 @@ import types
 import typing
 
 import amulet.core.selection.box
+import amulet.core.selection.shape_group
+import amulet.utils.matrix
 
-__all__ = ["SelectionGroup"]
+__all__: list[str] = ["SelectionBoxGroup"]
 
-class SelectionGroup:
+class SelectionBoxGroup:
     """
     A container for zero or more :class:`SelectionBox` instances.
 
@@ -18,46 +20,42 @@ class SelectionGroup:
     __hash__: typing.ClassVar[None] = None  # type: ignore
     def __bool__(self) -> bool:
         """
-        The number of :class:`SelectionBox` classes in the group.
+        Are there any selections in the group.
         """
 
     @typing.overload
-    def __eq__(self, arg0: SelectionGroup) -> bool:
+    def __eq__(self, other: SelectionBoxGroup) -> bool:
         """
-        Does the contents of this :class:`SelectionGroup` match the other :class:`SelectionGroup`.
+        Does the contents of this :class:`SelectionBoxGroup` match the other :class:`SelectionBoxGroup`.
 
         Note if the boxes do not exactly match this will return False even if the volume represented is the same.
 
-        :param other: The other :class:`SelectionGroup` to compare with.
+        :param other: The other :class:`SelectionBoxGroup` to compare with.
         :return: True if the boxes contained match.
         """
 
     @typing.overload
-    def __eq__(self, arg0: typing.Any) -> bool | types.NotImplementedType: ...
+    def __eq__(self, other: typing.Any) -> bool | types.NotImplementedType: ...
     @typing.overload
     def __init__(self) -> None:
         """
-        Create an empty SelectionGroup.
+        Create an empty SelectionBoxGroup.
 
-        >>> SelectionGroup()
+        >>> SelectionBoxGroup()
         """
 
     @typing.overload
-    def __init__(self, box: amulet.core.selection.box.SelectionBox) -> None:
-        """
-        Create a SelectionGroup containing the given box.
-
-        >>> SelectionGroup(SelectionBox(0, 0, 0, 1, 1, 1))
-        """
-
+    def __init__(
+        self, shape_group: amulet.core.selection.shape_group.SelectionShapeGroup
+    ) -> None: ...
     @typing.overload
     def __init__(
         self, boxes: collections.abc.Iterable[amulet.core.selection.box.SelectionBox]
     ) -> None:
         """
-        Create a SelectionGroup from the boxes in the iterable.
+        Create a SelectionBoxGroup from the boxes in the iterable.
 
-        >>> SelectionGroup([
+        >>> SelectionBoxGroup([
         >>>     SelectionBox(0, 0, 0, 1, 1, 1),
         >>>     SelectionBox(1, 1, 1, 1, 1, 1)
         >>> ])
@@ -119,16 +117,21 @@ class SelectionGroup:
         """
 
     @typing.overload
-    def intersects(self, other: SelectionGroup) -> bool: ...
+    def intersects(self, other: SelectionBoxGroup) -> bool: ...
+    def transform(self, matrix: amulet.utils.matrix.Matrix4x4) -> SelectionBoxGroup:
+        """
+        Transform the boxes in this group by the given transformation matrix.
+        """
+
     def translate(
-        self, x: typing.SupportsInt, y: typing.SupportsInt, z: typing.SupportsInt
-    ) -> SelectionGroup:
+        self, dx: typing.SupportsInt, dy: typing.SupportsInt, dz: typing.SupportsInt
+    ) -> SelectionBoxGroup:
         """
-        Create a new :class:`SelectionGroup` based on this one with the coordinates moved by the given offset.
+        Create a new :class:`SelectionBoxGroup` based on this one with the coordinates moved by the given offset.
 
-        :param x: The x offset.
-        :param y: The y offset.
-        :param z: The z offset.
+        :param dx: The x offset.
+        :param dy: The y offset.
+        :param dz: The z offset.
         :return: The new selection with the given offset.
         """
 
@@ -148,6 +151,12 @@ class SelectionGroup:
         :raises RuntimeError: If there are no boxes in the selection.
         """
 
+    @property
+    def boxes(self) -> collections.abc.Iterator[amulet.core.selection.box.SelectionBox]:
+        """
+        An iterator of the :class:`SelectionBox` instances stored for this group.
+        """
+
     @property
     def max(self) -> tuple[int, int, int]:
         """
@@ -211,11 +220,3 @@ class SelectionGroup:
 
         :raises RuntimeError: If there are no boxes in the selection.
         """
-
-    @property
-    def selection_boxes(
-        self,
-    ) -> collections.abc.Iterator[amulet.core.selection.box.SelectionBox]:
-        """
-        An iterator of the :class:`SelectionBox` instances stored for this group.
-        """

amulet/core/selection/cuboid.hpp

@@ -0,0 +1,41 @@
+#pragma once
+
+#include <amulet/core/dll.hpp>
+
+#include "shape.hpp"
+
+namespace Amulet {
+
+class AMULET_CORE_EXPORT SelectionCuboid : public SelectionShape {
+public:
+    SelectionCuboid();
+    SelectionCuboid(const Matrix4x4&);
+
+    SelectionCuboid(
+        double min_x,
+        double min_y,
+        double min_z,
+        double size_x,
+        double size_y,
+        double size_z
+    );
+
+    SelectionCuboid(const SelectionCuboid& other);
+
+    std::string serialise() const override;
+
+    std::unique_ptr<SelectionShape> copy() const override;
+    explicit operator std::set<SelectionBox>() const override;
+
+    // Transform
+    SelectionCuboid translate_cuboid(double dx, double dy, double dz) const;
+    SelectionCuboid transform_cuboid(const Matrix4x4&) const;
+    std::unique_ptr<SelectionShape> transform(const Matrix4x4&) const override;
+
+    bool almost_equal(const SelectionCuboid&) const;
+    bool almost_equal(const SelectionShape&) const override;
+    bool operator==(const SelectionCuboid&) const;
+    bool operator==(const SelectionShape&) const override;
+};
+
+} // namespace Amulet

amulet/core/selection/cuboid.pyi

@@ -0,0 +1,49 @@
+from __future__ import annotations
+
+import typing
+
+import amulet.core.selection.shape
+import amulet.utils.matrix
+
+__all__: list[str] = ["SelectionCuboid"]
+
+class SelectionCuboid(amulet.core.selection.shape.SelectionShape):
+    """
+    The SelectionCuboid class represents a single spherical selection.
+    """
+
+    @typing.overload
+    def __init__(
+        self,
+        min_x: typing.SupportsFloat,
+        min_y: typing.SupportsFloat,
+        min_z: typing.SupportsFloat,
+        size_x: typing.SupportsFloat,
+        size_y: typing.SupportsFloat,
+        size_z: typing.SupportsFloat,
+    ) -> None: ...
+    @typing.overload
+    def __init__(self, matrix: amulet.utils.matrix.Matrix4x4) -> None: ...
+    def __repr__(self) -> str: ...
+    def transform(self, matrix: amulet.utils.matrix.Matrix4x4) -> SelectionCuboid:
+        """
+        Create a new :class:`SelectionCuboid` based on this one transformed by the given matrix.
+
+        :param matrix: The matrix to transform by.
+        :return: The new selection with the added transform.
+        """
+
+    def translate(
+        self,
+        dx: typing.SupportsFloat,
+        dy: typing.SupportsFloat,
+        dz: typing.SupportsFloat,
+    ) -> SelectionCuboid:
+        """
+        Create a new :class:`SelectionCuboid` based on this one with the coordinates moved by the given offset.
+
+        :param dx: The x offset.
+        :param dy: The y offset.
+        :param dz: The z offset.
+        :return: The new selection with the given offset.
+        """

amulet/core/selection/ellipsoid.hpp

@@ -0,0 +1,42 @@
+#pragma once
+#include <cstdint>
+
+#include <amulet/core/dll.hpp>
+
+#include "shape.hpp"
+
+namespace Amulet {
+
+class SelectionBox;
+
+// The SelectionEllipsoid class represents a single spherical selection.
+class AMULET_CORE_EXPORT SelectionEllipsoid : public SelectionShape {
+public:
+    SelectionEllipsoid();
+    SelectionEllipsoid(const Matrix4x4&);
+
+    SelectionEllipsoid(
+        double x,
+        double y,
+        double z,
+        double radius);
+        
+    SelectionEllipsoid(const SelectionEllipsoid& other);
+
+    std::string serialise() const override;
+        
+    std::unique_ptr<SelectionShape> copy() const override;
+    explicit operator std::set<SelectionBox>() const override;
+
+    // Transform
+    SelectionEllipsoid translate_ellipsoid(double dx, double dy, double dz) const;
+    SelectionEllipsoid transform_ellipsoid(const Matrix4x4&) const;
+    std::unique_ptr<SelectionShape> transform(const Matrix4x4&) const override;
+
+    bool almost_equal(const SelectionEllipsoid&) const;
+    bool almost_equal(const SelectionShape&) const override;
+    bool operator==(const SelectionEllipsoid&) const;
+    bool operator==(const SelectionShape&) const override;
+};
+
+} // namespace Amulet

amulet/core/selection/ellipsoid.pyi

@@ -0,0 +1,47 @@
+from __future__ import annotations
+
+import typing
+
+import amulet.core.selection.shape
+import amulet.utils.matrix
+
+__all__: list[str] = ["SelectionEllipsoid"]
+
+class SelectionEllipsoid(amulet.core.selection.shape.SelectionShape):
+    """
+    The SelectionEllipsoid class represents a single ellipsoid selection.
+    """
+
+    @typing.overload
+    def __init__(
+        self,
+        x: typing.SupportsFloat,
+        y: typing.SupportsFloat,
+        z: typing.SupportsFloat,
+        radius: typing.SupportsFloat,
+    ) -> None: ...
+    @typing.overload
+    def __init__(self, matrix: amulet.utils.matrix.Matrix4x4) -> None: ...
+    def __repr__(self) -> str: ...
+    def transform(self, matrix: amulet.utils.matrix.Matrix4x4) -> SelectionEllipsoid:
+        """
+        Create a new :class:`SelectionEllipsoid` based on this one transformed by the given matrix.
+
+        :param matrix: The matrix to transform by.
+        :return: The new selection with the added transform.
+        """
+
+    def translate(
+        self,
+        dx: typing.SupportsFloat,
+        dy: typing.SupportsFloat,
+        dz: typing.SupportsFloat,
+    ) -> SelectionEllipsoid:
+        """
+        Create a new :class:`SelectionEllipsoid` based on this one with the coordinates moved by the given offset.
+
+        :param dx: The x offset.
+        :param dy: The y offset.
+        :param dz: The z offset.
+        :return: The new selection with the given offset.
+        """

amulet/core/selection/shape.hpp

@@ -0,0 +1,73 @@
+#pragma once
+
+#include <functional>
+#include <list>
+#include <memory>
+#include <optional>
+#include <set>
+#include <string>
+#include <string_view>
+#include <utility>
+
+#include <amulet/utils/matrix.hpp>
+
+#include <amulet/core/dll.hpp>
+
+namespace Amulet {
+
+class SelectionBox;
+class SelectionBoxGroup;
+
+class AMULET_CORE_EXPORT SelectionShape {
+private:
+    Matrix4x4 _matrix;
+
+public:
+    SelectionShape() = default;
+    SelectionShape(const Matrix4x4& matrix)
+        : _matrix(matrix)
+    {
+    }
+    virtual ~SelectionShape() = default;
+
+    const Matrix4x4& get_matrix() const;
+    void set_matrix(const Matrix4x4&);
+
+    // Convert the class to human readable plain text.
+    virtual std::string serialise() const = 0;
+
+    // Deserialise the serialised data back to an object.
+    static std::unique_ptr<SelectionShape> deserialise(std::string_view, size_t&);
+    static std::unique_ptr<SelectionShape> deserialise(std::string_view);
+
+    using Deserialiser = std::function<
+        std::unique_ptr<SelectionShape>(std::string_view, size_t&)>;
+
+    static bool register_deserialiser(Deserialiser);
+
+    // Create a copy of the class.
+    virtual std::unique_ptr<SelectionShape> copy() const = 0;
+
+    explicit operator std::unique_ptr<SelectionShape>() const
+    {
+        return copy();
+    }
+
+    // Convert the shape into unit voxels.
+    virtual explicit operator std::set<SelectionBox>() const = 0;
+    explicit operator SelectionBoxGroup() const;
+    SelectionBoxGroup voxelise() const;
+
+    // translate and transform
+    virtual std::unique_ptr<SelectionShape> transform(const Matrix4x4&) const = 0;
+    std::unique_ptr<SelectionShape> translate(double dx, double dy, double dz) const
+    {
+        return transform(Matrix4x4::translation_matrix(dx, dy, dz));
+    }
+
+    // Equality
+    virtual bool almost_equal(const SelectionShape&) const = 0;
+    virtual bool operator==(const SelectionShape&) const = 0;
+};
+
+} // namespace Amulet

amulet/core/selection/shape.pyi

@@ -0,0 +1,56 @@
+from __future__ import annotations
+
+import types
+import typing
+
+import amulet.core.selection.box_group
+import amulet.utils.matrix
+
+__all__: list[str] = ["SelectionShape"]
+
+class SelectionShape:
+    """
+    A base class for selection classes.
+    """
+
+    __hash__: typing.ClassVar[None] = None  # type: ignore
+    matrix: amulet.utils.matrix.Matrix4x4
+    @staticmethod
+    def deserialise(s: str) -> SelectionShape:
+        """
+        Deserialise the serialised data back to an object.
+        """
+
+    @typing.overload
+    def __eq__(self, other: SelectionShape) -> bool: ...
+    @typing.overload
+    def __eq__(self, other: typing.Any) -> bool | types.NotImplementedType: ...
+    def almost_equal(self, other: SelectionShape) -> bool:
+        """
+        Check if this shape is equal or almost equal to another shape.
+        """
+
+    def serialise(self) -> str:
+        """
+        Convert the class to human readable plain text.
+        """
+
+    def transform(self, matrix: amulet.utils.matrix.Matrix4x4) -> SelectionShape:
+        """
+        Translate the shape by the given matrix
+        """
+
+    def translate(
+        self,
+        dx: typing.SupportsFloat,
+        dy: typing.SupportsFloat,
+        dz: typing.SupportsFloat,
+    ) -> SelectionShape:
+        """
+        Translate the shape by the given amount
+        """
+
+    def voxelise(self) -> amulet.core.selection.box_group.SelectionBoxGroup:
+        """
+        Convert the selection to a SelectionBoxGroup.
+        """

amulet/core/selection/shape_group.hpp

@@ -0,0 +1,73 @@
+#pragma once
+
+#include <memory>
+#include <string>
+#include <string_view>
+#include <vector>
+
+#include <amulet/core/dll.hpp>
+
+#include "shape.hpp"
+
+namespace Amulet {
+
+class SelectionBox;
+class SelectionBoxGroup;
+
+class AMULET_CORE_EXPORT SelectionShapeGroup {
+private:
+    std::vector<std::shared_ptr<SelectionShape>> _shapes;
+
+public:
+    SelectionShapeGroup();
+    SelectionShapeGroup(std::vector<std::shared_ptr<SelectionShape>> shapes);
+
+    SelectionShapeGroup(const SelectionShapeGroup&);
+    SelectionShapeGroup& operator=(const SelectionShapeGroup&);
+
+    SelectionShapeGroup(SelectionShapeGroup&&);
+    SelectionShapeGroup& operator=(SelectionShapeGroup&&);
+
+    SelectionShapeGroup deep_copy() const;
+
+    std::string serialise() const;
+    static SelectionShapeGroup deserialise(std::string_view);
+
+    const std::vector<std::shared_ptr<SelectionShape>>& get_shapes() const
+    {
+        return _shapes;
+    }
+    std::vector<std::shared_ptr<SelectionShape>>& get_shapes()
+    {
+        return _shapes;
+    }
+    void set_shapes(std::vector<std::shared_ptr<SelectionShape>> shapes)
+    {
+        _shapes = std::move(shapes);
+    }
+    std::vector<std::shared_ptr<SelectionShape>>::const_iterator begin() const
+    {
+        return _shapes.begin();
+    }
+    std::vector<std::shared_ptr<SelectionShape>>::const_iterator end() const
+    {
+        return _shapes.end();
+    }
+    operator bool() const
+    {
+        return !_shapes.empty();
+    }
+    size_t count() const
+    {
+        return _shapes.size();
+    }
+
+    explicit operator SelectionBoxGroup() const;
+    explicit operator std::set<SelectionBox>() const;
+    SelectionBoxGroup voxelise() const;
+
+    bool almost_equal(const SelectionShapeGroup&) const;
+    bool operator==(const SelectionShapeGroup&) const;
+};
+
+}

amulet/core/selection/shape_group.pyi

@@ -0,0 +1,118 @@
+from __future__ import annotations
+
+import collections.abc
+import types
+import typing
+
+import amulet.core.selection.box_group
+import amulet.core.selection.shape
+
+__all__: list[str] = ["SelectionShapeGroup"]
+
+class SelectionShapeGroup:
+    """
+    A group of selection shapes.
+    """
+
+    __hash__: typing.ClassVar[None] = None  # type: ignore
+    @staticmethod
+    def deserialise(s: str) -> SelectionShapeGroup: ...
+    def __bool__(self) -> bool:
+        """
+        Are there any selections in the group.
+        """
+
+    def __contains__(self, item: typing.Any) -> bool: ...
+    def __copy__(self) -> SelectionShapeGroup: ...
+    def __deepcopy__(self, memo: dict) -> SelectionShapeGroup: ...
+    def __delitem__(self, index: typing.SupportsInt) -> None: ...
+    @typing.overload
+    def __eq__(self, other: SelectionShapeGroup) -> bool: ...
+    @typing.overload
+    def __eq__(self, other: typing.Any) -> bool | types.NotImplementedType: ...
+    @typing.overload
+    def __getitem__(
+        self, index: typing.SupportsInt
+    ) -> amulet.core.selection.shape.SelectionShape: ...
+    @typing.overload
+    def __getitem__(
+        self, item: slice
+    ) -> list[amulet.core.selection.shape.SelectionShape]: ...
+    def __iadd__(
+        self,
+        values: collections.abc.Iterable[amulet.core.selection.shape.SelectionShape],
+    ) -> typing.Any: ...
+    @typing.overload
+    def __init__(self) -> None:
+        """
+        Create an empty SelectionShapeGroup.
+
+        >>> SelectionShapeGroup()
+        """
+
+    @typing.overload
+    def __init__(
+        self, box_group: amulet.core.selection.box_group.SelectionBoxGroup
+    ) -> None: ...
+    @typing.overload
+    def __init__(
+        self,
+        shapes: collections.abc.Iterable[amulet.core.selection.shape.SelectionShape],
+    ) -> None:
+        """
+        Create a SelectionShapeGroup from the selections in the iterable.
+
+        >>> SelectionShapeGroup([
+        >>>     SelectionCuboid(0, 0, 0, 5, 5, 5),
+        >>>     SelectionEllipsoid(7.5, 0, 0, 2.5)
+        >>> ])
+        """
+
+    def __iter__(
+        self,
+    ) -> collections.abc.Iterator[amulet.core.selection.shape.SelectionShape]: ...
+    def __len__(self) -> int:
+        """
+        The number of :class:`SelectionShape` classes in the group.
+        """
+
+    def __repr__(self) -> str: ...
+    def __reversed__(
+        self,
+    ) -> collections.abc.Iterator[amulet.core.selection.shape.SelectionShape]: ...
+    def __setitem__(
+        self,
+        index: typing.SupportsInt,
+        item: amulet.core.selection.shape.SelectionShape,
+    ) -> None: ...
+    def almost_equal(self, other: SelectionShapeGroup) -> bool:
+        """
+        Returns True of the shape groups are equal or almost equal.
+        """
+
+    def append(self, value: amulet.core.selection.shape.SelectionShape) -> None: ...
+    def clear(self) -> None: ...
+    def count(self, value: amulet.core.selection.shape.SelectionShape) -> int: ...
+    def extend(
+        self,
+        values: collections.abc.Iterable[amulet.core.selection.shape.SelectionShape],
+    ) -> None: ...
+    def index(
+        self,
+        value: amulet.core.selection.shape.SelectionShape,
+        start: typing.SupportsInt = 0,
+        stop: typing.SupportsInt = 9223372036854775807,
+    ) -> int: ...
+    def insert(
+        self,
+        index: typing.SupportsInt,
+        item: amulet.core.selection.shape.SelectionShape,
+    ) -> None: ...
+    def pop(self, index: typing.SupportsInt = -1) -> typing.Any: ...
+    def remove(self, value: amulet.core.selection.shape.SelectionShape) -> None: ...
+    def reverse(self) -> None: ...
+    def serialise(self) -> str: ...
+    def voxelise(self) -> amulet.core.selection.box_group.SelectionBoxGroup:
+        """
+        Convert the shapes to a SelectionBoxGroup.
+        """

amulet/core/version/__init__.pyi

@@ -5,7 +5,7 @@ import types
 import typing
 from builtins import str as PlatformType
 
-__all__ = [
+__all__: list[str] = [
     "PlatformType",
     "PlatformVersionContainer",
     "VersionNumber",
@@ -51,9 +51,9 @@ class VersionNumber:
 
     def __contains__(self, arg0: typing.SupportsInt) -> bool: ...
     @typing.overload
-    def __eq__(self, arg0: VersionNumber) -> bool: ...
+    def __eq__(self, other: VersionNumber) -> bool: ...
     @typing.overload
-    def __eq__(self, arg0: typing.Any) -> bool | types.NotImplementedType: ...
+    def __eq__(self, other: typing.Any) -> bool | types.NotImplementedType: ...
     def __ge__(self, arg0: VersionNumber) -> bool: ...
     @typing.overload
     def __getitem__(self, item: typing.SupportsInt) -> int: ...
@@ -94,9 +94,9 @@ class VersionRange:
 
     __hash__: typing.ClassVar[None] = None  # type: ignore
     @typing.overload
-    def __eq__(self, arg0: VersionRange) -> bool: ...
+    def __eq__(self, other: VersionRange) -> bool: ...
     @typing.overload
-    def __eq__(self, arg0: typing.Any) -> bool | types.NotImplementedType: ...
+    def __eq__(self, other: typing.Any) -> bool | types.NotImplementedType: ...
     def __init__(
         self, platform: str, min_version: VersionNumber, max_version: VersionNumber
     ) -> None: ...