amulet-core 2.0a8__cp311-cp311-win_amd64.whl → 2.0.1.0.1297307203.19.43.34808.0a1__cp311-cp311-win_amd64.whl

amulet/level/abc/_history/_cache.py

@@ -1,224 +0,0 @@
-from __future__ import annotations
-
-import shutil
-from typing import Optional, Callable, cast, IO, Self
-from threading import Lock
-import os
-from weakref import ref, finalize
-import time
-import glob
-import re
-import tempfile
-
-import portalocker
-from leveldb import LevelDB
-from amulet.utils.weakref import CallableWeakMethod
-
-
-TempPattern = re.compile(r"amulettmp.*?-(?P<time>\d+)")
-
-
-def _temp_dir() -> str:
-    temp_dir = os.environ.get("CACHE_DIR")
-    if temp_dir is None:
-        raise RuntimeError
-    return temp_dir
-
-
-def _clear_temp_dirs() -> None:
-    """
-    Try and delete historic temporary directories.
-    If things went very wrong in past sessions temporary directories may still exist.
-    """
-    for path in glob.glob(
-        os.path.join(glob.escape(tempfile.gettempdir()), "amulettmp*")
-    ) + glob.glob(
-        os.path.join(glob.escape(_temp_dir()), "**", "amulettmp*"), recursive=True
-    ):
-        name = os.path.basename(path)
-        match = TempPattern.fullmatch(name)
-        if match and int(match.group("time")) < (time.time() - 7 * 24 * 3600):
-            lock_path = os.path.join(path, "lock")
-            if os.path.exists(lock_path):
-                with open(lock_path) as lock:
-                    # make sure it is not locked by another process
-                    try:
-                        portalocker.lock(lock, portalocker.LockFlags.EXCLUSIVE)
-                    except:
-                        continue
-                    else:
-                        portalocker.unlock(lock)
-            shutil.rmtree(path, ignore_errors=True)
-
-
-_clear_temp_dirs()
-
-
-class TempDir(str):
-    """
-    A temporary directory to do with as you wish.
-
-    >>> t = TempDir()
-    >>> path = os.path.join(t, "your_file.txt")  # TempDir is a subclass of str
-    >>> # make sure all files in the temporary directory are closed before releasing or closing this object.
-    >>> # The temporary directory will be deleted when the last reference to `t` is lost or when `t.close()` is called
-    """
-
-    __lock: IO | None
-    __finalise: finalize
-
-    def __new__(cls, group: str) -> Self:
-        cache_dir = os.path.join(_temp_dir(), group)
-        os.makedirs(cache_dir, exist_ok=True)
-        return super().__new__(
-            cls,
-            tempfile.mkdtemp(
-                prefix="amulettmp",
-                suffix=f"-{time.time():.0f}",
-                dir=cache_dir,
-            ),
-        )
-
-    def __init__(self, group: str) -> None:
-        self.__lock = open(os.path.join(self, "lock"), "w")
-        portalocker.lock(self.__lock, portalocker.LockFlags.EXCLUSIVE)
-        self.__finalise = finalize(self, CallableWeakMethod(self._close))
-
-    def _close(self) -> None:
-        if self.__lock is not None:
-            portalocker.unlock(self.__lock)
-            self.__lock.close()
-            self.__lock = None
-            shutil.rmtree(self)
-
-    def close(self) -> None:
-        """Close the lock and delete the directory."""
-        self.__finalise()
-
-    def __del__(self) -> None:
-        self.__finalise()
-
-
-class DiskCache:
-    """
-    A key, value database with a fast access RAM component and a longer term storage disk component.
-    Keys and values are both bytes.
-    The disk component is a leveldb database.
-    """
-
-    def __init__(self, path: str, max_size: int) -> None:
-        """
-        Create a new DiskCache
-        :param path: The path to save the disk component to.
-        :param max_size: The maximum amount of RAM that values can occupy. Key size is assumed negligible.
-            When this is overflowed, the least recently used entries are unloaded to the disk storage.
-        """
-        self._lock = Lock()
-        self._ram: dict[bytes, tuple[bytes, bool]] = {}
-        self._path = path
-        self._disk = LevelDB(path, create_if_missing=True)
-        self._max_size: int = max_size
-        self._size: int = 0
-        self.__finalise = finalize(self, CallableWeakMethod(self._close))
-
-    def _close(self) -> None:
-        self._disk.close()
-        shutil.rmtree(self._path, ignore_errors=True)
-
-    def __del__(self) -> None:
-        self.__finalise()
-
-    @property
-    def max_size(self) -> int:
-        return self._max_size
-
-    @max_size.setter
-    def max_size(self, max_size: int) -> None:
-        if not isinstance(max_size, int):
-            raise TypeError
-        with self._lock:
-            self._max_size = max_size
-            self._free()
-
-    def __setitem__(self, key: bytes, value: bytes) -> None:
-        with self._lock:
-            self._remove(key)
-            self._ram[key] = (value, True)
-            self._size += len(value)
-            self._free()
-
-    def _remove(self, key: bytes) -> None:
-        if key in self._ram:
-            data = self._ram.pop(key)[0]
-            self._size -= len(data)
-
-    def __delitem__(self, key: bytes) -> None:
-        with self._lock:
-            self._remove(key)
-            if key in self._disk:
-                del self._disk[key]
-
-    def _free(self) -> None:
-        """Push some values to disk"""
-        if self._size > self._max_size:
-            keys = iter(self._ram.copy())
-            while self._size > self._max_size:
-                key = next(keys)
-                value, changed = self._ram.pop(key)
-                self._size -= len(value)
-                if changed:
-                    self._disk[key] = value
-
-    def __getitem__(self, key: bytes) -> bytes:
-        with self._lock:
-            if key in self._ram:
-                value = self._ram.pop(key)
-                # Push it to the end
-                self._ram[key] = value
-                return value[0]
-            elif key in self._disk:
-                data = self._disk[key]
-                self._ram[key] = (data, False)
-                self._size += len(data)
-                self._free()
-                return data
-            else:
-                raise KeyError
-
-
-class GlobalDiskCache(DiskCache):
-    _instance_ref: Callable[[], Optional[GlobalDiskCache]] = cast(
-        Callable[[], Optional["GlobalDiskCache"]], lambda: None
-    )
-    _cache_size = 100_000_000
-
-    @classmethod
-    def instance(cls) -> GlobalDiskCache:
-        """
-        Get the global disk cache instance.
-        The caller must store a strong reference to the returned value otherwise it will be destroyed.
-        """
-        instance: Optional[GlobalDiskCache] = cls._instance_ref()
-        if instance is None:
-            instance = GlobalDiskCache()
-            cls._instance_ref = ref(instance)
-        return instance
-
-    @classmethod
-    def cache_size(cls) -> int:
-        instance: Optional[GlobalDiskCache] = cls._instance_ref()
-        if instance is None:
-            return cls._cache_size
-        else:
-            return instance.max_size
-
-    @classmethod
-    def set_cache_size(cls, size: int) -> None:
-        instance: Optional[GlobalDiskCache] = cls._instance_ref()
-        cls._cache_size = size
-        if instance is not None:
-            instance.max_size = size
-
-    def __init__(self) -> None:
-        self._temp_dir = TempDir("level_data")
-        super().__init__(os.path.join(self._temp_dir, "history_db"), 100_000_000)

