amulet-core 2.0a9__1.AppleClang.15.0.0.15000309-cp313-cp313-macosx_11_0_universal2.whl

amulet/core/selection/group.pyi

@@ -0,0 +1,213 @@
+from __future__ import annotations
+
+import collections.abc
+import types
+import typing
+
+import amulet.core.selection.box
+
+__all__ = ["SelectionGroup"]
+
+class SelectionGroup:
+    """
+    A container for zero or more :class:`SelectionBox` instances.
+
+    This allows for non-rectangular and non-contiguous selections.
+    """
+
+    __hash__: typing.ClassVar[None] = None  # type: ignore
+    def __bool__(self) -> bool:
+        """
+        The number of :class:`SelectionBox` classes in the group.
+        """
+
+    @typing.overload
+    def __eq__(self, arg0: SelectionGroup) -> bool:
+        """
+        Does the contents of this :class:`SelectionGroup` match the other :class:`SelectionGroup`.
+
+        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.
+        :return: True if the boxes contained match.
+        """
+
+    @typing.overload
+    def __eq__(self, arg0: typing.Any) -> bool | types.NotImplementedType: ...
+    @typing.overload
+    def __init__(self) -> None:
+        """
+        Create an empty SelectionGroup.
+
+        >>> SelectionGroup()
+        """
+
+    @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))
+        """
+
+    @typing.overload
+    def __init__(
+        self, boxes: collections.abc.Iterable[amulet.core.selection.box.SelectionBox]
+    ) -> None:
+        """
+        Create a SelectionGroup from the boxes in the iterable.
+
+        >>> SelectionGroup([
+        >>>     SelectionBox(0, 0, 0, 1, 1, 1),
+        >>>     SelectionBox(1, 1, 1, 1, 1, 1)
+        >>> ])
+        """
+
+    def __iter__(self) -> typing.Iterator[amulet.core.selection.box.SelectionBox]:
+        """
+        An iterable of all the :class:`SelectionBox` classes in the group.
+        """
+
+    def __len__(self) -> int:
+        """
+        The number of :class:`SelectionBox` classes in the group.
+        """
+
+    def __repr__(self) -> str: ...
+    def __str__(self) -> str: ...
+    def contains_block(self, x: int, y: int, z: int) -> bool:
+        """
+        Is the block contained within the selection.
+
+        >>> selection1: AbstractBaseSelection
+        >>> (1, 2, 3) in selection1
+        True
+
+        :param x: The x coordinate of the block. Defined by the most negative corner.
+        :param y: The y coordinate of the block. Defined by the most negative corner.
+        :param z: The z coordinate of the block. Defined by the most negative corner.
+        :return: True if the block is in the selection.
+        """
+
+    def contains_point(self, x: float, y: float, z: float) -> bool:
+        """
+        Is the point contained within the selection.
+
+        >>> selection1: AbstractBaseSelection
+        >>> (1.5, 2.5, 3.5) in selection1
+        True
+
+        :param x: The x coordinate of the point.
+        :param y: The y coordinate of the point.
+        :param z: The z coordinate of the point.
+        :return: True if the point is in the selection.
+        """
+
+    @typing.overload
+    def intersects(self, other: amulet.core.selection.box.SelectionBox) -> bool:
+        """
+        Does this selection intersect ``other``.
+
+        :param other: The other selection.
+        :return: True if the selections intersect, False otherwise.
+        """
+
+    @typing.overload
+    def intersects(self, other: SelectionGroup) -> bool: ...
+    def translate(self, x: int, y: int, z: int) -> SelectionGroup:
+        """
+        Create a new :class:`SelectionGroup` 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.
+        :return: The new selection with the given offset.
+        """
+
+    @property
+    def bounding_box(self) -> amulet.core.selection.box.SelectionBox:
+        """
+        A SelectionBox containing this entire selection.
+
+        :raises RuntimeError: If there are no boxes in the selection.
+        """
+
+    @property
+    def bounds(self) -> tuple[tuple[int, int, int], tuple[int, int, int]]:
+        """
+        The minimum and maximum x, y and z coordinates in the selection.
+
+        :raises RuntimeError: If there are no boxes in the selection.
+        """
+
+    @property
+    def max(self) -> tuple[int, int, int]:
+        """
+        The maximum x, y and z coordinates in the selection.
+
+        :raises RuntimeError: If there are no boxes in the selection.
+        """
+
+    @property
+    def max_x(self) -> int:
+        """
+        The maximum x coordinate in the selection.
+
+        :raises RuntimeError: If there are no boxes in the selection.
+        """
+
+    @property
+    def max_y(self) -> int:
+        """
+        The maximum y coordinate in the selection.
+
+        :raises RuntimeError: If there are no boxes in the selection.
+        """
+
+    @property
+    def max_z(self) -> int:
+        """
+        The maximum z coordinate in the selection.
+
+        :raises RuntimeError: If there are no boxes in the selection.
+        """
+
+    @property
+    def min(self) -> tuple[int, int, int]:
+        """
+        The minimum x, y and z coordinates in the selection.
+
+        :raises RuntimeError: If there are no boxes in the selection.
+        """
+
+    @property
+    def min_x(self) -> int:
+        """
+        The minimum x coordinate in the selection.
+
+        :raises RuntimeError: If there are no boxes in the selection.
+        """
+
+    @property
+    def min_y(self) -> int:
+        """
+        The minimum y coordinate in the selection.
+
+        :raises RuntimeError: If there are no boxes in the selection.
+        """
+
+    @property
+    def min_z(self) -> int:
+        """
+        The minimum z coordinate in the selection.
+
+        :raises RuntimeError: If there are no boxes in the selection.
+        """
+
+    @property
+    def selection_boxes(
+        self,
+    ) -> typing.Iterator[amulet.core.selection.box.SelectionBox]:
+        """
+        An iterator of the :class:`SelectionBox` instances stored for this group.
+        """

amulet/core/version/__init__.pyi

@@ -0,0 +1,134 @@
+from __future__ import annotations
+
+import types
+import typing
+from builtins import str as PlatformType
+
+__all__ = [
+    "PlatformType",
+    "PlatformVersionContainer",
+    "VersionNumber",
+    "VersionRange",
+    "VersionRangeContainer",
+]
+
+class PlatformVersionContainer:
+    """
+    A class storing platform identifier and version number.
+    Thread safe.
+    """
+
+    def __init__(self, platform: str, version: VersionNumber) -> None: ...
+    def __repr__(self) -> str: ...
+    @property
+    def platform(self) -> str:
+        """
+        Get the platform identifier.
+        """
+
+    @property
+    def version(self) -> VersionNumber:
+        """
+        Get the version number.
+        """
+
+class VersionNumber:
+    """
+    This class is designed to store semantic versions and data versions and allow comparisons between them.
+    It is a wrapper around std::vector<std::int64_t> with special comparison handling.
+    The version can contain zero to max(int64) values.
+    Undefined trailing values are implied zeros. 1.1 == 1.1.0
+    All methods are thread safe.
+
+    >>> v1 = VersionNumber(1, 0, 0)
+    >>> v2 = VersionNumber(1, 0)
+    >>> assert v2 == v1
+
+    This class should also be used to store single number data versions.
+    >>> v3 = VersionNumber(3578)
+    """
+
+    def __contains__(self, arg0: int) -> bool: ...
+    @typing.overload
+    def __eq__(self, arg0: VersionNumber) -> bool: ...
+    @typing.overload
+    def __eq__(self, arg0: typing.Any) -> bool | types.NotImplementedType: ...
+    def __ge__(self, arg0: VersionNumber) -> bool: ...
+    @typing.overload
+    def __getitem__(self, item: typing.SupportsInt) -> int: ...
+    @typing.overload
+    def __getitem__(self, item: slice) -> list[int]: ...
+    def __gt__(self, arg0: VersionNumber) -> bool: ...
+    def __hash__(self) -> int: ...
+    def __init__(self, *args: typing.SupportsInt) -> None: ...
+    def __iter__(self) -> typing.Iterator[int]: ...
+    def __le__(self, arg0: VersionNumber) -> bool: ...
+    def __len__(self) -> int: ...
+    def __lt__(self, arg0: VersionNumber) -> bool: ...
+    def __repr__(self) -> str: ...
+    def __reversed__(self) -> typing.Iterator[int]: ...
+    def __str__(self) -> str: ...
+    def count(self, value: int) -> int: ...
+    def cropped_version(self) -> list[int]:
+        """
+        The version number with trailing zeros cut off.
+        """
+
+    def index(
+        self, value: int, start: int = 0, stop: int = 18446744073709551615
+    ) -> int: ...
+    def padded_version(self, len: int) -> list[int]:
+        """
+        Get the version number cropped or padded with zeros to the given length.
+        """
+
+class VersionRange:
+    """
+    A class storing platform identifier and minimum and maximum version numbers.
+    Thread safe.
+    """
+
+    __hash__: typing.ClassVar[None] = None  # type: ignore
+    @typing.overload
+    def __eq__(self, arg0: VersionRange) -> bool: ...
+    @typing.overload
+    def __eq__(self, arg0: typing.Any) -> bool | types.NotImplementedType: ...
+    def __init__(
+        self, platform: str, min_version: VersionNumber, max_version: VersionNumber
+    ) -> None: ...
+    def __repr__(self) -> str: ...
+    def contains(self, arg0: str, arg1: VersionNumber) -> bool:
+        """
+        Check if the platform is equal and the version number is within the range.
+        """
+
+    @property
+    def max_version(self) -> VersionNumber:
+        """
+        The maximum version number
+        """
+
+    @property
+    def min_version(self) -> VersionNumber:
+        """
+        The minimum version number
+        """
+
+    @property
+    def platform(self) -> str:
+        """
+        The platform identifier.
+        """
+
+class VersionRangeContainer:
+    """
+    A class that contains a version range.
+    """
+
+    def __init__(self, version_range: VersionRange) -> None: ...
+    def __repr__(self) -> str: ...
+    @property
+    def version_range(self) -> VersionRange:
+        """
+        The version range.
+        """

amulet/core/version/version.hpp

@@ -0,0 +1,204 @@
+#pragma once
+
+#include <algorithm>
+#include <cstdint>
+#include <initializer_list>
+#include <memory>
+#include <sstream>
+#include <string>
+#include <vector>
+
+#include <amulet/io/binary_reader.hpp>
+#include <amulet/io/binary_writer.hpp>
+
+#include <amulet/core/dll.hpp>
+
+namespace Amulet {
+
+typedef std::string PlatformType;
+
+// This class is designed to store semantic versions and data versions and allow comparisons between them.
+// It is a wrapper around std::vector<std::int64_t> with special comparison handling.
+// The version can contain zero to max(int64) values.
+// Undefined trailing values are implied zeros. 1.1 == 1.1.0
+// All methods are thread safe.
+class VersionNumber {
+private:
+    std::vector<std::int64_t> _vec;
+
+public:
+    // Get the underlying vector.
+    // Thread safe.
+    const std::vector<std::int64_t>& get_vector() const { return _vec; }
+
+    // Constructors
+    template <typename... Args>
+        requires std::is_constructible_v<std::vector<std::int64_t>, Args...>
+    VersionNumber(Args&&... args)
+        : _vec(std::forward<Args>(args)...)
+    {
+    }
+
+    VersionNumber(std::initializer_list<std::int64_t> args)
+        : _vec(args)
+    {
+    }
+
+    AMULET_CORE_EXPORT void serialise(BinaryWriter&) const;
+    AMULET_CORE_EXPORT static VersionNumber deserialise(BinaryReader&);
+
+    // Iterators
+    std::vector<std::int64_t>::const_iterator begin() const { return _vec.begin(); }
+    std::vector<std::int64_t>::const_iterator end() const { return _vec.end(); }
+    std::vector<std::int64_t>::const_reverse_iterator rbegin() const { return _vec.rbegin(); }
+    std::vector<std::int64_t>::const_reverse_iterator rend() const { return _vec.rend(); }
+
+    // Capacity
+    size_t size() const { return _vec.size(); }
+
+    // Element access
+    std::int64_t operator[](size_t index) const {
+        if (index >= _vec.size()) {
+            return 0;
+        }
+        return _vec[index];
+    }
+
+    // Comparison
+    auto operator<=>(const VersionNumber& other) const
+    {
+        size_t max_len = std::max(_vec.size(), other.size());
+        std::int64_t v1, v2;
+        for (size_t i = 0; i < max_len; i++) {
+            v1 = (*this)[i];
+            v2 = other[i];
+            if (v1 < v2) {
+                // Less than
+                return std::strong_ordering::less;
+            }
+            if (v1 > v2) {
+                // Greater than
+                return std::strong_ordering::greater;
+            }
+        }
+        // equal
+        return std::strong_ordering::equal;
+    }
+    bool operator==(const VersionNumber& other) const
+    {
+        return (*this <=> other) == 0;
+    }
+
+    // Convert the value to its string representation eg "1.1"
+    AMULET_CORE_EXPORT std::string toString() const;
+
+    // The version number with trailing zeros cut off.
+    AMULET_CORE_EXPORT std::vector<std::int64_t> cropped_version() const;
+
+    // Get the version number cropped or padded with zeros to the given length.
+    AMULET_CORE_EXPORT std::vector<std::int64_t> padded_version(size_t len) const;
+};
+
+// A class storing platform identifier and version number.
+// Thread safe.
+class PlatformVersionContainer {
+private:
+    PlatformType _platform;
+    VersionNumber _version;
+
+public:
+    // Get the platform identifier.
+    const PlatformType& get_platform() const { return _platform; }
+
+    // Get the version number.
+    const VersionNumber& get_version() const { return _version; }
+
+    template <typename PlatformT, typename VersionNumberT>
+    PlatformVersionContainer(
+        PlatformT&& platform,
+        VersionNumberT&& version)
+        : _platform(std::forward<PlatformT>(platform))
+        , _version(std::forward<VersionNumberT>(version))
+    {
+    }
+
+    AMULET_CORE_EXPORT void serialise(BinaryWriter&) const;
+    AMULET_CORE_EXPORT static PlatformVersionContainer deserialise(BinaryReader&);
+
+    // Comparison operators
+    auto operator<=>(const PlatformVersionContainer& other) const
+    {
+        auto cmp = _platform <=> other._platform;
+        if (cmp != 0) {
+            return cmp;
+        }
+        return _version <=> other._version;
+    }
+    bool operator==(const PlatformVersionContainer& other) const
+    {
+        return (*this <=> other) == 0;
+    }
+};
+
+// A class storing platform identifier and minimum and maximum version numbers.
+// Thread safe.
+class VersionRange {
+private:
+    PlatformType _platform;
+    VersionNumber _min_version;
+    VersionNumber _max_version;
+
+public:
+    // Get the platform identifier.
+    const PlatformType& get_platform() const { return _platform; }
+
+    // Get the minimum version number
+    const VersionNumber& get_min_version() const { return _min_version; }
+
+    // Get the maximum version number
+    const VersionNumber& get_max_version() const { return _max_version; }
+
+    template <typename PlatformT, typename MinVersionT, typename MaxVersionT>
+    VersionRange(
+        PlatformT&& platform,
+        MinVersionT&& min_version,
+        MaxVersionT&& max_version)
+        : _platform(std::forward<PlatformT>(platform))
+        , _min_version(std::forward<MinVersionT>(min_version))
+        , _max_version(std::forward<MaxVersionT>(max_version))
+    {
+        if (_min_version > _max_version) {
+            throw std::invalid_argument("min_version must be less than or equal to max_version");
+        }
+    }
+
+    AMULET_CORE_EXPORT void serialise(BinaryWriter&) const;
+    AMULET_CORE_EXPORT static VersionRange deserialise(BinaryReader&);
+
+    // Check if the platform is equal and the version number is within the range.
+    AMULET_CORE_EXPORT bool contains(const PlatformType& platform_, const VersionNumber& version) const;
+
+    // Equality operator
+    AMULET_CORE_EXPORT bool operator==(const VersionRange&) const;
+};
+
+// A class that contains a version range.
+class VersionRangeContainer {
+private:
+    VersionRange _version_range;
+
+public:
+    // Get the version range.
+    const VersionRange& get_version_range() const { return _version_range; }
+
+    template <typename VersionRangeT>
+    VersionRangeContainer(
+        VersionRangeT&& version_range)
+        : _version_range(std::forward<VersionRangeT>(version_range))
+    {
+    }
+
+    AMULET_CORE_EXPORT void serialise(BinaryWriter&) const;
+    AMULET_CORE_EXPORT static VersionRangeContainer deserialise(BinaryReader&);
+};
+}

amulet_core-2.0a9.dist-info/METADATA

@@ -0,0 +1,109 @@
+Metadata-Version: 2.4
+Name: amulet-core
+Version: 2.0a9
+Summary: A Python library for reading/writing Minecraft's various save formats.
+Author: James Clare, Ben Gothard
+Project-URL: Homepage, https://www.amuletmc.com
+Project-URL: Repository, https://github.com/Amulet-Team/Amulet-Core
+Project-URL: Issues, https://github.com/Amulet-Team/Amulet-Core/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+Requires-Dist: amulet-compiler-target==1.0
+Requires-Dist: numpy~=2.0
+Requires-Dist: amulet-compiler-version==1.3.0.309027957683952396889703.15.0.0.15000309
+Requires-Dist: amulet_pybind11_extensions~=1.0.0.0
+Requires-Dist: amulet_io~=1.0.0.0
+Requires-Dist: amulet_nbt==4.0.0a20
+Provides-Extra: docs
+Requires-Dist: Sphinx>=1.7.4; extra == "docs"
+Requires-Dist: sphinx-autodoc-typehints>=1.3.0; extra == "docs"
+Requires-Dist: sphinx_rtd_theme>=0.3.1; extra == "docs"
+Provides-Extra: dev
+Requires-Dist: setuptools>=42; extra == "dev"
+Requires-Dist: versioneer; extra == "dev"
+Requires-Dist: packaging; extra == "dev"
+Requires-Dist: wheel; extra == "dev"
+Requires-Dist: pybind11[global]==2.13.6; extra == "dev"
+Requires-Dist: amulet_pybind11_extensions~=1.0; extra == "dev"
+Requires-Dist: pybind11_stubgen>=2.5.4; extra == "dev"
+Requires-Dist: black>=22.3; extra == "dev"
+Requires-Dist: isort; extra == "dev"
+Requires-Dist: autoflake; extra == "dev"
+Requires-Dist: mypy; extra == "dev"
+Requires-Dist: types-pyinstaller; extra == "dev"
+Requires-Dist: amulet-test-utils~=1.1; extra == "dev"
+Dynamic: requires-dist
+
+# Amulet Core
+
+![Build](../../workflows/Build/badge.svg)
+![Unittests](../../workflows/Unittests/badge.svg?event=push)
+![Stylecheck](../../workflows/Stylecheck/badge.svg?event=push)
+[![Documentation](https://readthedocs.org/projects/amulet-core/badge)](https://amulet-core.readthedocs.io)
+
+A Python 3 library to read and write data from Minecraft's various save formats.
+
+This library provides the main world editing functionality for Amulet Map Editor
+
+#### If you are looking for the actual editor it can be found at [Amulet Map Editor](https://github.com/Amulet-Team/Amulet-Map-Editor)
+
+
+## Documentation
+
+Our online documentation can be found here: https://amulet-core.readthedocs.io
+
+## Installing
+1) Install Python 3.7
+2) We recommend setting up a [python virtual environment](https://docs.python.org/3/tutorial/venv.html) so you don't run into issues with dependency conflicts.
+3) run `pip install amulet-core` to install the library and all its dependencies.
+
+## Dependencies
+
+This library uses a number of other libraries. These will be automatically installed when running the command above.
+- Numpy
+- [Amulet_NBT](https://github.com/Amulet-Team/Amulet-NBT)
+- [PyMCTranslate](https://github.com/gentlegiantJGC/PyMCTranslate)
+
+## Contributing
+
+### For Development
+Download the code to your computer, install python and run the following command from the root directory.
+run `pip install -e .[dev]`
+This command will install the library in development mode with the libraries required for development.
+- [Black](https://github.com/ambv/black) (Required for formatting)
+  - Must be run before pushing a Pull Request
+
+For information about contributing to this project, please see the contribution section [below](#contributing)
+
+### Code Formatting
+For code formatting, we use the formatting utility [black](https://github.com/psf/black). 
+To run it, run the following command from your favorite terminal after installing: `black amulet tests`
+
+In order for your pull request to be accepted, this command must be run to format every file.
+
+### Building the Documentation
+To build the documentation locally, run the following command: `make html` and then navigate to the
+generated directory `docs_build/html` in your favorite web browser
+
+### Branch Naming
+Branches should be created when a certain bug or feature may take multiple attempts to fix. Naming
+them should follow the following convention (even for forked repositories when a pull request is being made):
+
+* For features, use: `impl-<feature name>`
+* For bug fixes, use: `bug-<bug tracker ID>`
+* For improvements/rewrites, use: `improv-<feature name>`
+* For prototyping, use: `proto-<feature name>`
+
+### Pull Requests
+We ask that submitted Pull Requests give moderately detailed notes about the changes and explain 
+any changes that were made to the program outside of those directly related to the feature/bug-fix.
+Make sure to run all tests and formatting otherwise we cannot accept your pull request.
+
+_Note: We will also re-run all tests before reviewing, this is to mitigate additional changes/commits
+needed to pass all tests._
+
+Once a Pull Request is submitted, we will mark the request for review, once that is done, we will
+review the changes and provide any notes/things to change. Once all additional changes have been made,
+we will merge the request.