amulet-core 2.0a8__cp312-cp312-win_amd64.whl → 2.0.1.0.1297307203.19.43.34808.0a0__cp312-cp312-win_amd64.whl

amulet/utils/world_utils.py

@@ -1,102 +0,0 @@
-from __future__ import annotations
-
-import math
-from typing import Optional
-import numpy
-from numpy import ndarray, zeros, uint8
-from amulet.data_types import ChunkCoordinates
-
-
-def block_coords_to_chunk_coords(
-    *args: int, sub_chunk_size: int = 16
-) -> tuple[int, ...]:
-    """
-    Converts the supplied block coordinates into chunk coordinates
-
-    :param args: The coordinate of the block(s)
-    :param sub_chunk_size: The dimension of the chunk (Optional. Default 16)
-    :return: The resulting chunk coordinates in (x, z) order
-    """
-    return tuple(int(math.floor(coord / sub_chunk_size)) for coord in args)
-
-
-def chunk_coords_to_block_coords(
-    x: int, z: int, chunk_x_size: int = 16, chunk_z_size: int = 16
-) -> ChunkCoordinates:
-    """
-    Converts the supplied chunk coordinates into block coordinates
-
-    :param x: The x coordinate of the chunk
-    :param z: The z coordinate of the chunk
-    :param chunk_x_size: The dimension of the chunk in the x direction (Optional. Default 16)
-    :param chunk_z_size: The dimension of the chunk in the z direction (Optional. Default 16)
-    :return: The resulting block coordinates in (x, z) order
-    """
-    return x * chunk_x_size, z * chunk_z_size
-
-
-def chunk_coords_to_region_coords(cx: int, cz: int) -> ChunkCoordinates:
-    """
-    Converts the supplied chunk coordinates into region coordinates
-
-    :param cx: The x coordinate of the chunk
-    :param cz: The z coordinate of the chunk
-    :return: The resulting region coordinates in (x, z) order
-    """
-    return cx >> 5, cz >> 5
-
-
-def region_coords_to_chunk_coords(rx: int, rz: int) -> ChunkCoordinates:
-    """
-    Converts the supplied region coordinates into the minimum chunk coordinates of that region
-
-    :param rx: The x coordinate of the region
-    :param rz: The y coordinate of the region
-    :return: The resulting minimum chunk coordinates of that region in (x, z) order
-    """
-    return rx << 5, rz << 5
-
-
-def blocks_slice_to_chunk_slice(
-    blocks_slice: slice, chunk_shape: int, chunk_coord: int
-) -> slice:
-    """
-    Converts the supplied blocks slice into chunk slice
-
-    :param blocks_slice: The slice of the blocks
-    :param chunk_shape: The shape of the chunk in this direction
-    :param chunk_coord: The coordinate of the chunk in this direction
-    :return: The resulting chunk slice
-    """
-    return slice(
-        min(max(0, blocks_slice.start - chunk_coord * chunk_shape), chunk_shape),
-        min(max(0, blocks_slice.stop - chunk_coord * chunk_shape), chunk_shape),
-    )
-
-
-def from_nibble_array(arr: ndarray) -> ndarray:
-    """
-    Unpacks a flat nibble array into a full size numpy array
-
-    :param arr: The nibble array
-    :return: The resulting array
-    """
-    shape = arr.size
-
-    new_arr = zeros((shape * 2), dtype=uint8)
-
-    new_arr[::2] = arr & 0xF
-    new_arr[1::2] = arr >> 4
-
-    return new_arr
-
-
-def to_nibble_array(arr: ndarray) -> ndarray:
-    """
-    packs a full size numpy array into a nibble array.
-
-    :param arr: Full numpy array
-    :return: The nibble array
-    """
-    arr = arr.ravel()
-    return (arr[::2] + (arr[1::2] << 4)).astype(uint8)  # type: ignore

amulet/version.cpp