amulet/level/abc/_history/_history_manager.py

@@ -1,291 +0,0 @@
-from __future__ import annotations
-
-from uuid import uuid4
-from threading import Lock
-from typing import Sequence, Protocol, TypeVar, Generic, Mapping, Any
-from weakref import WeakSet, WeakValueDictionary
-from collections.abc import MutableMapping
-
-from amulet.utils.signal import Signal, SignalInstanceCacheName
-
-from ._cache import GlobalDiskCache
-
-# TODO: consider adding a max undo option
-# TODO: if we clear old undo info we should remove that data from the cache
-# TODO: compact the cache periodically
-
-
-class ResourceId(Protocol):
-    def __hash__(self) -> int:
-        """A constant hash"""
-        ...
-
-    def __eq__(self, other: Any) -> bool: ...
-
-    def __bytes__(self) -> bytes:
-        """A constant bytes representation"""
-        ...
-
-
-ResourceIdT = TypeVar("ResourceIdT", bound=ResourceId)
-
-
-class Resource:
-    __slots__ = ("index", "saved_index", "global_index", "exists")
-
-    def __init__(self) -> None:
-        # The index of the currently active revision
-        self.index: int = 0
-        # The index of the saved revision. -1 if the index no longer exists (overwritten or destroyed future)
-        self.saved_index: int = 0
-        # The global history index
-        self.global_index: int = 0
-        # Does the resource data exist
-        self.exists: list[bool] = [True]
-
-    def get_resource_key(self, uuid: bytes, resource_id: ResourceId) -> bytes:
-        return b"/".join((uuid, bytes(resource_id), str(self.index).encode()))
-
-
-class HistoryManagerPrivate:
-    lock: Lock
-    resources: WeakValueDictionary[bytes, MutableMapping[ResourceId, Resource]]
-    history: list[WeakSet[Resource]]
-    history_index: int
-    has_redo: bool
-    cache: GlobalDiskCache
-
-    def __init__(self) -> None:
-        self.lock = Lock()
-        self.resources = WeakValueDictionary()
-        self.history = [WeakSet()]
-        self.history_index = 0
-        self.has_redo = False
-        self.cache = GlobalDiskCache.instance()
-
-    def invalidate_future(self) -> None:
-        """Destroy all future redo bins. Caller must acquire the lock"""
-        if self.has_redo:
-            self.has_redo = False
-            del self.history[self.history_index + 1 :]
-            for layer in self.resources.values():
-                for resource in layer.values():
-                    if resource.saved_index > resource.index:
-                        # A future index is saved that just got invalidated
-                        resource.saved_index = -1
-
-    def reset(self) -> None:
-        with self.lock:
-            for layer in self.resources.values():
-                layer.clear()
-            self.history = [WeakSet()]
-            self.history_index = 0
-            self.has_redo = False
-
-
-class CustomDict(dict):
-    pass
-
-
-class HistoryManager:
-    __slots__ = (SignalInstanceCacheName, "_h")
-
-    _h: HistoryManagerPrivate
-
-    def __init__(self) -> None:
-        self._h = HistoryManagerPrivate()
-
-    def new_layer(self) -> HistoryManagerLayer:
-        uuid = uuid4().bytes
-        resources: MutableMapping[ResourceId, Resource] = CustomDict()
-        self._h.resources[uuid] = resources
-        return HistoryManagerLayer(self._h, uuid, resources)
-
-    history_changed = Signal[()]()
-
-    def create_undo_bin(self) -> None:
-        """
-        Call this to create a new undo bin.
-        All changes made after this point will be part of the same undo bin until this is called again.
-        If this is not called, all changes will be part of the previous undo bin.
-        """
-        with self._h.lock:
-            self._h.invalidate_future()
-            self._h.history_index += 1
-            self._h.history.append(WeakSet())
-
-    def mark_saved(self) -> None:
-        with self._h.lock:
-            for layer in self._h.resources.values():
-                for resource in layer.values():
-                    resource.saved_index = resource.index
-
-    @property
-    def undo_count(self) -> int:
-        """The number of times undo can be called."""
-        with self._h.lock:
-            return self._h.history_index
-
-    def undo(self) -> None:
-        """Undo the changes in the current undo bin."""
-        with self._h.lock:
-            if self._h.history_index <= 0:
-                raise RuntimeError
-            for resource in self._h.history[self._h.history_index]:
-                resource.index -= 1
-            self._h.history_index -= 1
-            self._h.has_redo = True
-
-    def _redo_count(self) -> int:
-        return len(self._h.history) - (self._h.history_index + 1)
-
-    @property
-    def redo_count(self) -> int:
-        """The number of times redo can be called."""
-        with self._h.lock:
-            return self._redo_count()
-
-    def redo(self) -> None:
-        """Redo the changes in the next undo bin."""
-        with self._h.lock:
-            if not self._h.has_redo:
-                raise RuntimeError
-            self._h.history_index += 1
-            for resource in self._h.history[self._h.history_index]:
-                resource.index += 1
-            self._h.has_redo = bool(self._redo_count())
-
-    def reset(self) -> None:
-        """Reset to the factory state."""
-        self._h.reset()
-
-
-class HistoryManagerLayer(Generic[ResourceIdT]):
-    __slots__ = ("_h", "_uuid", "_resources")
-
-    _h: HistoryManagerPrivate
-    _uuid: bytes
-    _resources: MutableMapping[ResourceIdT, Resource]
-
-    def __init__(
-        self,
-        _h: HistoryManagerPrivate,
-        uuid: bytes,
-        resources: MutableMapping[ResourceIdT, Resource],
-    ) -> None:
-        """This must not be used directly."""
-        self._h = _h
-        self._uuid = uuid
-        self._resources = resources
-
-    def resources(self) -> Sequence[ResourceIdT]:
-        """
-        Get all resource ids from this layer.
-        :return:
-        """
-        with self._h.lock:
-            return list(self._resources)
-
-    def changed_resources(self) -> Sequence[ResourceIdT]:
-        """
-        Get all resource ids from this layer that have changed since the last call to mark_saved.
-        :return:
-        """
-        with self._h.lock:
-            return [
-                resource_id
-                for resource_id, resource in self._resources.items()
-                if resource.saved_index != resource.index
-            ]
-
-    def resources_exist_map(self) -> Mapping[ResourceIdT, bool]:
-        """
-        Get a mapping from the resource ids to a bool stating if the data exists for that resource.
-        If false that resource has been deleted.
-        """
-        with self._h.lock:
-            return {
-                resource_id: resource.exists[resource.index]
-                for resource_id, resource in self._resources.items()
-            }
-
-    def has_resource(self, resource_id: ResourceIdT) -> bool:
-        """
-        Check if a resource entry exists.
-        If the resource has been loaded this will be True regardless if the resource data has been deleted.
-        Use :meth:`resource_exists` to check if the resource data has been deleted.
-        Calling :meth:`get_resource` or :meth:`set_resource` when this is False will error.
-        :param resource_id: The resource identifier
-        :return:
-        """
-        with self._h.lock:
-            return resource_id in self._resources
-
-    def resource_exists(self, resource_id: ResourceIdT) -> bool:
-        """
-        A fast way to check if the resource data exists without loading it.
-        :param resource_id: The resource identifier
-        :return: True if the data exists.
-        """
-        with self._h.lock:
-            resource = self._resources[resource_id]
-            return resource.exists[resource.index]
-
-    def get_resource(self, resource_id: ResourceIdT) -> bytes:
-        """
-        Get the newest resource data.
-        :param resource_id: The resource identifier
-        :return: The binary data that was previously set. An empty bytes object for the deleted state.
-        """
-        with self._h.lock:
-            resource = self._resources[resource_id]
-            if resource.exists[resource.index]:
-                return self._h.cache[resource.get_resource_key(self._uuid, resource_id)]
-            else:
-                return b""
-
-    def set_initial_resource(self, resource_id: ResourceIdT, data: bytes) -> None:
-        """
-        Set the data for the resource.
-        This can only be used if the resource does not already exist.
-        :param resource_id: The resource identifier
-        :param data: The binary data to set. An empty bytes object for the deleted state.
-        :return:
-        """
-        with self._h.lock:
-            if resource_id in self._resources:
-                raise RuntimeError("Resource already exists")
-            resource = self._resources[resource_id] = Resource()
-            if data:
-                # Save the data to the cache if it exists
-                self._h.cache[resource.get_resource_key(self._uuid, resource_id)] = data
-            # Store a flag if it exists
-            resource.exists[resource.index] = bool(data)
-
-    def set_resource(self, resource_id: ResourceIdT, data: bytes) -> None:
-        """
-        Set the data for the resource.
-        :param resource_id: The resource identifier
-        :param data: The binary data to set. An empty bytes object for the deleted state.
-        :return:
-        """
-        with self._h.lock:
-            self._h.invalidate_future()
-            resource = self._resources[resource_id]
-            if resource.global_index != self._h.history_index:
-                # The global history index has been increased since the last change to this resource
-                # Add a new state
-                resource.index += 1
-                resource.global_index = self._h.history_index
-                resource.exists.append(False)
-            if resource.index == resource.saved_index:
-                # The saved index has been directly modified
-                resource.saved_index = -1
-            if data:
-                # Save the data to the cache if it exists
-                self._h.cache[resource.get_resource_key(self._uuid, resource_id)] = data
-            # Store a flag if it exists
-            resource.exists[resource.index] = bool(data)
-            if self._h.history_index:
-                # Add the resource to the history bin if one has been created
-                self._h.history[self._h.history_index].add(resource)

