amulet-core 2.0a6__cp312-cp312-win_amd64.whl → 2.0a7__cp312-cp312-win_amd64.whl

amulet/level/java/anvil/_sector_manager.pyi

@@ -1,142 +0,0 @@
-from __future__ import annotations
-
-import threading as threading
-import typing
-from typing import NamedTuple
-
-from _bisect import bisect_left, bisect_right
-
-__all__ = [
-    "NamedTuple",
-    "NoValidSector",
-    "Sector",
-    "SectorManager",
-    "bisect_left",
-    "bisect_right",
-    "threading",
-]
-
-class NoValidSector(Exception):
-    """
-    An error for when there is no sector large enough and the region cannot be resized.
-    """
-
-class Sector(tuple):
-    """
-    Sector(start, stop)
-    """
-
-    __slots__: typing.ClassVar[tuple] = tuple()
-    _field_defaults: typing.ClassVar[dict] = {}
-    _fields: typing.ClassVar[tuple] = ("start", "stop")
-    @staticmethod
-    def __new__(_cls, start: ForwardRef("int"), stop: ForwardRef("int")):
-        """
-        Create new instance of Sector(start, stop)
-        """
-
-    @classmethod
-    def _make(cls, iterable):
-        """
-        Make a new Sector object from a sequence or iterable
-        """
-
-    def __getnewargs__(self):
-        """
-        Return self as a plain tuple.  Used by copy and pickle.
-        """
-
-    def __repr__(self):
-        """
-        Return a nicely formatted representation string
-        """
-
-    def _asdict(self):
-        """
-        Return a new dict which maps field names to their values.
-        """
-
-    def _replace(self, **kwds):
-        """
-        Return a new Sector object replacing specified fields with new values
-        """
-
-    def contains(self, other: Sector) -> bool:
-        """
-        Is the other sector entirely within this sector.
-        """
-
-    def intersects(self, other: Sector) -> bool:
-        """
-        Do the two sectors intersect each other.
-        """
-
-    def neighbours(self, other: Sector) -> bool:
-        """
-        Do the two sectors neighbour but not intersect.
-        """
-
-    def split(self, other: Sector) -> list[Sector]:
-        """
-
-        Split this sector around another sector.
-        The other sector must be contained within this sector
-
-        :param other: The other sector to split around.
-        :return: A list of 0-2 sectors
-
-        """
-
-    @property
-    def length(self) -> int: ...
-
-class SectorManager:
-    """
-    A class to manage a sequence of memory.
-    """
-
-    def __init__(self, start: int, stop: int, resizable: bool = True):
-        """
-
-        :param start: The start of the memory region
-        :param stop: The end of the memory region
-        :param resizable: Can the region be resized
-
-        """
-
-    def _add_size_sector(self, sector: Sector) -> None: ...
-    def free(self, sector: Sector) -> None:
-        """
-
-        Free a reserved sector.
-        The sector must match exactly a sector previously reserved.
-
-        :param sector: The sector to free
-
-        """
-
-    def reserve(self, sector: Sector) -> None:
-        """
-
-        Mark a section as reserved.
-        If you don't know exactly where the sector is use `reserve_space` to find and reserve a new sector
-
-        :param sector: The sector to reserve
-
-        """
-
-    def reserve_space(self, length: int) -> Sector:
-        """
-
-        Find and reserve a memory location large enough to fit the requested memory.
-
-        :param length: The length of the memory region to reserve
-        :return: The index of the start of the reserved memory region
-
-        """
-
-    @property
-    def sectors(self) -> list[Sector]:
-        """
-        A list of reserved sectors. Ordered by their start location.
-        """

amulet/pybind11/python.hpp

@@ -1,14 +0,0 @@
-#pragma once
-
-#include <pybind11/pybind11.h>
-
-namespace py = pybind11;
-
-namespace pybind11 {
-	inline bool equals(
-	    const py::handle l,
-	    const py::handle r
-	){
-		return PyObject_RichCompare(l.ptr(), r.ptr(), Py_EQ);
-	}
-}

amulet/utils/call_spec/__init__.pyi

