amulet-core 1.9.19__py3-none-any.whl → 1.9.20__py3-none-any.whl

amulet/api/block_entity.py

@@ -1,71 +1,71 @@
-from __future__ import annotations
-import copy
-import numpy
-
-from amulet_nbt import NamedTag
-from amulet.api.data_types import BlockCoordinates
-from .abstract_base_entity import AbstractBaseEntity
-
-
-class BlockEntity(AbstractBaseEntity):
-    """
-    A class to contain all the data to define a BlockEntity.
-    """
-
-    obj_name = "BlockEntity"
-    coord_types = (int, numpy.integer)
-
-    def __init__(
-        self,
-        namespace: str,
-        base_name: str,
-        x: int,
-        y: int,
-        z: int,
-        nbt: NamedTag,
-    ):
-        """
-        Constructs a :class:`BlockEntity` instance.
-
-        :param namespace: The namespace of the block entity eg "minecraft"
-        :param base_name: The base name of the block entity eg "chest"
-        :param x: The x coordinate of the block entity
-        :param y: The y coordinate of the block entity
-        :param z: The z coordinate of the block entity
-        :param nbt: The NBT stored with the block entity
-        """
-        super().__init__(namespace, base_name, x, y, z, nbt)
-
-    @property
-    def x(self) -> int:
-        """The x location of the BlockEntity. Read Only"""
-        return self._x
-
-    @property
-    def y(self) -> int:
-        """The y location of the BlockEntity. Read Only"""
-        return self._y
-
-    @property
-    def z(self) -> int:
-        """The z location of the BlockEntity. Read Only"""
-        return self._z
-
-    @property
-    def location(self) -> BlockCoordinates:
-        """The location of the BlockEntity. Read Only"""
-        return self._x, self._y, self._z
-
-    def new_at_location(self, x: int, y: int, z: int) -> BlockEntity:
-        """
-        Creates a copy of this BlockEntity at a new location
-        BlockEntities are stored in the chunk based on their location so location cannot be mutable
-        """
-        return BlockEntity(
-            self._namespace,
-            self._base_name,
-            x,
-            y,
-            z,
-            copy.deepcopy(self._nbt),
-        )
+from __future__ import annotations
+import copy
+import numpy
+
+from amulet_nbt import NamedTag
+from amulet.api.data_types import BlockCoordinates
+from .abstract_base_entity import AbstractBaseEntity
+
+
+class BlockEntity(AbstractBaseEntity):
+    """
+    A class to contain all the data to define a BlockEntity.
+    """
+
+    obj_name = "BlockEntity"
+    coord_types = (int, numpy.integer)
+
+    def __init__(
+        self,
+        namespace: str,
+        base_name: str,
+        x: int,
+        y: int,
+        z: int,
+        nbt: NamedTag,
+    ):
+        """
+        Constructs a :class:`BlockEntity` instance.
+
+        :param namespace: The namespace of the block entity eg "minecraft"
+        :param base_name: The base name of the block entity eg "chest"
+        :param x: The x coordinate of the block entity
+        :param y: The y coordinate of the block entity
+        :param z: The z coordinate of the block entity
+        :param nbt: The NBT stored with the block entity
+        """
+        super().__init__(namespace, base_name, x, y, z, nbt)
+
+    @property
+    def x(self) -> int:
+        """The x location of the BlockEntity. Read Only"""
+        return self._x
+
+    @property
+    def y(self) -> int:
+        """The y location of the BlockEntity. Read Only"""
+        return self._y
+
+    @property
+    def z(self) -> int:
+        """The z location of the BlockEntity. Read Only"""
+        return self._z
+
+    @property
+    def location(self) -> BlockCoordinates:
+        """The location of the BlockEntity. Read Only"""
+        return self._x, self._y, self._z
+
+    def new_at_location(self, x: int, y: int, z: int) -> BlockEntity:
+        """
+        Creates a copy of this BlockEntity at a new location
+        BlockEntities are stored in the chunk based on their location so location cannot be mutable
+        """
+        return BlockEntity(
+            self._namespace,
+            self._base_name,
+            x,
+            y,
+            z,
+            copy.deepcopy(self._nbt),
+        )

amulet/api/cache.py

