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

amulet/utils/matrix.py

@@ -1,243 +0,0 @@
-from typing import Literal
-import math
-import numpy
-from amulet.data_types import FloatTriplet, PointCoordinates
-
-
-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
-    """
-    return numpy.array(
-        [[sx, 0, 0, 0], [0, sy, 0, 0], [0, 0, sz, 0], [0, 0, 0, 1]], dtype=numpy.float64
-    )
-
-
-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
-    """
-    return numpy.array(
-        [[1, 0, 0, x], [0, 1, 0, y], [0, 0, 1, z], [0, 0, 0, 1]], dtype=numpy.float64
-    )
-
-
-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
-    """
-    assert isinstance(order, str) and len(order) == len(
-        angles
-    ), "Order must be a string of the same length as angles."
-    mat = numpy.identity(4, dtype=numpy.float64)
-
-    for angle, axis in zip(angles, order):
-        if angle:
-            c = math.cos(angle)
-            s = math.sin(angle)
-            if axis == "x":
-                mat = numpy.matmul(
-                    numpy.array(
-                        [[1, 0, 0, 0], [0, c, -s, 0], [0, s, c, 0], [0, 0, 0, 1]],
-                        dtype=numpy.float64,
-                    ),
-                    mat,
-                )
-            elif axis == "y":
-                mat = numpy.matmul(
-                    numpy.array(
-                        [[c, 0, s, 0], [0, 1, 0, 0], [-s, 0, c, 0], [0, 0, 0, 1]],
-                        dtype=numpy.float64,
-                    ),
-                    mat,
-                )
-            elif axis == "z":
-                mat = numpy.matmul(
-                    numpy.array(
-                        [[c, -s, 0, 0], [s, c, 0, 0], [0, 0, 1, 0], [0, 0, 0, 1]],
-                        dtype=numpy.float64,
-                    ),
-                    mat,
-                )
-
-    return mat
-
-
-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
-    """
-    return _rotation_matrix(rx, order="x")
-
-
-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
-    """
-    return _rotation_matrix(ry, order="y")
-
-
-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
-    """
-    return _rotation_matrix(rz, order="z")
-
-
-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
-    """
-    return _rotation_matrix(rx, ry, order="xy")
-
-
-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
-    """
-    return _rotation_matrix(ry, rx, order="yx")
-
-
-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
-    """
-    return _rotation_matrix(x, y, z, order="xyz")
-
-
-def transform_matrix(
-    scale: FloatTriplet,
-    rotation: FloatTriplet,
-    displacement: PointCoordinates,
-    order: 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
-    """
-    scale_transform = scale_matrix(*scale)
-    rotation_transform = _rotation_matrix(*rotation, order=order)
-    displacement_transform = displacement_matrix(*displacement)
-    return numpy.matmul(  # type: ignore
-        displacement_transform,
-        numpy.matmul(rotation_transform, scale_transform),
-    )
-
-
-def inverse_transform_matrix(
-    scale: FloatTriplet,
-    rotation: FloatTriplet,
-    displacement: PointCoordinates,
-    order: 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
-    """
-    scale_transform = scale_matrix(*1 / numpy.asarray(scale))
-    ra, rb, rc = -numpy.asarray(rotation)
-    rotation_transform = _rotation_matrix(
-        rc, rb, ra, order="".join(list(reversed(order)))
-    )
-    displacement_transform = displacement_matrix(*-numpy.asarray(displacement))
-    return numpy.matmul(  # type: ignore
-        scale_transform,
-        numpy.matmul(rotation_transform, displacement_transform),
-    )
-
-
-def decompose_transformation_matrix(
-    matrix: numpy.ndarray,
-) -> tuple[
-    tuple[float, float, float], tuple[float, float, float], 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.
-    """
-    assert isinstance(matrix, numpy.ndarray), "Matrix must be an ndarray"
-    assert matrix.shape == (4, 4), "Expected a 4x4 numpy array"
-    # https://gist.github.com/Aerilius/0cbc46271c163746717902b36bea8fd4
-    # 0 4 8  12
-    # 1 5 9  13
-    # 2 6 10 14
-    # 3 7 11 15
-    matrix = matrix.copy()  # just in case
-    displacement = tuple(matrix[:3, 3].tolist())
-    matrix[:3, 3] = 0
-    scale_np = numpy.linalg.norm(matrix[:3, :3], axis=0) * matrix[3, 3]
-    scale = tuple(scale_np.tolist())
-    matrix[:3, :3] = matrix[:3, :3] / scale_np
-
-    matrix[3, 3] = 1
-
-    if (
-        numpy.dot(
-            numpy.cross(
-                matrix[:3, 0],
-                matrix[:3, 1],
-            ),
-            matrix[:3, 2],
-        )
-        < 0
-    ):
-        scale = (-scale[0], scale[1], scale[2])
-        matrix[:3, 0] *= -1
-
-    rotation = (
-        math.atan2(matrix[2, 1], matrix[2, 2]),
-        math.atan2(
-            -matrix[2, 0],
-            (matrix[2, 1] ** 2 + matrix[2, 2] ** 2) ** 0.5,
-        ),
-        math.atan2(matrix[1, 0], matrix[0, 0]),
-    )
-
-    return scale, rotation, displacement

amulet/utils/numpy.hpp

@@ -1,36 +0,0 @@
-#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.pyi

@@ -1,11 +0,0 @@
-from __future__ import annotations
-
-import numpy
-import numpy.typing
-import typing_extensions
-
-__all__ = ["unique_inverse"]
-
-def unique_inverse(
-    array: typing_extensions.Buffer,
-) -> tuple[numpy.typing.NDArray[numpy.uint32], numpy.typing.NDArray[numpy.uint32]]: ...

amulet/utils/numpy_helpers.py

@@ -1,19 +0,0 @@
-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]:
-    unique: list[T] = []
-    inverse = numpy.zeros(dtype=numpy.uint32, shape=len(data))
-    for i, d in enumerate(data):
-        try:
-            index = unique.index(d)
-        except ValueError:
-            index = len(unique)
-            unique.append(d)
-        inverse[i] = index
-
-    return unique, numpy.array(inverse)