@@ -1,53 +0,0 @@
-from __future__ import annotations
-
-from amulet.utils.call_spec._call_spec import (
-    AbstractArg,
-    AbstractHashableArg,
-    BoolArg,
-    BytesArg,
-    CallableArg,
-    CallSpec,
-    ConstantArg,
-    DictArg,
-    DirectoryPathArg,
-    FilePathArg,
-    FloatArg,
-    HashableCallableArg,
-    HashableTupleArg,
-    HashableUnionArg,
-    IntArg,
-    PositionalArgs,
-    SequenceArg,
-    StringArg,
-    TupleArg,
-    UnionArg,
-    callable_spec,
-    method_spec,
-)
-
-from . import _call_spec
-
-__all__ = [
-    "AbstractArg",
-    "AbstractHashableArg",
-    "BoolArg",
-    "BytesArg",
-    "CallSpec",
-    "CallableArg",
-    "ConstantArg",
-    "DictArg",
-    "DirectoryPathArg",
-    "FilePathArg",
-    "FloatArg",
-    "HashableCallableArg",
-    "HashableTupleArg",
-    "HashableUnionArg",
-    "IntArg",
-    "PositionalArgs",
-    "SequenceArg",
-    "StringArg",
-    "TupleArg",
-    "UnionArg",
-    "callable_spec",
-    "method_spec",
-]

amulet/utils/call_spec/_call_spec.pyi

@@ -1,272 +0,0 @@
-"""
-This modules contains classes to notify other code of the call specification for a function.
-The aim is to support generating GUIs without having to manually program a GUI to handle the function call.
-"""
-
-from __future__ import annotations
-
-import abc
-import typing
-from abc import ABC, abstractmethod
-from collections.abc import Sequence
-from typing import Any, ParamSpec, Protocol, TypeVar, cast, overload, runtime_checkable
-
-__all__ = [
-    "ABC",
-    "AbstractArg",
-    "AbstractHashableArg",
-    "Any",
-    "BoolArg",
-    "BytesArg",
-    "CallSpec",
-    "CallableArg",
-    "ConstantArg",
-    "DictArg",
-    "DirectoryPathArg",
-    "DocumentationArg",
-    "FilePathArg",
-    "FloatArg",
-    "HashableCallableArg",
-    "HashableTupleArg",
-    "HashableUnionArg",
-    "IntArg",
-    "P",
-    "ParamSpec",
-    "PositionalArgs",
-    "Protocol",
-    "R",
-    "Sequence",
-    "SequenceArg",
-    "StringArg",
-    "TupleArg",
-    "TypeVar",
-    "TypedCallable",
-    "TypedMethod",
-    "UnionArg",
-    "abstractmethod",
-    "callable_spec",
-    "cast",
-    "method_spec",
-    "overload",
-    "runtime_checkable",
-]
-
-class AbstractArg(abc.ABC):
-    """
-    The base class for all arguments.
-    """
-
-    def __init__(self, *args: typing.Any, **kwargs: typing.Any) -> None: ...
-
-class AbstractHashableArg(AbstractArg, abc.ABC):
-    """
-    A base class for all arguments that are hashable.
-    """
-
-class BoolArg(AbstractHashableArg):
-    """
-    A bool argument
-    """
-
-    def __init__(self, default: bool = False) -> None: ...
-
-class BytesArg(AbstractHashableArg):
-    """
-    A bytes argument
-    """
-
-    def __init__(self, default: bytes = ...) -> None: ...
-
-class CallSpec:
-    """
-    Arguments and keyword arguments that should be unpacked to call a function.
-    """
-
-    def __init__(self, *args: AbstractArg, **kwargs: AbstractArg) -> None: ...
-
-class CallableArg(AbstractArg):
-    """
-    An argument generated by a function.
-        This can be used to create instances of classes.
-        kwargs specify the arguments to pass to the function.
-
-    """
-
-    def __init__(
-        self,
-        func: typing.Callable[..., typing.Any],
-        *args: AbstractArg,
-        **kwargs: AbstractArg,
-    ) -> None: ...
-
-class ConstantArg(AbstractArg):
-    """
-    A constant argument.
-        Use this for fixed values.
-
-    """
-
-    def __init__(self, value: typing.Any) -> None: ...
-
-class DictArg(AbstractArg):
-    """
-    A dictionary argument
-    """
-
-    def __init__(self, key: AbstractHashableArg, value: AbstractArg) -> None: ...
-
-class DirectoryPathArg(StringArg):
-    """
-    A path to a directory on disk. Converts to a string.
-    """
-
-class DocumentationArg(AbstractArg):
-    """
-    A way to add documentation for an argument.
-    """
-
-    def __init__(
-        self, arg: AbstractArg, name: str | None = None, description: str | None = None
-    ) -> None:
-        """
-        Construct a DocumentationArg instance.
-
-                :param arg: The argument this documentation relates to.
-                :param name: The short name for the argument.
-                :param description: A longer description for the argument.
-
-        """
-
-class FilePathArg(StringArg):
-    """
-    A path to a file on disk. Converts to a string.
-    """
-
-class FloatArg(AbstractHashableArg):
-    """
-    A float argument
-    """
-
-    def __init__(
-        self,
-        default: float = 0,
-        min_value: float | None = None,
-        max_value: float | None = None,
-    ) -> None: ...
-
-class HashableCallableArg(AbstractHashableArg):
-    """
-    An argument generated by a function.
-        This can be used to create instances of classes.
-        kwargs specify the arguments to pass to the function.
-
-    """
-
-    def __init__(
-        self, func: typing.Callable[..., Hashable], call_spec: CallSpec
-    ) -> None: ...
-
-class HashableTupleArg(AbstractArg):
-    """
-    A tuple argument where all elements are hashable.
-    """
-
-    def __init__(self, *args: AbstractHashableArg) -> None: ...
-
-class HashableUnionArg(AbstractArg):
-    """
-    The object must match one of the types in args
-    """
-
-    def __init__(self, *args: AbstractHashableArg) -> None: ...
-
-class IntArg(AbstractHashableArg):
-    """
-    An int argument
-    """
-
-    def __init__(
-        self,
-        default: int = 0,
-        min_value: int | None = None,
-        max_value: int | None = None,
-    ) -> None: ...
-
-class PositionalArgs(SequenceArg):
-    """
-    A sequence of arguments that should be unpacked into the container.
-        This is useful when a CallableArg can take a variable number of an argument.
-
-    """
-
-class SequenceArg(AbstractArg):
-    """
-
-    A sequence of other arguments.
-    Each element must match element_type.
-    length must be a positive integer for a fixed length or None for unbounded length.
-
-    """
-
-    def __init__(
-        self,
-        element_type: AbstractArg,
-        default: typing.Sequence[AbstractArg] = tuple(),
-        min_length: int | None = None,
-        max_length: int | None = None,
-    ) -> None: ...
-
-class StringArg(AbstractHashableArg):
-    """
-    A string argument
-    """
-
-    def __init__(self, default: str) -> None: ...
-
-class TupleArg(AbstractArg):
-    """
-    A tuple argument
-    """
-
-    def __init__(self, *args: AbstractArg) -> None: ...
-
-class TypedCallable(typing.Protocol):
-    __non_callable_proto_members__: typing.ClassVar[set] = {"call_spec"}
-    _is_runtime_protocol: typing.ClassVar[bool] = True
-    @classmethod
-    def __subclasshook__(cls, other): ...
-    def __call__(self, *args: P.args, **kwargs: P.kwargs) -> R: ...
-    def __init__(self, *args, **kwargs): ...
-
-class TypedMethod(typing.Protocol):
-    __non_callable_proto_members__: typing.ClassVar[set] = {"call_spec"}
-    _is_runtime_protocol: typing.ClassVar[bool] = True
-    @staticmethod
-    def __get__(*args, **kwds):
-        """
-        Helper for @overload to raise when called.
-        """
-
-    @classmethod
-    def __subclasshook__(cls, other): ...
-    def __call__(self, self_: typing.Any, *args: P.args, **kwargs: P.kwargs) -> R: ...
-    def __init__(self, *args, **kwargs): ...
-
-class UnionArg(AbstractArg):
-    """
-    The object must match one of the types in args
-    """
-
-    def __init__(self, *args: AbstractArg) -> None: ...
-
-def callable_spec(
-    *args: AbstractArg, **kwargs: AbstractArg
-) -> typing.Callable[[typing.Callable[P, R]], TypedCallable[P, R]]: ...
-def method_spec(
-    *args: AbstractArg, **kwargs: AbstractArg
-) -> typing.Callable[
-    [typing.Callable[Concatenate[typing.Any, P], R]], TypedMethod[P, R]
-]: ...
-
-P: typing.ParamSpec  # value = ~P
-R: typing.TypeVar  # value = +R