@@ -1,136 +0,0 @@
-#include <stdexcept>
-#include <cstdint>
-#include <compare>
-
-#include <amulet/version.hpp>
-
-
-namespace Amulet {
-    void VersionNumber::serialise(BinaryWriter& writer) const {
-        writer.writeNumeric<std::uint8_t>(1);
-        writer.writeNumeric<std::uint64_t>(vec.size());
-        for (const std::int64_t& v : vec){
-            writer.writeNumeric<std::int64_t>(v);
-        }
-    }
-    std::shared_ptr<VersionNumber> VersionNumber::deserialise(BinaryReader& reader){
-        auto version_number = reader.readNumeric<std::uint8_t>();
-        switch (version_number) {
-            case 1:
-            {
-                std::uint64_t count;
-                reader.readNumericInto(count);
-                std::vector<std::int64_t> vec(count);
-                for (size_t i = 0; i < count; i++) {
-                    reader.readNumericInto<std::int64_t>(vec[i]);
-                }
-                return std::make_shared<VersionNumber>(vec);
-            }
-            default:
-                throw std::invalid_argument("Unsupported version " + std::to_string(version_number));
-        }
-    }
-
-    std::int64_t VersionNumber::operator[](size_t index) const {
-        if (index >= vec.size()) {
-            return 0;
-        }
-        return vec[index];
-    }
-
-    std::string VersionNumber::toString() const {
-        std::ostringstream oss;
-        for (size_t i = 0; i < vec.size(); ++i) {
-            if (i > 0){
-                oss << '.';
-            }
-            oss << vec[i];
-        }
-        return oss.str();
-    }
-
-    std::vector<std::int64_t> VersionNumber::cropped_version() const {
-        bool found_non_zero = false;
-        std::vector<std::int64_t> out;
-        for (auto it = vec.rbegin(); it != vec.rend(); ++it) {
-            if (found_non_zero){
-                out.push_back(*it);
-            } else if (*it != 0) {
-                found_non_zero = true;
-                out.push_back(*it);
-            }
-        }
-        std::reverse(out.begin(), out.end());
-        return out;
-    }
-
-    std::vector<std::int64_t> VersionNumber::padded_version(size_t len) const {
-        std::vector<std::int64_t> out(len);
-        for (size_t i = 0; i < len; i++){
-            out[i] = (*this)[i];
-        }
-        return out;
-    }
-
-    void PlatformVersionContainer::serialise(BinaryWriter& writer) const {
-        writer.writeNumeric<std::uint8_t>(1);
-        writer.writeSizeAndBytes(platform);
-        version->serialise(writer);
-    }
-    std::shared_ptr<PlatformVersionContainer> PlatformVersionContainer::deserialise(BinaryReader& reader){
-        auto version_number = reader.readNumeric<std::uint8_t>();
-        switch (version_number) {
-        case 1:
-        {
-            std::string platform = reader.readSizeAndBytes();
-            auto version = VersionNumber::deserialise(reader);
-            return std::make_shared<PlatformVersionContainer>(platform, version);
-        }
-        default:
-            throw std::invalid_argument("Unsupported version " + std::to_string(version_number));
-        }
-    }
-
-    void VersionRange::serialise(BinaryWriter& writer) const {
-        writer.writeNumeric<std::uint8_t>(1);
-        writer.writeSizeAndBytes(platform);
-        min_version->serialise(writer);
-        max_version->serialise(writer);
-    }
-    std::shared_ptr<VersionRange> VersionRange::deserialise(BinaryReader& reader) {
-        auto version_number = reader.readNumeric<std::uint8_t>();
-        switch (version_number) {
-        case 1:
-        {
-            std::string platform = reader.readSizeAndBytes();
-            auto min_version = VersionNumber::deserialise(reader);
-            auto max_version = VersionNumber::deserialise(reader);
-            return std::make_shared<VersionRange>(platform, min_version, max_version);
-        }
-        default:
-            throw std::invalid_argument("Unsupported version " + std::to_string(version_number));
-        }
-    }
-
-    bool VersionRange::contains(const PlatformType& platform_, const VersionNumber& version) const {
-        return platform == platform_ && *min_version <= version && version <= *max_version;
-    }
-
-    void VersionRangeContainer::serialise(BinaryWriter& writer) const {
-        writer.writeNumeric<std::uint8_t>(1);
-        version_range->serialise(writer);
-    }
-    std::shared_ptr<VersionRangeContainer> VersionRangeContainer::deserialise(BinaryReader& reader) {
-        auto version_number = reader.readNumeric<std::uint8_t>();
-        switch (version_number) {
-        case 1:
-        {
-            return std::make_shared<VersionRangeContainer>(
-                VersionRange::deserialise(reader)
-            );
-        }
-        default:
-            throw std::invalid_argument("Unsupported version " + std::to_string(version_number));
-        }
-    }
-}

amulet/version.hpp

