amulet-core 2.0a5__cp311-cp311-win_amd64.whl → 2.0a7__cp311-cp311-win_amd64.whl

amulet/utils/comment_json.py

@@ -0,0 +1,188 @@
+from json import JSONDecodeError, loads as json_loads
+from typing import TextIO, Union
+
+"""
+Some of the Bedrock json files contain comments which is not valid JSON and the standard json parser
+will throw errors. This will first try and use the vanilla json parser and fall back to the slower version if that fails.
+"""
+
+
+JSONValue = Union[str, int, float, bool, None, "JSONDict", "JSONList"]
+JSONDict = dict[str, JSONValue]
+JSONList = list[JSONValue]
+
+
+class CommentJSONDecodeError(JSONDecodeError):
+    pass
+
+
+def from_file(path: str) -> JSONValue:
+    with open(path) as f:
+        return load(f)
+
+
+def load(obj: TextIO) -> JSONValue:
+    return loads(obj.read())
+
+
+def loads(s: str) -> JSONValue:
+    try:
+        return json_loads(s)  # type: ignore
+    except JSONDecodeError:
+        return _loads(s)
+
+
+def _loads(text: str) -> JSONValue:
+    # given a valid MinecraftJSON string will return the values as python objects
+    # in this context MinecraftJSON is standard JSON but with comment blocks and
+    # line comments that would normally be illegal in standard JSON
+    _number = set("0123456789-")
+    _float = set("0123456789-.")
+    _whitespace = set(" \t\r\n")
+
+    def strip_whitespace(index: int) -> int:
+        # skips whitespace characters (<space>, <tab>, <charrage return> and <newline>)
+        # as well as block comments and line comments
+        while text[index] in _whitespace:
+            index += 1
+        if text[index] == "/":
+            if text[index + 1] == "/":
+                index += 2
+                while text[index] != "\n":
+                    index += 1
+                index = strip_whitespace(index)
+            elif text[index + 1] == "*":
+                index += 2
+                while text[index : index + 2] != "*/":
+                    index += 1
+                    if index + 1 >= len(text):
+                        raise JSONDecodeError(
+                            "expected */ but reached the end of file", text, index
+                        )
+                index += 2
+                index = strip_whitespace(index)
+            else:
+                raise JSONDecodeError(f"unexpected / at index {index}", text, index)
+        return index
+
+    def parse_json_recursive(index: int = 0) -> tuple[JSONValue, int]:
+        index = strip_whitespace(index)
+        if text[index] == "{":
+            index += 1
+            # dictionary
+            json_obj = {}
+            repeat = True
+            while repeat:
+                index = strip_whitespace(index)
+                # }"
+                if text[index] == '"':
+                    index += 1
+                    key = ""
+                    while text[index] != '"':
+                        key += text[index]
+                        index += 1
+                    index += 1
+
+                    index = strip_whitespace(index)
+
+                    if text[index] == ":":
+                        index += 1
+                    else:
+                        raise JSONDecodeError(
+                            f"expected : got {text[index]} at index {index}",
+                            text,
+                            index,
+                        )
+
+                    index = strip_whitespace(index)
+
+                    json_obj[key], index = parse_json_recursive(index)
+
+                    index = strip_whitespace(index)
+
+                    if text[index] == ",":
+                        index += 1
+                    else:
+                        repeat = False
+                else:
+                    repeat = False
+
+            if index >= len(text):
+                raise JSONDecodeError("expected } but reached end of file", text, index)
+            elif text[index] == "}":
+                index += 1
+            else:
+                raise JSONDecodeError(
+                    f"expected }} got {text[index]} at index {index}", text, index
+                )
+            return json_obj, index
+
+        elif text[index] == "[":
+            index += 1
+            # list
+            json_array = []
+            index = strip_whitespace(index)
+            repeat = text[index] != "]"
+            while repeat:
+                val, index = parse_json_recursive(index)
+                json_array.append(val)
+
+                index = strip_whitespace(index)
+
+                if text[index] == ",":
+                    index += 1
+                else:
+                    repeat = False
+                index = strip_whitespace(index)
+
+            if index >= len(text):
+                raise JSONDecodeError("expected ] but reached end of file", text, index)
+            elif text[index] == "]":
+                index += 1
+            else:
+                raise JSONDecodeError(
+                    f"expected ] got {text[index]} at index {index}", text, index
+                )
+            return json_array, index
+
+        elif text[index] == '"':
+            index += 1
+            # string
+            json_obj_list = []
+            while text[index] != '"':
+                json_obj_list.append(text[index])
+                index += 1
+            index += 1
+            return "".join(json_obj_list), index
+
+        elif text[index] in _number:
+            # number
+            json_obj_list = []
+            while text[index] in _float:
+                json_obj_list += text[index]
+                index += 1
+            if "." in json_obj_list:
+                return float("".join(json_obj_list)), index
+            else:
+                return int("".join(json_obj_list)), index
+
+        elif text[index] == "n" and text[index : index + 4] == "null":
+            index += 4
+            return None, index
+
+        elif text[index] == "t" and text[index : index + 4] == "true":
+            index += 4
+            return True, index
+
+        elif text[index] == "f" and text[index : index + 5] == "false":
+            index += 5
+            return False, index
+        else:
+            raise JSONDecodeError(
+                f'unexpected key {text[index]} at {index}. Expected {{, [, ", num, null, true or false',
+                text,
+                index,
+            )
+
+    # call recursive function and pass back python object
+    return parse_json_recursive()[0]