amulet/utils/shareable_lock.py

@@ -1,335 +0,0 @@
-from typing import Callable, Iterator
-from threading import Lock, Condition, get_ident
-from contextlib import contextmanager
-import time
-import logging
-
-from .task_manager import AbstractCancelManager, VoidCancelManager, TaskCancelled
-
-
-log = logging.getLogger(__name__)
-
-
-class LockNotAcquired(TaskCancelled):
-    """An exception raised if the lock was not acquired."""
-
-
-class ShareableRLock:
-    """
-    This is a custom lock implementation that can be acquired in
-    1) unique mode.
-        - This is the normal mode where only this thread can use the resource.
-        - All other acquires block until this releases it.
-    2) shared mode.
-        - This allows multiple threads to acquire the resource at the same time.
-        - This is useful if multiple threads want to read a resource but not write to it.
-        - If the resource is locked in unique mode this will block
-        - Once locked in shared mode it
-
-    """
-
-    _state_lock: Lock
-    _state_condition: Condition
-    _blocking_threads: dict[
-        int, tuple[bool, bool]
-    ]  # dict[thread_id, tuple[is_serial, is_blocking]]
-    _unique_thread: int | None
-    _unique_r_count: int
-    _shared_threads: dict[
-        int, int
-    ]  # Map from thread id to the number of times it has been acquired in shared mode.
-
-    def __init__(self) -> None:
-        self._state_lock = Lock()
-        self._state_condition = Condition(self._state_lock)
-        self._blocking_threads = {}
-        self._unique_thread = None
-        self._unique_r_count = 0
-        self._shared_threads = {}
-
-    def _wait(
-        self,
-        exit_condition: Callable[[], bool],
-        blocking: bool = True,
-        timeout: float = -1,
-        task_manager: AbstractCancelManager = VoidCancelManager(),
-    ) -> bool:
-        """Wait until a condition is False.
-
-        :param exit_condition: The condition to check.
-        :param blocking: Should this block until the lock can be acquired. Default is True.
-            If false and the lock cannot be acquired on the first try, this returns False.
-        :param timeout: Maximum amount of time to block for. Has no effect is blocking is False. Default is forever.
-        :param task_manager: A custom object through which acquiring can be cancelled.
-            This effectively manually triggers timeout.
-            This is useful for GUIs so that the user can cancel an operation that may otherwise block for a while.
-        :return: True if the lock was acquired, otherwise False.
-        """
-        if task_manager.is_cancel_requested():
-            return False
-
-        if exit_condition():
-            # We don't need to wait
-            return True
-
-        if not blocking:
-            # Need to wait but told not to
-            return False
-
-        if timeout == -1:
-            # wait with no timeout
-            while not exit_condition():
-                if task_manager.is_cancel_requested():
-                    return False
-                self._state_condition.wait()
-            return True
-
-        else:
-            # Wait with a timeout
-            end_time = time.time() + timeout
-            while not exit_condition():
-                if task_manager.is_cancel_requested():
-                    return False
-                wait_time = end_time - time.time()
-                if wait_time > 0:
-                    self._state_condition.wait(wait_time)
-                else:
-                    return False
-            return True
-
-    def acquire_unique(
-        self,
-        blocking: bool = True,
-        timeout: float = -1,
-        task_manager: AbstractCancelManager = VoidCancelManager(),
-    ) -> bool:
-        """
-        Only use this if you know what you are doing. Consider using :meth:`unique` instead
-        Acquire the lock in unique mode. This is equivalent to threading.RLock.acquire
-        With improper use this can lead to a deadlock.
-        :param blocking: Should this block until the lock can be acquired. Default is True.
-            If false and the lock cannot be acquired on the first try, this returns False.
-        :param timeout: Maximum amount of time to block for. Has no effect is blocking is False. Default is forever.
-        :param task_manager: A custom object through which acquiring can be cancelled.
-            This effectively manually triggers timeout.
-            This is useful for GUIs so that the user can cancel an operation that may otherwise block for a while.
-        :return: True if the lock was acquired otherwise False.
-        """
-        with self._state_lock:
-            ident = get_ident()
-            if (
-                ident in self._shared_threads
-                and blocking
-                and timeout == -1
-                and any(
-                    self._blocking_threads[thread_id][1]
-                    for thread_id in self._blocking_threads
-                    if thread_id in self._shared_threads
-                )
-            ):
-                logging.warning("Possible deadlock")
-
-            def on_cancel() -> None:
-                with self._state_lock:
-                    self._state_condition.notify_all()
-
-            task_manager.register_on_cancel(on_cancel)
-
-            self._blocking_threads[ident] = (
-                True,
-                blocking
-                and timeout == -1
-                and isinstance(task_manager, VoidCancelManager),
-            )
-
-            def exit_condition() -> bool:
-                # The thread was the first to join
-                # The lock is not locked or is locked by this thread
-                can_exit = (
-                    next(iter(self._blocking_threads)) == ident
-                    and self._unique_thread in (None, ident)
-                    and self._shared_threads.keys() in (set(), {ident})
-                )
-                if can_exit:
-                    self._blocking_threads.pop(ident)
-                return can_exit
-
-            locked = self._wait(
-                exit_condition,
-                blocking,
-                timeout,
-                task_manager,
-            )
-
-            task_manager.unregister_on_cancel(on_cancel)
-
-            if locked:
-                # Lock it
-                self._unique_thread = ident
-                self._unique_r_count += 1
-                return True
-            else:
-                self._blocking_threads.pop(ident)
-                return False
-
-    def release_unique(self) -> None:
-        """
-        Only use this if you know what you are doing. Consider using :meth:`unique` instead
-        Release the unique hold on the lock. This must be called by the same thread that acquired it.
-        This must be called exactly the same number of times as :meth:`acquire_unique` was called.
-        """
-        with self._state_lock:
-            if self._unique_thread != get_ident():
-                raise RuntimeError("Lock released by a thread that does not own it.")
-
-            self._unique_r_count -= 1
-            if self._unique_r_count == 0:
-                self._unique_thread = None
-                # Let another thread continue
-                self._state_condition.notify_all()
-
-    def acquire_shared(
-        self,
-        blocking: bool = True,
-        timeout: float = -1,
-        task_manager: AbstractCancelManager = VoidCancelManager(),
-    ) -> bool:
-        """
-        Only use this if you know what you are doing. Consider using :meth:`shared` instead
-        Acquire the lock in shared mode.
-        :param blocking: Should this block until the lock can be acquired. Default is True.
-            If false and the lock cannot be acquired on the first try, this returns False.
-        :param timeout: Maximum amount of time to block for. Has no effect is blocking is False. Default is forever.
-        :param task_manager: A custom object through which acquiring can be cancelled.
-            This effectively manually triggers timeout.
-            This is useful for GUIs so that the user can cancel an operation that may otherwise block for a while.
-        :return: True if the lock was acquired otherwise False.
-        """
-        with self._state_lock:
-            ident = get_ident()
-
-            def exit_condition() -> bool:
-                if self._unique_thread == ident or ident in self._shared_threads:
-                    # Lock is already acquired by this thread
-                    self._blocking_threads.pop(ident)
-                    return True
-                elif self._unique_thread is None:
-                    # Is it not locked in unique mode
-                    for thread_id, (is_serial, _) in self._blocking_threads.items():
-                        if is_serial:
-                            return False
-                        elif thread_id == ident:
-                            self._blocking_threads.pop(ident)
-                            return True
-                return False
-
-            def on_cancel() -> None:
-                with self._state_lock:
-                    self._state_condition.notify_all()
-
-            task_manager.register_on_cancel(on_cancel)
-
-            self._blocking_threads[ident] = (False, False)
-
-            locked = self._wait(exit_condition, blocking, timeout, task_manager)
-
-            task_manager.unregister_on_cancel(on_cancel)
-
-            if locked:
-                # Not unique locked or unique locked by the current thread
-                self._shared_threads.setdefault(ident, 0)
-                self._shared_threads[ident] += 1
-                return True
-            else:
-                self._blocking_threads.pop(ident)
-                return False
-
-    def release_shared(self) -> None:
-        """
-        Only use this if you know what you are doing. Consider using :meth:`shared` instead
-        Release the shared hold on the lock. This must be called by the same thread that acquired it.
-        This must be called exactly the same number of times as :meth:`acquire_shared` was called.
-        """
-        with self._state_lock:
-            ident = get_ident()
-            if ident not in self._shared_threads:
-                raise RuntimeError("Lock released by a thread that does not own it.")
-
-            self._shared_threads[ident] -= 1
-            if self._shared_threads[ident] == 0:
-                self._shared_threads.pop(ident)
-                self._state_condition.notify_all()
-
-    @contextmanager
-    def unique(
-        self,
-        blocking: bool = True,
-        timeout: float = -1,
-        task_manager: AbstractCancelManager = VoidCancelManager(),
-    ) -> Iterator[None]:
-        """
-        Acquire the lock in unique mode.
-        This is used as follows
-
-        >>> lock: ShareableRLock
-        >>> with lock.unique():
-        >>>     # code with lock acquired
-        >>> # the lock will automatically be released here
-
-        This will block while all other threads using the resource finish
-        and once acquired block all other threads until the lock is released.
-
-        :param blocking: Should this block until the lock can be acquired. Default is True.
-            If false and the lock cannot be acquired on the first try, this returns False.
-        :param timeout: Maximum amount of time to block for. Has no effect is blocking is False. Default is forever.
-        :param task_manager: A custom object through which acquiring can be cancelled.
-            This effectively manually triggers timeout.
-            This is useful for GUIs so that the user can cancel an operation that may otherwise block for a while.
-        :return: None
-        :raises: LockNotAcquired if the lock could not be acquired.
-        """
-        if not self.acquire_unique(blocking, timeout, task_manager):
-            raise LockNotAcquired
-        try:
-            yield
-        finally:
-            self.release_unique()
-
-    @contextmanager
-    def shared(
-        self,
-        blocking: bool = True,
-        timeout: float = -1,
-        task_manager: AbstractCancelManager = VoidCancelManager(),
-    ) -> Iterator[None]:
-        """
-        Acquire the lock in shared mode.
-        This is used as follows
-
-        >>> lock: ShareableRLock
-        >>> with lock.shared():
-        >>>     # code with lock acquired
-        >>> # the lock will automatically be released here
-
-        If the lock is acquired by a different thread in unique mode then this will block until it is finished.
-        If the lock is acquired in unique mode by this thread or by otherthreads in shared mode then this will acquire
-        the lock.
-
-        If another thread wants to acquire the lock in unique mode it will block until all threads have finished in
-        shared mode.
-
-        :param blocking: Should this block until the lock can be acquired. Default is True.
-            If false and the lock cannot be acquired on the first try, this returns False.
-        :param timeout: Maximum amount of time to block for. Has no effect is blocking is False. Default is forever.
-        :param task_manager: A custom object through which acquiring can be cancelled.
-            This effectively manually triggers timeout.
-            This is useful for GUIs so that the user can cancel an operation that may otherwise block for a while.
-        :return: None
-        :raises: LockNotAcquired if the lock could not be acquired.
-        """
-        if not self.acquire_shared(blocking, timeout, task_manager):
-            raise LockNotAcquired
-        try:
-            yield
-        finally:
-            self.release_shared()

amulet/utils/signal/__init__.py

@@ -1,10 +0,0 @@
-from ._signal import (
-    Signal,
-    SignalInstance,
-    create_signal_instance,
-    SignalInstanceConstructor,
-    set_signal_instance_constructor,
-    get_fallback_signal_instance_constructor,
-    get_pyside6_signal_instance_constructor,
-    SignalInstanceCacheName,
-)