@@ -1,142 +0,0 @@
-#pragma once
-
-#include <cstdint>
-#include <vector>
-#include <string>
-#include <sstream>
-#include <memory>
-#include <algorithm>
-#include <initializer_list>
-
-#include <amulet/io/binary_reader.hpp>
-#include <amulet/io/binary_writer.hpp>
-
-
-namespace Amulet {
-    typedef std::string PlatformType;
-    class VersionNumber {
-        private:
-            std::vector<std::int64_t> vec;
-        public:
-            const std::vector<std::int64_t>& get_vector() const { return vec; }
-
-            VersionNumber(std::initializer_list<std::int64_t> vec) : vec(vec) {};
-            VersionNumber(const std::vector<std::int64_t>& vec) : vec(vec) {};
-
-            void serialise(BinaryWriter&) const;
-            static std::shared_ptr<VersionNumber> deserialise(BinaryReader&);
-
-            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(); };
-            size_t size() const { return vec.size(); };
-            std::int64_t operator[](size_t index) const;
-            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;
-            };
-            std::string toString() const;
-            std::vector<std::int64_t> cropped_version() const;
-            std::vector<std::int64_t> padded_version(size_t len) const;
-    };
-
-    class PlatformVersionContainer {
-        private:
-            PlatformType platform;
-            std::shared_ptr<VersionNumber> version;
-        public:
-            const PlatformType& get_platform() const { return platform; }
-            std::shared_ptr<VersionNumber> get_version() const { return version; }
-
-            template <typename versionT>
-            PlatformVersionContainer(
-                const PlatformType& platform,
-                const versionT& version
-            ) : 
-                platform(platform), 
-                version([&]{
-                    if constexpr (std::is_same_v<versionT, std::shared_ptr<VersionNumber>>){
-                        if (!version) { throw std::runtime_error("Version is nullptr"); }
-                        return version;
-                    }
-                    else {
-                        return std::make_shared<VersionNumber>(version);
-                    }
-                }())
-            {};
-
-            void serialise(BinaryWriter&) const;
-            static std::shared_ptr<PlatformVersionContainer> deserialise(BinaryReader&);
-
-            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;
-            };
-    };
-
-    class VersionRange {
-        private:
-            PlatformType platform;
-            std::shared_ptr<VersionNumber> min_version;
-            std::shared_ptr<VersionNumber> max_version;
-        public:
-            const PlatformType& get_platform() const { return platform; }
-            std::shared_ptr<VersionNumber> get_min_version() const { return min_version; }
-            std::shared_ptr<VersionNumber> get_max_version() const { return max_version; }
-
-            VersionRange(
-                const PlatformType& platform,
-                std::shared_ptr<VersionNumber> min_version,
-                std::shared_ptr<VersionNumber> max_version
-            ) :
-                platform(platform),
-                min_version(min_version),
-                max_version(max_version)
-            {
-                if (*min_version > *max_version) {
-                    throw std::invalid_argument("min_version must be less than or equal to max_version");
-                }
-            };
-
-            void serialise(BinaryWriter&) const;
-            static std::shared_ptr<VersionRange> deserialise(BinaryReader&);
-
-            bool contains(const PlatformType& platform_, const VersionNumber& version) const;
-    };
-
-    class VersionRangeContainer {
-        private:
-            std::shared_ptr<const VersionRange> version_range;
-        public:
-            std::shared_ptr<const VersionRange> get_version_range() const { return version_range; }
-
-            VersionRangeContainer(
-                std::shared_ptr<VersionRange> version_range
-            ): version_range(version_range) {}
-
-            void serialise(BinaryWriter&) const;
-            static std::shared_ptr<VersionRangeContainer> deserialise(BinaryReader&);
-    };
-}

amulet/version.py.cpp

