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

amulet/utils/shareable_lock.pyi

@@ -1,190 +0,0 @@
-from __future__ import annotations
-
-import logging as logging
-import time as time
-from _thread import allocate_lock as Lock
-from _thread import get_ident
-from contextlib import contextmanager
-from threading import Condition
-
-import amulet.utils.task_manager
-from amulet.utils.task_manager import (
-    AbstractCancelManager,
-    TaskCancelled,
-    VoidCancelManager,
-)
-
-__all__ = [
-    "AbstractCancelManager",
-    "Condition",
-    "Lock",
-    "LockNotAcquired",
-    "ShareableRLock",
-    "TaskCancelled",
-    "VoidCancelManager",
-    "contextmanager",
-    "get_ident",
-    "log",
-    "logging",
-    "time",
-]
-
-class LockNotAcquired(amulet.utils.task_manager.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
-
-
-    """
-
-    @staticmethod
-    def shared(*args, **kwds) -> typing.Iterator[NoneType]:
-        """
-
-        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.
-
-        """
-
-    @staticmethod
-    def unique(*args, **kwds) -> typing.Iterator[NoneType]:
-        """
-
-        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.
-
-        """
-
-    def __init__(self) -> None: ...
-    def _wait(
-        self,
-        exit_condition: typing.Callable[[], bool],
-        blocking: bool = True,
-        timeout: float = -1,
-        task_manager: amulet.utils.task_manager.AbstractCancelManager = ...,
-    ) -> 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.
-
-        """
-
-    def acquire_shared(
-        self,
-        blocking: bool = True,
-        timeout: float = -1,
-        task_manager: amulet.utils.task_manager.AbstractCancelManager = ...,
-    ) -> 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.
-
-        """
-
-    def acquire_unique(
-        self,
-        blocking: bool = True,
-        timeout: float = -1,
-        task_manager: amulet.utils.task_manager.AbstractCancelManager = ...,
-    ) -> 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.
-
-        """
-
-    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.
-
-        """
-
-    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.
-
-        """
-
-log: logging.Logger  # value = <Logger amulet.utils.shareable_lock (INFO)>

amulet/utils/signal/__init__.pyi

@@ -1,25 +0,0 @@
-from __future__ import annotations
-
-from amulet.utils.signal._signal import (
-    Signal,
-    SignalInstance,
-    SignalInstanceConstructor,
-    create_signal_instance,
-    get_fallback_signal_instance_constructor,
-    get_pyside6_signal_instance_constructor,
-    set_signal_instance_constructor,
-)
-
-from . import _signal
-
-__all__ = [
-    "Signal",
-    "SignalInstance",
-    "SignalInstanceCacheName",
-    "SignalInstanceConstructor",
-    "create_signal_instance",
-    "get_fallback_signal_instance_constructor",
-    "get_pyside6_signal_instance_constructor",
-    "set_signal_instance_constructor",
-]
-SignalInstanceCacheName: str

amulet/utils/signal/_signal.pyi

@@ -1,84 +0,0 @@
-from __future__ import annotations
-
-import logging as logging
-import typing
-from collections.abc import Sequence
-from inspect import ismethod
-from typing import Any, Generic, Protocol, TypeVarTuple, overload
-from weakref import WeakMethod
-
-__all__ = [
-    "Any",
-    "CallArgs",
-    "Generic",
-    "Protocol",
-    "Sequence",
-    "Signal",
-    "SignalInstance",
-    "SignalInstanceCacheName",
-    "SignalInstanceConstructor",
-    "TypeVarTuple",
-    "WeakMethod",
-    "create_signal_instance",
-    "get_fallback_signal_instance_constructor",
-    "get_pyside6_signal_instance_constructor",
-    "ismethod",
-    "logging",
-    "overload",
-    "set_signal_instance_constructor",
-]
-
-class Signal(typing.Generic):
-    def __get__(self, instance: typing.Any, owner: typing.Any) -> typing.Any: ...
-    def __init__(
-        self, *types: type, name: str, arguments: typing.Sequence[str] = tuple()
-    ): ...
-
-class SignalInstance(typing.Protocol):
-    @classmethod
-    def __subclasshook__(cls, other): ...
-    def __init__(self, *args, **kwargs): ...
-    def connect(
-        self,
-        slot: typing.Callable[[*CallArgs], None] | SignalInstance[*CallArgs,] | None,
-        type: PySide6.QtCore.Qt.ConnectionType | None = ...,
-    ) -> None: ...
-    def disconnect(
-        self,
-        slot: (
-            typing.Callable[[*CallArgs], None] | SignalInstance[*CallArgs,] | None
-        ) = None,
-    ) -> None: ...
-    def emit(self, *args: *CallArgs) -> None: ...
-
-class SignalInstanceConstructor(typing.Protocol):
-    @classmethod
-    def __subclasshook__(cls, other): ...
-    def __call__(
-        self,
-        *,
-        types: tuple[type, ...],
-        name: str,
-        arguments: typing.Sequence[str],
-        instance: typing.Any,
-    ) -> SignalInstance[*CallArgs,]: ...
-    def __init__(self, *args, **kwargs): ...
-
-def _get_signal_instances(instance: typing.Any) -> dict[Signal, SignalInstance]: ...
-def create_signal_instance(
-    *types: type,
-    instance: typing.Any,
-    name: str,
-    arguments: typing.Sequence[str] = tuple(),
-) -> SignalInstance[*CallArgs,]:
-    """
-    Create a new signal instance
-    """
-
-def get_fallback_signal_instance_constructor() -> SignalInstanceConstructor: ...
-def get_pyside6_signal_instance_constructor() -> SignalInstanceConstructor: ...
-def set_signal_instance_constructor(constructor: SignalInstanceConstructor) -> None: ...
-
-CallArgs: typing.TypeVarTuple  # value = CallArgs
-SignalInstanceCacheName: str
-_signal_instance_constructor = None

amulet/utils/task_manager.pyi

@@ -1,168 +0,0 @@
-from __future__ import annotations
-
-import abc
-import typing
-from abc import ABC, abstractmethod
-from typing import Generic, TypeVar
-
-from amulet.utils.signal._signal import Signal, SignalInstance
-
-__all__ = [
-    "ABC",
-    "AbstractCancelManager",
-    "AbstractProgressManager",
-    "AbstractTaskManager",
-    "CancelManager",
-    "Generic",
-    "Pointer",
-    "ProgressManager",
-    "Signal",
-    "SignalInstance",
-    "T",
-    "TaskCancelled",
-    "TaskManager",
-    "TypeVar",
-    "VoidCancelManager",
-    "VoidProgressManager",
-    "VoidTaskManager",
-    "abstractmethod",
-]
-
-class AbstractCancelManager(abc.ABC):
-    def cancel(self) -> None:
-        """
-        Request the operation be canceled.
-
-                It is down to the operation to implement support for this.
-
-        """
-
-    def is_cancel_requested(self) -> bool:
-        """
-        Has cancel been called to signal that the operation should be canceled.
-        """
-
-    def register_on_cancel(self, callback: typing.Callable[[], None]) -> None:
-        """
-        Register a function to get called when :meth:`cancel` is called.
-        """
-
-    def unregister_on_cancel(self, callback: typing.Callable[[], None]) -> None:
-        """
-        Unregister a registered function from being called when :meth:`cancel` is called.
-        """
-
-class AbstractProgressManager(abc.ABC):
-    def get_child(
-        self, progress_min: float, progress_max: float
-    ) -> AbstractProgressManager:
-        """
-        Get a child ExecutionContext.
-
-                If calling multiple functions, this allows segmenting the reported time.
-
-                :param progress_min: The minimum progress for the child to use 0.0-1.0
-                :param progress_max: The maximum progress for the child to use 0.0-1.0
-                :return: A new ExecutionContext
-
-        """
-
-    def update_progress(self, progress: float) -> None:
-        """
-        Notify the caller of the updated progress.
-
-                :param progress: The new progress to relay to the caller. 0.0-1.0
-
-        """
-
-    def update_progress_text(self, text: str) -> None:
-        """
-        Notify the caller of the updated progress.
-
-                :param text: The new message to relay to the caller.
-
-        """
-
-class AbstractTaskManager(AbstractCancelManager, AbstractProgressManager, abc.ABC):
-    pass
-
-class CancelManager(_CancelManager):
-    @staticmethod
-    def _cancel_signal(*args, **kwargs): ...
-    def __init__(self) -> None: ...
-
-class Pointer(typing.Generic):
-    def __init__(self, value: T) -> None: ...
-
-class ProgressManager(_ProgressManager):
-    @staticmethod
-    def progress_change(*args, **kwargs): ...
-    @staticmethod
-    def progress_text_change(*args, **kwargs): ...
-    def __init__(self) -> None: ...
-
-class TaskCancelled(Exception):
-    """
-    Exception to be raised by the callee when a task is cancelled.
-
-        The callee may define a custom return instead of using this.
-
-    """
-
-class TaskManager(_TaskManager):
-    def __init__(self) -> None: ...
-
-class VoidCancelManager(AbstractCancelManager):
-    def cancel(self) -> None: ...
-    def is_cancel_requested(self) -> bool: ...
-    def register_on_cancel(self, callback: typing.Callable[[], None]) -> None: ...
-    def unregister_on_cancel(self, callback: typing.Callable[[], None]) -> None: ...
-
-class VoidProgressManager(AbstractProgressManager):
-    def get_child(
-        self, progress_min: float, progress_max: float
-    ) -> VoidProgressManager: ...
-    def update_progress(self, progress: float) -> None: ...
-    def update_progress_text(self, text: str) -> None: ...
-
-class VoidTaskManager(VoidCancelManager, VoidProgressManager, AbstractTaskManager):
-    """
-    An empty Execution Context that ignores all calls.
-    """
-
-class _CancelManager(AbstractCancelManager):
-    def __init__(
-        self, cancelled: Pointer[bool], cancel_signal: SignalInstance[()]
-    ) -> None: ...
-    def cancel(self) -> None: ...
-    def is_cancel_requested(self) -> bool: ...
-    def register_on_cancel(self, callback: typing.Callable[[], None]) -> None: ...
-    def unregister_on_cancel(self, callback: typing.Callable[[], None]) -> None: ...
-
-class _ProgressManager(AbstractProgressManager):
-    def __init__(
-        self,
-        progress_change: SignalInstance[float],
-        progress_text_change: SignalInstance[str],
-        progress_min: float,
-        progress_max: float,
-    ) -> None: ...
-    def get_child(
-        self, progress_min: float, progress_max: float
-    ) -> _ProgressManager: ...
-    def update_progress(self, progress: float) -> None: ...
-    def update_progress_text(self, text: str) -> None: ...
-
-class _TaskManager(CancelManager, ProgressManager, AbstractTaskManager):
-    def __init__(
-        self,
-        cancelled: Pointer[bool],
-        cancel_signal: SignalInstance[()],
-        progress_change: SignalInstance[float],
-        progress_text_change: SignalInstance[str],
-        progress_min: float,
-        progress_max: float,
-    ) -> None: ...
-    def get_child(self, progress_min: float, progress_max: float) -> _TaskManager: ...
-
-T: typing.TypeVar  # value = ~T

amulet/utils/typing.py

@@ -1,4 +0,0 @@
-# There are cases where it would be useful to type hint a class that must inherit from two or more ABCs.
-# Python doesn't currently have an intersection type but all cases that need it should refer here to make renaming
-# easier if Python implements it.
-from typing import Union as Intersection  # noqa

amulet/utils/typing.pyi

@@ -1,6 +0,0 @@
-from __future__ import annotations
-
-import typing
-
-__all__ = ["Intersection"]
-Intersection: typing._SpecialForm  # value = typing.Union

amulet/utils/weakref.pyi

@@ -1,50 +0,0 @@
-"""
-Extension to the builtin weakref module.
-"""
-
-from __future__ import annotations
-
-import typing
-import weakref
-from typing import Any, Generic, TypeVar, final
-
-__all__ = [
-    "Any",
-    "CallableWeakMethod",
-    "DetachableWeakRef",
-    "Generic",
-    "T",
-    "TypeVar",
-    "final",
-]
-
-class CallableWeakMethod(weakref.WeakMethod):
-    """
-
-    A wrapper around WeakMethod that makes the method directly callable.
-    If the method no longer exists, this does nothing.
-
-    """
-
-    __final__: typing.ClassVar[bool] = True
-    def __call__(self, *args: typing.Any, **kwargs: typing.Any) -> typing.Any: ...
-
-class DetachableWeakRef(typing.Generic):
-    """
-    A weak reference that can be detached by the creator before the object is deleted.
-    """
-
-    __final__: typing.ClassVar[bool] = True
-    @classmethod
-    def new(cls, obj: T) -> tuple[DetachableWeakRef[T], typing.Callable[[], None]]:
-        """
-        Get a new weak reference and a callable to detach the object.
-                Once called the reference will always return None.
-
-        """
-
-    def __call__(self) -> T | None: ...
-    def __init__(self, obj: T) -> None: ...
-    def _detach(self) -> None: ...
-
-T: typing.TypeVar  # value = ~T

amulet/utils/world_utils.pyi

@@ -1,109 +0,0 @@
-from __future__ import annotations
-
-import math as math
-import types
-
-import numpy as numpy
-from numpy import ndarray, uint8, zeros
-
-__all__ = [
-    "ChunkCoordinates",
-    "block_coords_to_chunk_coords",
-    "blocks_slice_to_chunk_slice",
-    "chunk_coords_to_block_coords",
-    "chunk_coords_to_region_coords",
-    "from_nibble_array",
-    "math",
-    "ndarray",
-    "numpy",
-    "region_coords_to_chunk_coords",
-    "to_nibble_array",
-    "uint8",
-    "zeros",
-]
-
-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
-
-    """
-
-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
-
-    """
-
-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
-
-    """
-
-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
-
-    """
-
-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
-
-    """
-
-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
-
-    """
-
-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
-
-    """
-
-ChunkCoordinates: types.GenericAlias  # value = tuple[int, int]