amulet/utils/matrix.py

@@ -1,4 +1,4 @@
-from typing import Tuple, Literal
+from typing import Literal
 import math
 import numpy
 from amulet.data_types import FloatTriplet, PointCoordinates
@@ -193,8 +193,8 @@ def inverse_transform_matrix(
 
 def decompose_transformation_matrix(
     matrix: numpy.ndarray,
-) -> Tuple[
-    Tuple[float, float, float], Tuple[float, float, float], Tuple[float, float, float]
+) -> tuple[
+    tuple[float, float, float], tuple[float, float, float], tuple[float, float, float]
 ]:
     """
     Decompose a 4x4 transformation matrix into scale, rotation and displacement tuples.

amulet/utils/numpy.hpp

@@ -0,0 +1,36 @@
+#pragma once
+
+#include <cstdint>
+#include <vector>
+#include <utility>
+#include <span>
+#include <unordered_map>
+
+
+namespace Amulet {
+    // dtypeT can be any numerical type.
+    // inverseT must be large enough to store the length of arr.
+    template <typename dtypeT, typename inverseT>
+    void unique_inverse(const std::span<dtypeT> arr, std::vector<dtypeT>& unique, std::span<inverseT>& inverse){
+        if (arr.size() != inverse.size()){
+            throw std::invalid_argument("arr and inverse must have the same size.");
+        }
+        if (unique.size()){
+            throw std::invalid_argument("unique must be empty.");
+        }
+        // Map from found values to their index in unique
+        std::unordered_map<dtypeT, inverseT> value_to_index;
+
+        for (inverseT i = 0; i < arr.size(); i++){
+            dtypeT value = arr[i];
+            auto it = value_to_index.find(value);
+            if (it == value_to_index.end()){
+                inverse[i] = unique.size();
+                value_to_index[value] = unique.size();
+                unique.push_back(value);
+            } else {
+                inverse[i] = it->second;
+            }
+        }
+    }
+}

amulet/utils/numpy_helpers.py

@@ -1,11 +1,11 @@
-from typing import Tuple, TypeVar
+from typing import TypeVar
 from collections.abc import Collection
 import numpy
 
 T = TypeVar("T")
 
 
-def brute_sort_objects_no_hash(data: Collection[T]) -> Tuple[list[T], numpy.ndarray]:
+def brute_sort_objects_no_hash(data: Collection[T]) -> tuple[list[T], numpy.ndarray]:
     unique: list[T] = []
     inverse = numpy.zeros(dtype=numpy.uint32, shape=len(data))
     for i, d in enumerate(data):

amulet/utils/world_utils.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 import math
-from typing import Tuple, Optional
+from typing import Optional
 import numpy
 from numpy import ndarray, zeros, uint8
 from amulet.data_types import ChunkCoordinates
@@ -9,7 +9,7 @@ from amulet.data_types import ChunkCoordinates
 
 def block_coords_to_chunk_coords(
     *args: int, sub_chunk_size: int = 16
-) -> Tuple[int, ...]:
+) -> tuple[int, ...]:
     """
     Converts the supplied block coordinates into chunk coordinates
 

amulet/version.py.cpp

@@ -0,0 +1,281 @@
+#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>());
+                }
+            )
+        );
+}