@@ -1,281 +0,0 @@
-#include <sstream>
-
-#include <pybind11/pybind11.h>
-#include <pybind11/stl.h>
-#include <pybind11/operators.h>
-
-#include <amulet/collections/eq.py.hpp>
-#include <amulet/version.hpp>
-
-namespace py = pybind11;
-
-void init_version(py::module m_parent) {
-    auto m = m_parent.def_submodule("version");
-    py::options options;
-
-    m.attr("PlatformType") = py::module::import("builtins").attr("str");
-
-    py::class_<Amulet::VersionNumber, std::shared_ptr<Amulet::VersionNumber>> VersionNumber(m, "VersionNumber",
-        "This class is designed to store semantic versions and data versions and allow comparisons between them.\n"
-        "\n"
-        ">>> v1 = VersionNumber(1, 0, 0)\n"
-        ">>> v2 = VersionNumber(1, 0)\n"
-        ">>> assert v2 == v1\n"
-        "\n"
-        "This class should also be used to store single number data versions.\n"
-        ">>> v3 = VersionNumber(3578)"
-    );
-        options.disable_function_signatures();
-        VersionNumber.def(
-            py::init(
-                [](py::args v){
-                    return std::make_shared<Amulet::VersionNumber>(
-                        v.cast<std::vector<std::int64_t>>()
-                    );
-                }
-            ),
-            py::doc("__init__(self: amulet.version.VersionNumber, *args: typing.SupportsInt) -> None")
-        );
-
-        // Start collections.abc.Sequence
-        VersionNumber.def(
-            "__getitem__",
-            &Amulet::VersionNumber::operator[],
-            py::doc(
-                "__getitem__(*args, **kwargs)\n"
-                "Overloaded function.\n"
-                "1. __getitem__(self: amulet.version.VersionNumber, item: typing.SupportsInt) -> int\n"
-                "2. __getitem__(self: amulet.version.VersionNumber, item: slice) -> list[int]"
-            )
-        );
-        VersionNumber.def(
-            "__getitem__",
-            [](const Amulet::VersionNumber& self, const py::slice &slice) -> std::vector<std::int64_t> {
-                size_t start = 0, stop = 0, step = 0, slicelength = 0;
-                if (!slice.compute(self.size(), &start, &stop, &step, &slicelength)) {
-                    throw py::error_already_set();
-                }
-                std::vector<std::int64_t> out(slicelength);
-                for (size_t i = 0; i < slicelength; ++i) {
-                    out[i] = self[start];
-                    start += step;
-                }
-                return out;
-            }
-        );
-        options.enable_function_signatures();
-
-        VersionNumber.def(
-            "__repr__",
-            [](const Amulet::VersionNumber& self){
-                std::ostringstream oss;
-                auto& vec = self.get_vector();
-                oss << "VersionNumber(";
-                for (size_t i = 0; i < vec.size(); i++){
-                    if (i != 0){
-                        oss << ", ";
-                    }
-                    oss << vec[i];
-                }
-                oss << ")";
-                return oss.str();
-            }
-        );
-        VersionNumber.def(
-            py::pickle(
-                [](const Amulet::VersionNumber& self) {
-                    return py::bytes(Amulet::serialise(self));
-                },
-                [](py::bytes state){
-                    return Amulet::deserialise<Amulet::VersionNumber>(state.cast<std::string>());
-                }
-            )
-        );
-
-        VersionNumber.def(
-            "__len__",
-            &Amulet::VersionNumber::size
-        );
-
-        VersionNumber.def(
-            "__contains__",
-            [](const Amulet::VersionNumber& self, std::int64_t value) {
-                for (auto it = self.begin(); it != self.end(); it++){
-                    if (*it == value) return true;
-                }
-                return false;
-            }
-        );
-
-        VersionNumber.def(
-            "__iter__",
-            [](const Amulet::VersionNumber& self) {return py::make_iterator(self.begin(), self.end());},
-            py::keep_alive<0, 1>() /* Essential: keep object alive while iterator exists */
-        );
-
-        VersionNumber.def(
-            "__reversed__",
-            [](const Amulet::VersionNumber& self) {return py::make_iterator(self.rbegin(), self.rend());},
-            py::keep_alive<0, 1>() /* Essential: keep object alive while iterator exists */
-        );
-
-        VersionNumber.def(
-            "index",
-            [](const Amulet::VersionNumber& self, std::int64_t value, size_t start, size_t stop) {
-                start = std::min(start, self.size());
-                stop = std::min(stop, self.size());
-                for (size_t i = start; i < stop; i++){
-                    if (self[i] == value) return i;
-                }
-                throw py::value_error(std::to_string(value) + " is not in VersionNumber.");
-            },
-            py::arg("value"), py::arg("start") = 0, py::arg("stop") = std::numeric_limits<size_t>::max()
-        );
-
-        VersionNumber.def(
-            "count",
-            [](const Amulet::VersionNumber& self, std::int64_t value) {
-                size_t count = 0;
-                for (size_t i = 0; i < self.size(); i++){
-                    if (self[i] == value) ++count;
-                }
-                return count;
-            },
-            py::arg("value")
-        );
-
-        // End collections.abc.Sequence
-
-        VersionNumber.def(
-            "__str__",
-            &Amulet::VersionNumber::toString
-        );
-
-        Eq(VersionNumber);
-        Eq_default(VersionNumber);
-        VersionNumber.def(pybind11::self < pybind11::self);
-        VersionNumber.def(pybind11::self > pybind11::self);
-        VersionNumber.def(pybind11::self <= pybind11::self);
-        VersionNumber.def(pybind11::self >= pybind11::self);
-
-        VersionNumber.def(
-            "cropped_version",
-            [](const Amulet::VersionNumber& self) -> py::tuple {return py::cast(self.cropped_version());},
-            py::doc("The version number with trailing zeros cut off.")
-        );
-
-        VersionNumber.def(
-            "padded_version",
-            [](const Amulet::VersionNumber& self, size_t len) -> py::tuple {return py::cast(self.padded_version(len));},
-            py::doc("Get the version number padded with zeros to the given length."),
-            py::arg("len")
-        );
-
-        VersionNumber.def(
-            "__hash__",
-            [](const Amulet::VersionNumber& self) {
-                py::tuple py_tuple = py::cast(self.cropped_version());
-                return py::hash(py_tuple);
-            }
-        );
-
-    py::module::import("collections.abc").attr("Sequence").attr("register")(VersionNumber);
-
-
-    py::class_<Amulet::PlatformVersionContainer, std::shared_ptr<Amulet::PlatformVersionContainer>> PlatformVersionContainer(m, "PlatformVersionContainer");
-        PlatformVersionContainer.def(
-            py::init<
-                const Amulet::PlatformType&,
-                std::shared_ptr<Amulet::VersionNumber>
-            >(),
-            py::arg("platform"),
-            py::arg("version")
-        );
-        PlatformVersionContainer.def_property_readonly("platform", &Amulet::PlatformVersionContainer::get_platform);
-        PlatformVersionContainer.def_property_readonly("version", &Amulet::PlatformVersionContainer::get_version);
-        PlatformVersionContainer.def(
-            "__repr__",
-            [](const Amulet::PlatformVersionContainer& self){
-                return "PlatformVersionContainer(" +
-                    py::repr(py::cast(self.get_platform())).cast<std::string>() + ", " +
-                    py::repr(py::cast(self.get_version())).cast<std::string>() +
-                ")";
-            }
-        );
-        PlatformVersionContainer.def(
-            py::pickle(
-                [](const Amulet::PlatformVersionContainer& self) -> py::bytes {
-                    return py::bytes(Amulet::serialise(self));
-                },
-                [](py::bytes state){
-                    return Amulet::deserialise<Amulet::PlatformVersionContainer>(state.cast<std::string>());
-                }
-            )
-        );
-
-
-    py::class_<Amulet::VersionRange, std::shared_ptr<Amulet::VersionRange>> VersionRange(m, "VersionRange");
-        VersionRange.def(
-            py::init<
-                const Amulet::PlatformType&,
-                std::shared_ptr<Amulet::VersionNumber>,
-                std::shared_ptr<Amulet::VersionNumber>
-            >(),
-            py::arg("platform"),
-            py::arg("min_version"),
-            py::arg("max_version")
-        );
-        VersionRange.def_property_readonly("platform", &Amulet::VersionRange::get_platform);
-        VersionRange.def_property_readonly("min_version", &Amulet::VersionRange::get_min_version);
-        VersionRange.def_property_readonly("max_version", &Amulet::VersionRange::get_max_version);
-        VersionRange.def(
-            "contains",
-            &Amulet::VersionRange::contains
-        );
-        VersionRange.def(
-            "__repr__",
-            [](const Amulet::VersionRange& self){
-                return "VersionRange(" +
-                    py::repr(py::cast(self.get_platform())).cast<std::string>() + ", " +
-                    py::repr(py::cast(self.get_min_version())).cast<std::string>() + ", " +
-                    py::repr(py::cast(self.get_max_version())).cast<std::string>() +
-                ")";
-            }
-        );
-        VersionRange.def(
-            py::pickle(
-                [](const Amulet::VersionRange& self) -> py::bytes {
-                    return py::bytes(Amulet::serialise(self));
-                },
-                [](py::bytes state){
-                    return Amulet::deserialise<Amulet::VersionRange>(state.cast<std::string>());
-                }
-            )
-        );
-
-
-    py::class_<Amulet::VersionRangeContainer, std::shared_ptr<Amulet::VersionRangeContainer>> VersionRangeContainer(m, "VersionRangeContainer");
-        VersionRangeContainer.def(
-            py::init<
-                std::shared_ptr<Amulet::VersionRange>
-            >(),
-            py::arg("version_range")
-        );
-        VersionRangeContainer.def_property_readonly("version_range", &Amulet::VersionRangeContainer::get_version_range);
-        VersionRangeContainer.def(
-            "__repr__",
-            [](const Amulet::VersionRangeContainer& self){
-                return "VersionRangeContainer(" + py::repr(py::cast(self.get_version_range())).cast<std::string>() + ")";
-            }
-        );
-        VersionRangeContainer.def(
-            py::pickle(
-                [](const Amulet::VersionRangeContainer& self) -> py::bytes {
-                    return py::bytes(Amulet::serialise(self));
-                },
-                [](py::bytes state){
-                    return Amulet::deserialise<Amulet::VersionRangeContainer>(state.cast<std::string>());
-                }
-            )
-        );
-}