amulet/utils/matrix.pyi

@@ -1,177 +0,0 @@
-from __future__ import annotations
-
-import math as math
-import types
-
-import numpy as numpy
-
-__all__ = [
-    "FloatTriplet",
-    "PointCoordinates",
-    "decompose_transformation_matrix",
-    "displacement_matrix",
-    "inverse_transform_matrix",
-    "math",
-    "numpy",
-    "rotation_matrix_x",
-    "rotation_matrix_xy",
-    "rotation_matrix_xyz",
-    "rotation_matrix_y",
-    "rotation_matrix_yx",
-    "rotation_matrix_z",
-    "scale_matrix",
-    "transform_matrix",
-]
-
-def _rotation_matrix(*angles: float, order: str) -> numpy.ndarray:
-    """
-
-    Create a rotation matrix from the inputs specified
-
-    :param angles: The angles in radians
-    :param order: The order the angles are specified. Transforms will be applied in this order.
-    :return: The 4x4 rotation matrix
-
-    """
-
-def decompose_transformation_matrix(
-    matrix: numpy.ndarray,
-) -> typing.Tuple[
-    typing.Tuple[float, float, float],
-    typing.Tuple[float, float, float],
-    typing.Tuple[float, float, float],
-]:
-    """
-
-    Decompose a 4x4 transformation matrix into scale, rotation and displacement tuples.
-
-    :param matrix: The matrix to decompose.
-    :return: The scale, rotation and displacement.
-
-    """
-
-def displacement_matrix(x: float, y: float, z: float) -> numpy.ndarray:
-    """
-
-    Create a displacement matrix from the inputs specified
-
-    :param x: The displacement in the x axis
-    :param y: The displacement in the y axis
-    :param z: The displacement in the z axis
-    :return: The 4x4 displacement matrix
-
-    """
-
-def inverse_transform_matrix(
-    scale: tuple[float, float, float],
-    rotation: tuple[float, float, float],
-    displacement: tuple[float, float, float],
-    order: typing.Literal["xyz", "xzy", "yxz", "yzx", "zxy", "zyx"] = "xyz",
-) -> numpy.ndarray:
-    """
-    Create the inverse of the 4x4 transformation matrix from the scale, rotation and displacement specified.
-        This should be the inverse of transform_matrix
-
-        :param scale: The scale in the x, y and z axis
-        :param rotation: The rotation in the x, y and z axis (axis can be changed using `order`)
-        :param displacement: The displacement in the x, y and z axis
-        :param order: The order to apply the rotations in.
-        :return: The 4x4 transformation matrix of combined scale, rotation and displacement
-
-    """
-
-def rotation_matrix_x(rx: float) -> numpy.ndarray:
-    """
-
-    Create a rotation matrix in the x axis
-
-    :param rx: The angle in radians
-    :return: The 4x4 rotation matrix
-
-    """
-
-def rotation_matrix_xy(rx: float, ry: float) -> numpy.ndarray:
-    """
-
-    Create a rotation matrix from the inputs specified
-
-    :param rx: The rotation in radians in the x axis
-    :param ry: The rotation in radians in the y axis
-    :return: The 4x4 rotation matrix
-
-    """
-
-def rotation_matrix_xyz(x: float, y: float, z: float) -> numpy.ndarray:
-    """
-
-    Create a rotation matrix from the inputs specified
-
-    :param x: The rotation in radians in the x axis
-    :param y: The rotation in radians in the y axis
-    :param z: The rotation in radians in the z axis
-    :return: The 4x4 rotation matrix
-
-    """
-
-def rotation_matrix_y(ry: float) -> numpy.ndarray:
-    """
-
-    Create a rotation matrix in the x axis
-
-    :param ry: The angle in radians
-    :return: The 4x4 rotation matrix
-
-    """
-
-def rotation_matrix_yx(ry: float, rx: float) -> numpy.ndarray:
-    """
-
-    Create a rotation matrix from the inputs specified
-
-    :param rx: The rotation in radians in the x axis
-    :param ry: The rotation in radians in the y axis
-    :return: The 4x4 rotation matrix
-
-    """
-
-def rotation_matrix_z(rz: float) -> numpy.ndarray:
-    """
-
-    Create a rotation matrix in the x axis
-
-    :param rz: The angle in radians
-    :return: The 4x4 rotation matrix
-
-    """
-
-def scale_matrix(sx: float, sy: float, sz: float) -> numpy.ndarray:
-    """
-
-    Create a scale matrix from the inputs specified
-
-    :param sx: The scale in the x axis
-    :param sy: The scale in the y axis
-    :param sz: The scale in the z axis
-    :return: The 4x4 scale matrix
-
-    """
-
-def transform_matrix(
-    scale: tuple[float, float, float],
-    rotation: tuple[float, float, float],
-    displacement: tuple[float, float, float],
-    order: typing.Literal["xyz", "xzy", "yxz", "yzx", "zxy", "zyx"] = "xyz",
-) -> numpy.ndarray:
-    """
-    Create a 4x4 transformation matrix from the scale, rotation and displacement specified.
-
-        :param scale: The scale in the x, y and z axis
-        :param rotation: The rotation in the x, y and z axis in radians. (axis can be changed using `order`)
-        :param displacement: The displacement in the x, y and z axis
-        :param order: The order to apply the rotations in.
-        :return: The 4x4 transformation matrix of combined scale, rotation and displacement
-
-    """
-
-FloatTriplet: types.GenericAlias  # value = tuple[float, float, float]
-PointCoordinates: types.GenericAlias  # value = tuple[float, float, float]