amulet/level/abc/_level/__init__.py

@@ -1,5 +0,0 @@
-from ._level import LevelOpenData, Level, LevelT, LevelFriend
-from ._compactable_level import CompactableLevel
-from ._creatable_level import CreatableLevel
-from ._disk_level import DiskLevel
-from ._loadable_level import LoadableLevel

amulet/level/abc/_level/_compactable_level.py

@@ -1,10 +0,0 @@
-from abc import ABC, abstractmethod
-
-
-class CompactableLevel(ABC):
-    __slots__ = ()
-
-    @abstractmethod
-    def compact(self) -> None:
-        """Compact level data to reduce file size."""
-        raise NotImplementedError

amulet/level/abc/_level/_creatable_level.py

@@ -1,28 +0,0 @@
-from __future__ import annotations
-from abc import ABC, abstractmethod
-from typing import TYPE_CHECKING, Any
-
-from amulet.utils.call_spec import method_spec
-
-
-if TYPE_CHECKING:
-    from ._level import Level
-
-
-class CreatableLevel(ABC):
-    """Level extension class for levels that can be created without data."""
-
-    __slots__ = ()
-
-    @classmethod
-    @abstractmethod
-    @method_spec()
-    def create(cls, *args: Any, **kwargs: Any) -> Level:
-        """
-        Create a new instance without any existing data.
-        You must call :meth:`~amulet.level.abc.Level.open` to open the level for editing.
-        :return: A new Level instance
-        """
-        # If writing data to disk, it must write a valid level.
-        # If only setting attributes, the open method must be aware that it should not load data from disk.
-        raise NotImplementedError

amulet/level/abc/_level/_disk_level.py

@@ -1,17 +0,0 @@
-from __future__ import annotations
-
-from abc import abstractmethod
-
-from ._level import Level, OpenLevelDataT, RawLevelT, DimensionT
-
-
-class DiskLevel(Level[OpenLevelDataT, DimensionT, RawLevelT]):
-    """A level base class for all levels with data on disk."""
-
-    __slots__ = ()
-
-    @property
-    @abstractmethod
-    def path(self) -> str:
-        """The path to the level on disk."""
-        raise NotImplementedError