@@ -1,107 +1,107 @@
-# A cache for objects implemented using leveldb for speed.
-import os
-import shutil
-import time
-import logging
-import glob
-import re
-import tempfile
-
-import portalocker
-
-
-def _get_cache_dir() -> str:
-    return os.environ.get("AMULET_LEVEL_CACHE_DIR", None) or os.path.join(
-        os.environ.get("CACHE_DIR"), "level_data"
-    )
-
-
-log = logging.getLogger(__name__)
-
-
-def _clear_legacy_cache():
-    legacy_cache_dir = _get_cache_dir()
-    world_temp_dir = os.path.join(legacy_cache_dir, "world_temp")
-    if not os.path.isdir(world_temp_dir):
-        return
-    paths = [
-        os.path.join(legacy_cache_dir, t)
-        for t in os.listdir(world_temp_dir)
-        if t.isnumeric() and int(t) < (time.time() - 7 * 24 * 3600)
-    ]
-    if paths:
-        log.info("Removing legacy cache.")
-
-        # remove all cache directories that were created before a week ago
-        # Sometimes if the program is stopped or it crashes the cleanup won't happen
-        for path in paths:
-            shutil.rmtree(path, ignore_errors=True)
-
-
-_clear_legacy_cache()
-
-
-TempPattern = re.compile(r"amulettmp.*?-(?P<time>\d+)")
-
-
-def _clear_temp_dirs():
-    """
-    Try and delete historic temporary directories.
-    If things went very wrong in past sessions temporary directories may still exist.
-    """
-    temp_dir = tempfile.gettempdir()
-    for path in glob.glob(os.path.join(glob.escape(temp_dir), "amulettmp*")):
-        name = os.path.relpath(path, temp_dir)
-        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
-    """
-
-    def __new__(cls):
-        cache_dir = _get_cache_dir()
-        os.makedirs(cache_dir, exist_ok=True)
-        self = super().__new__(
-            cls,
-            tempfile.mkdtemp(
-                prefix="amulettmp",
-                suffix=f"-{time.time():.0f}",
-                dir=cache_dir,
-            ),
-        )
-        self.__lock = open(os.path.join(self, "lock"), "w")
-        portalocker.lock(self.__lock, portalocker.LockFlags.EXCLUSIVE)
-        return self
-
-    def close(self):
-        """Close the lock and delete the directory."""
-        if self.__lock is not None:
-            portalocker.unlock(self.__lock)
-            self.__lock.close()
-            self.__lock = None
-            shutil.rmtree(self)
-
-    def __del__(self):
-        self.close()
+# A cache for objects implemented using leveldb for speed.
+import os
+import shutil
+import time
+import logging
+import glob
+import re
+import tempfile
+
+import portalocker
+
+
+def _get_cache_dir() -> str:
+    return os.environ.get("AMULET_LEVEL_CACHE_DIR", None) or os.path.join(
+        os.environ.get("CACHE_DIR"), "level_data"
+    )
+
+
+log = logging.getLogger(__name__)
+
+
+def _clear_legacy_cache():
+    legacy_cache_dir = _get_cache_dir()
+    world_temp_dir = os.path.join(legacy_cache_dir, "world_temp")
+    if not os.path.isdir(world_temp_dir):
+        return
+    paths = [
+        os.path.join(legacy_cache_dir, t)
+        for t in os.listdir(world_temp_dir)
+        if t.isnumeric() and int(t) < (time.time() - 7 * 24 * 3600)
+    ]
+    if paths:
+        log.info("Removing legacy cache.")
+
+        # remove all cache directories that were created before a week ago
+        # Sometimes if the program is stopped or it crashes the cleanup won't happen
+        for path in paths:
+            shutil.rmtree(path, ignore_errors=True)
+
+
+_clear_legacy_cache()
+
+
+TempPattern = re.compile(r"amulettmp.*?-(?P<time>\d+)")
+
+
+def _clear_temp_dirs():
+    """
+    Try and delete historic temporary directories.
+    If things went very wrong in past sessions temporary directories may still exist.
+    """
+    temp_dir = tempfile.gettempdir()
+    for path in glob.glob(os.path.join(glob.escape(temp_dir), "amulettmp*")):
+        name = os.path.relpath(path, temp_dir)
+        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
+    """
+
+    def __new__(cls):
+        cache_dir = _get_cache_dir()
+        os.makedirs(cache_dir, exist_ok=True)
+        self = super().__new__(
+            cls,
+            tempfile.mkdtemp(
+                prefix="amulettmp",
+                suffix=f"-{time.time():.0f}",
+                dir=cache_dir,
+            ),
+        )
+        self.__lock = open(os.path.join(self, "lock"), "w")
+        portalocker.lock(self.__lock, portalocker.LockFlags.EXCLUSIVE)
+        return self
+
+    def close(self):
+        """Close the lock and delete the directory."""
+        if self.__lock is not None:
+            portalocker.unlock(self.__lock)
+            self.__lock.close()
+            self.__lock = None
+            shutil.rmtree(self)
+
+    def __del__(self):
+        self.close()

amulet/api/chunk/__init__.py

@@ -1,6 +1,6 @@
-from .blocks import Blocks
-from .status import Status, StatusFormats
-from .biomes import Biomes, BiomesShape
-from .entity_list import EntityList
-from .block_entity_dict import BlockEntityDict
-from .chunk import Chunk
+from .blocks import Blocks
+from .status import Status, StatusFormats
+from .biomes import Biomes, BiomesShape
+from .entity_list import EntityList
+from .block_entity_dict import BlockEntityDict
+from .chunk import Chunk