amulet/version.pyi

@@ -13,10 +13,8 @@ __all__ = [
 ]
 
 class PlatformVersionContainer:
-    def __getstate__(self) -> bytes: ...
     def __init__(self, platform: str, version: VersionNumber) -> None: ...
     def __repr__(self) -> str: ...
-    def __setstate__(self, arg0: bytes) -> None: ...
     @property
     def platform(self) -> str: ...
     @property
@@ -44,7 +42,6 @@ class VersionNumber:
     def __getitem__(self, item: typing.SupportsInt) -> int: ...
     @typing.overload
     def __getitem__(self, item: slice) -> list[int]: ...
-    def __getstate__(self) -> bytes: ...
     def __gt__(self, arg0: VersionNumber) -> bool: ...
     def __hash__(self) -> int: ...
     def __init__(self, *args: typing.SupportsInt) -> None: ...
@@ -54,7 +51,6 @@ class VersionNumber:
     def __lt__(self, arg0: VersionNumber) -> bool: ...
     def __repr__(self) -> str: ...
     def __reversed__(self) -> typing.Iterator[int]: ...
-    def __setstate__(self, arg0: bytes) -> None: ...
     def __str__(self) -> str: ...
     def count(self, value: int) -> int: ...
     def cropped_version(self) -> tuple:
@@ -71,12 +67,10 @@ class VersionNumber:
         """
 
 class VersionRange:
-    def __getstate__(self) -> bytes: ...
     def __init__(
         self, platform: str, min_version: VersionNumber, max_version: VersionNumber
     ) -> None: ...
     def __repr__(self) -> str: ...
-    def __setstate__(self, arg0: bytes) -> None: ...
     def contains(self, arg0: str, arg1: VersionNumber) -> bool: ...
     @property
     def max_version(self) -> VersionNumber: ...
@@ -86,9 +80,7 @@ class VersionRange:
     def platform(self) -> str: ...
 
 class VersionRangeContainer:
-    def __getstate__(self) -> bytes: ...
     def __init__(self, version_range: VersionRange) -> None: ...
     def __repr__(self) -> str: ...
-    def __setstate__(self, arg0: bytes) -> None: ...
     @property
     def version_range(self) -> VersionRange: ...

{amulet_core-2.0a5.dist-info → amulet_core-2.0a7.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: amulet-core
-Version: 2.0a5
+Version: 2.0a7
 Summary: A Python library for reading/writing Minecraft's various save formats.
 Home-page: https://www.amuletmc.com
 Author: James Clare, Ben Gothard et al.
@@ -10,8 +10,8 @@ Classifier: Programming Language :: Python :: 3
 Classifier: Operating System :: OS Independent
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown
-Requires-Dist: numpy~=1.21
-Requires-Dist: amulet-nbt~=4.0a2
+Requires-Dist: numpy~=2.0
+Requires-Dist: amulet-nbt~=4.0a3
 Requires-Dist: portalocker~=2.4
 Requires-Dist: amulet-leveldb~=1.0b0
 Requires-Dist: platformdirs~=3.1