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

amulet/level/abc/_chunk_handle.py

@@ -12,6 +12,7 @@ from amulet.chunk import Chunk, get_null_chunk
 from amulet.data_types import DimensionId
 from amulet.errors import ChunkDoesNotExist, ChunkLoadError
 from amulet.utils.signal import Signal
+from amulet.utils.shareable_lock import ShareableRLock
 
 from ._level import LevelFriend, LevelT
 from ._history import HistoryManagerLayer
@@ -58,7 +59,7 @@ class ChunkHandle(
     Some internal synchronisation is done to catch some threading issues.
     """
 
-    _lock: RLock
+    _lock: ShareableRLock
     _dimension: DimensionId
     _key: ChunkKey
     _chunk_history: HistoryManagerLayer[ChunkKey]
@@ -84,7 +85,7 @@ class ChunkHandle(
         cz: int,
     ) -> None:
         super().__init__(level_ref)
-        self._lock = RLock()
+        self._lock = ShareableRLock()
         self._dimension_id = dimension_id
         self._key = ChunkKey(cx, cz)
         self._chunk_history = chunk_history
@@ -135,13 +136,7 @@ class ChunkHandle(
         :raises:
             LockNotAcquired: If the lock could not be acquired.
         """
-        if not self._lock.acquire(blocking, timeout):
-            # Thread was not acquired
-            raise LockNotAcquired("Lock was not acquired.")
-        try:
-            yield
-        finally:
-            self._lock.release()
+        return self._lock.unique(blocking, timeout)
 
     @contextmanager
     def edit(
@@ -171,7 +166,7 @@ class ChunkHandle(
         :raises:
             LockNotAcquired: If the lock could not be acquired.
         """
-        with self.lock(blocking=blocking, timeout=timeout):
+        with self._lock.unique(blocking=blocking, timeout=timeout):
             chunk = self.get(components)
             yield chunk
             # If an exception occurs in user code, this line won't be run.
@@ -187,14 +182,18 @@ class ChunkHandle(
 
         :return: True if the chunk exists. Calling get on this chunk handle may still throw ChunkLoadError
         """
-        if self._chunk_history.has_resource(self._key):
-            return self._chunk_history.resource_exists(self._key)
-        else:
-            # The history system is not aware of the chunk. Look in the level data
-            return self._get_raw_dimension().has_chunk(self.cx, self.cz)
+        with self._lock.shared():
+            if self._chunk_history.has_resource(self._key):
+                return self._chunk_history.resource_exists(self._key)
+            else:
+                # The history system is not aware of the chunk. Look in the level data
+                return self._get_raw_dimension().has_chunk(self.cx, self.cz)
 
     def _preload(self) -> None:
-        """Load the chunk data if it has not already been loaded."""
+        """
+        Load the chunk data if it has not already been loaded.
+        The lock must be acquired in unique mode before calling this.
+        """
         if not self._chunk_history.has_resource(self._key):
             # The history system is not aware of the chunk. Load from the level data
             chunk: Chunk
@@ -260,8 +259,9 @@ class ChunkHandle(
         :param components: None to load all components or an iterable of component strings to load.
         :return: A unique copy of the chunk data.
         """
-        with self.lock(blocking=False):
-            self._preload()
+
+        def get_chunk() -> ChunkT:
+            nonlocal components
             chunk = self._get_null_chunk()
             if components is None:
                 components = chunk.component_ids
@@ -276,8 +276,25 @@ class ChunkHandle(
             chunk.reconstruct_chunk(chunk_components)
             return chunk
 
+        # Block if the chunk is locked in unique mode.
+        with self._lock.shared():
+            if self._chunk_history.has_resource(self._key):
+                # Does not need loading from disk.
+                return get_chunk()
+
+        # Acquire the lock in unique mode.
+        with self._lock.unique():
+            # If it wasn't already loaded by another thread.
+            if not self._chunk_history.has_resource(self._key):
+                # Load it from disk.
+                self._preload()
+
+        with self._lock.shared():
+            # If it was loaded in another thread just read it from the cache.
+            return get_chunk()
+
     def _set(self, chunk: ChunkT | None) -> None:
-        """Lock must be acquired before calling this"""
+        """lock must be acquired in unique mode before calling this."""
         history = self._chunk_history
         if not history.has_resource(self._key):
             if self._l.history_enabled:
@@ -322,14 +339,20 @@ class ChunkHandle(
         :raises:
             LockNotAcquired: If the chunk is already locked by another thread.
         """
-        with self.lock(blocking=False):
+        with self._lock.unique(blocking=False):
             self._set(chunk)
         self.changed.emit()
         self._l.changed.emit()
 
     def delete(self) -> None:
-        """Delete the chunk from the level."""
-        with self.lock(blocking=False):
+        """
+        Delete the chunk from the level.
+        You must acquire the chunk lock before deleting.
+
+        :raises:
+            LockNotAcquired: If the chunk is already locked by another thread.
+        """
+        with self._lock.unique(blocking=False):
             self._set(None)
         self.changed.emit()
         self._l.changed.emit()

amulet/level/abc/_level/_creatable_level.py

@@ -2,7 +2,6 @@ from __future__ import annotations
 from abc import ABC, abstractmethod
 from typing import TYPE_CHECKING, Any
 
-from amulet.utils.typing import Intersection
 from amulet.utils.call_spec import method_spec
 
 
@@ -18,7 +17,7 @@ class CreatableLevel(ABC):
     @classmethod
     @abstractmethod
     @method_spec()
-    def create(cls, *args: Any, **kwargs: Any) -> Intersection[Level, CreatableLevel]:
+    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.

amulet/level/abc/_level/_level.py

@@ -3,16 +3,15 @@ from __future__ import annotations
 from abc import ABC, abstractmethod
 from typing import TYPE_CHECKING, Optional, TypeVar, Type, Generic, Iterator, Callable
 from contextlib import contextmanager, AbstractContextManager as ContextManager
-import os
 import logging
 from weakref import finalize
 
 from runtime_final import final
 from PIL import Image
 
-from amulet import IMG_DIRECTORY
 from amulet.version import PlatformType, VersionNumber
 from amulet.data_types import DimensionId
+from amulet.img import missing_world_icon_path
 
 from amulet.chunk import Chunk
 
@@ -31,9 +30,6 @@ if TYPE_CHECKING:
 
 log = logging.getLogger(__name__)
 
-missing_world_icon_path = os.path.abspath(
-    os.path.join(IMG_DIRECTORY, "missing_world_icon.png")
-)
 missing_world_icon: Optional[Image.Image] = None
 
 

amulet/level/java/__init__.pyi

@@ -1,7 +1,5 @@
 from __future__ import annotations
 
-import typing
-
 from amulet.level.java._level import JavaLevel
 
 from . import (
@@ -16,6 +14,3 @@ from . import (
 )
 
 __all__ = ["JavaLevel", "anvil", "chunk", "chunk_components", "long_array"]
-
-def __dir__() -> typing.Any: ...
-def __getattr__(arg0: typing.Any) -> typing.Any: ...

amulet/level/java/_raw/__init__.pyi

@@ -1,6 +1,5 @@
 from __future__ import annotations
 
-import typing
 from builtins import str as InternalDimensionId
 
 from amulet.level.java._raw._dimension import JavaRawDimension
@@ -14,6 +13,3 @@ __all__ = [
     "JavaRawDimension",
     "JavaRawLevel",
 ]
-
-def __dir__() -> typing.Any: ...
-def __getattr__(arg0: typing.Any) -> typing.Any: ...

amulet/level/java/_raw/java_chunk_decode.cpp

@@ -10,8 +10,6 @@
 
 #include <pybind11/pybind11.h>
 
-#include <amulet/pybind11/python.hpp>
-
 #include <amulet_nbt/tag/named_tag.hpp>
 #include <amulet_nbt/tag/compound.hpp>
 
@@ -316,7 +314,7 @@ namespace Amulet {
 					
 					// TODO: convert this to C++
 					py::object waterloggable = game_version.attr("block").attr("waterloggable")(block_namespace, block_base_name);
-					if (py::equals(waterloggable, WaterloggableYes)) {
+					if (waterloggable.equal(WaterloggableYes)) {
 						auto waterlogged_it = block_properties.find("waterlogged");
 						if (
 							waterlogged_it != block_properties.end() and 
@@ -328,7 +326,7 @@ namespace Amulet {
 							block_properties.erase(waterlogged_it);
 						}
 					}
-					else if (py::equals(waterloggable, WaterloggableAlways)) {
+					else if (waterloggable.equal(WaterloggableAlways)) {
 						blocks.push_back(get_water());
 					}
 					blocks.insert(

amulet/level/java/long_array.pyi

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import numpy
+import numpy.typing
 import typing_extensions
 
 __all__ = ["decode_long_array", "encode_long_array"]
@@ -26,7 +27,7 @@ def encode_long_array(
     bits_per_entry: None | int = None,
     dense: bool = True,
     min_bits_per_entry: int = 1,
-) -> numpy.ndarray[numpy.uint64]:
+) -> numpy.typing.NDArray[numpy.uint64]:
     """
     Encode a long array (from BlockStates or Heightmaps)
 

amulet/mesh/block/__init__.pyi

@@ -0,0 +1,301 @@
+from __future__ import annotations
+
+import collections.abc
+import typing
+
+import numpy
+import pybind11_stubgen.typing_ext
+from amulet.mesh.block._cube import get_cube, get_unit_cube
+from amulet.mesh.block._missing_block import get_missing_block
+
+from . import _cube, _missing_block
+
+__all__ = [
+    "BlockMesh",
+    "BlockMeshCullDirection",
+    "BlockMeshPart",
+    "BlockMeshTransparency",
+    "CUBE_FACE_LUT",
+    "FACE_KEYS",
+    "FloatVec2",
+    "FloatVec3",
+    "TRI_FACE",
+    "Triangle",
+    "UV_ROTATION_LUT",
+    "Vertex",
+    "get_cube",
+    "get_missing_block",
+    "get_unit_cube",
+    "merge_block_meshes",
+]
+
+class BlockMesh:
+    """
+    All the data that makes up a block mesh.
+    """
+
+    def __init__(
+        self,
+        transparency: BlockMeshTransparency,
+        textures: list[str],
+        parts: tuple[
+            BlockMeshPart | None,
+            BlockMeshPart | None,
+            BlockMeshPart | None,
+            BlockMeshPart | None,
+            BlockMeshPart | None,
+            BlockMeshPart | None,
+            BlockMeshPart | None,
+        ],
+    ) -> None: ...
+    def rotate(self, rotx: int, roty: int) -> BlockMesh:
+        """
+        Rotate the mesh in the x and y axis. Accepted values are -3 to 3 which corrospond to 90 degree rotations.
+        """
+
+    @property
+    def parts(
+        self,
+    ) -> typing.Annotated[
+        list[BlockMeshPart | None], pybind11_stubgen.typing_ext.FixedSize(7)
+    ]:
+        """
+        The mesh parts that make up this mesh. The index corrosponds to the value of BlockMeshCullDirection.
+        """
+
+    @parts.setter
+    def parts(
+        self,
+        arg0: typing.Annotated[
+            list[BlockMeshPart | None], pybind11_stubgen.typing_ext.FixedSize(7)
+        ],
+    ) -> None: ...
+    @property
+    def textures(self) -> list[str]:
+        """
+        The texture paths used in this block mesh. The Triangle's texture_index attribute is an index into this list.
+        """
+
+    @textures.setter
+    def textures(self, arg0: list[str]) -> None: ...
+    @property
+    def transparency(self) -> BlockMeshTransparency:
+        """
+        The transparency state of this block mesh.
+        """
+
+    @transparency.setter
+    def transparency(self, arg0: BlockMeshTransparency) -> None: ...
+
+class BlockMeshCullDirection:
+    """
+    The direction a mesh part is culled by. The value corrosponds to the index in the mesh parts array.
+
+    Members:
+
+      CullNone : Is not culled by any neighbouring blocks.
+
+      CullUp : Is culled by an opaque block above.
+
+      CullDown : Is culled by an opaque block below.
+
+      CullNorth : Is culled by an opaque block to the north.
+
+      CullEast : Is culled by an opaque block to the east.
+
+      CullSouth : Is culled by an opaque block to the south.
+
+      CullWest : Is culled by an opaque block to the west.
+    """
+
+    CullDown: typing.ClassVar[
+        BlockMeshCullDirection
+    ]  # value = <BlockMeshCullDirection.CullDown: 2>
+    CullEast: typing.ClassVar[
+        BlockMeshCullDirection
+    ]  # value = <BlockMeshCullDirection.CullEast: 4>
+    CullNone: typing.ClassVar[
+        BlockMeshCullDirection
+    ]  # value = <BlockMeshCullDirection.CullNone: 0>
+    CullNorth: typing.ClassVar[
+        BlockMeshCullDirection
+    ]  # value = <BlockMeshCullDirection.CullNorth: 3>
+    CullSouth: typing.ClassVar[
+        BlockMeshCullDirection
+    ]  # value = <BlockMeshCullDirection.CullSouth: 5>
+    CullUp: typing.ClassVar[
+        BlockMeshCullDirection
+    ]  # value = <BlockMeshCullDirection.CullUp: 1>
+    CullWest: typing.ClassVar[
+        BlockMeshCullDirection
+    ]  # value = <BlockMeshCullDirection.CullWest: 6>
+    __members__: typing.ClassVar[
+        dict[str, BlockMeshCullDirection]
+    ]  # value = {'CullNone': <BlockMeshCullDirection.CullNone: 0>, 'CullUp': <BlockMeshCullDirection.CullUp: 1>, 'CullDown': <BlockMeshCullDirection.CullDown: 2>, 'CullNorth': <BlockMeshCullDirection.CullNorth: 3>, 'CullEast': <BlockMeshCullDirection.CullEast: 4>, 'CullSouth': <BlockMeshCullDirection.CullSouth: 5>, 'CullWest': <BlockMeshCullDirection.CullWest: 6>}
+    def __and__(self, other: typing.Any) -> typing.Any: ...
+    def __eq__(self, other: typing.Any) -> bool: ...
+    def __ge__(self, other: typing.Any) -> bool: ...
+    def __gt__(self, other: typing.Any) -> bool: ...
+    def __hash__(self) -> int: ...
+    def __index__(self) -> int: ...
+    def __init__(self, value: int) -> None: ...
+    def __int__(self) -> int: ...
+    def __invert__(self) -> typing.Any: ...
+    def __le__(self, other: typing.Any) -> bool: ...
+    def __lt__(self, other: typing.Any) -> bool: ...
+    def __ne__(self, other: typing.Any) -> bool: ...
+    def __or__(self, other: typing.Any) -> typing.Any: ...
+    def __rand__(self, other: typing.Any) -> typing.Any: ...
+    def __repr__(self) -> str: ...
+    def __ror__(self, other: typing.Any) -> typing.Any: ...
+    def __rxor__(self, other: typing.Any) -> typing.Any: ...
+    def __str__(self) -> str: ...
+    def __xor__(self, other: typing.Any) -> typing.Any: ...
+    @property
+    def name(self) -> str: ...
+    @property
+    def value(self) -> int: ...
+
+class BlockMeshPart:
+    """
+    A part of a block mesh for one of the culling directions.
+    """
+
+    def __init__(self, verts: list[Vertex], triangles: list[Triangle]) -> None: ...
+    @property
+    def triangles(self) -> list[Triangle]:
+        """
+        The triangles in this block mesh part.
+        """
+
+    @triangles.setter
+    def triangles(self, arg0: list[Triangle]) -> None: ...
+    @property
+    def verts(self) -> list[Vertex]:
+        """
+        The vertices in this block mesh part.
+        """
+
+    @verts.setter
+    def verts(self, arg0: list[Vertex]) -> None: ...
+
+class BlockMeshTransparency:
+    """
+    The transparency of a block mesh.
+
+    Members:
+
+      FullOpaque : A block that occupies the whole block and is opaque.
+
+      FullTranslucent : A block that occupies the whole block and has at least one translucent face.
+
+      Partial : A block that does not occupy the whole block.
+    """
+
+    FullOpaque: typing.ClassVar[
+        BlockMeshTransparency
+    ]  # value = <BlockMeshTransparency.FullOpaque: 0>
+    FullTranslucent: typing.ClassVar[
+        BlockMeshTransparency
+    ]  # value = <BlockMeshTransparency.FullTranslucent: 1>
+    Partial: typing.ClassVar[
+        BlockMeshTransparency
+    ]  # value = <BlockMeshTransparency.Partial: 2>
+    __members__: typing.ClassVar[
+        dict[str, BlockMeshTransparency]
+    ]  # value = {'FullOpaque': <BlockMeshTransparency.FullOpaque: 0>, 'FullTranslucent': <BlockMeshTransparency.FullTranslucent: 1>, 'Partial': <BlockMeshTransparency.Partial: 2>}
+    def __eq__(self, other: typing.Any) -> bool: ...
+    def __ge__(self, other: typing.Any) -> bool: ...
+    def __gt__(self, other: typing.Any) -> bool: ...
+    def __hash__(self) -> int: ...
+    def __index__(self) -> int: ...
+    def __init__(self, value: int) -> None: ...
+    def __int__(self) -> int: ...
+    def __le__(self, other: typing.Any) -> bool: ...
+    def __lt__(self, other: typing.Any) -> bool: ...
+    def __ne__(self, other: typing.Any) -> bool: ...
+    def __repr__(self) -> str: ...
+    def __str__(self) -> str: ...
+    @property
+    def name(self) -> str: ...
+    @property
+    def value(self) -> int: ...
+
+class FloatVec2:
+    """
+    A 2D floating point vector
+    """
+
+    x: float
+    y: float
+    def __init__(self, x: float, y: float) -> None: ...
+
+class FloatVec3:
+    """
+    A 3D floating point vector
+    """
+
+    x: float
+    y: float
+    z: float
+    def __init__(self, x: float, y: float, z: float) -> None: ...
+
+class Triangle:
+    """
+    The vertex and texture indexes that make up a triangle.
+    """
+
+    texture_index: int
+    vert_index_a: int
+    vert_index_b: int
+    vert_index_c: int
+    def __init__(
+        self,
+        vert_index_a: int,
+        vert_index_b: int,
+        vert_index_c: int,
+        texture_index: int,
+    ) -> None: ...
+
+class Vertex:
+    """
+    Attributes for a single vertex.
+    """
+
+    def __init__(
+        self, coord: FloatVec3, texture_coord: FloatVec2, tint: FloatVec3
+    ) -> None: ...
+    @property
+    def coord(self) -> FloatVec3:
+        """
+        The spatial coordinate of the vertex.
+        """
+
+    @coord.setter
+    def coord(self, arg0: FloatVec3) -> None: ...
+    @property
+    def texture_coord(self) -> FloatVec2:
+        """
+        The texture coordinate of the vertex.
+        """
+
+    @texture_coord.setter
+    def texture_coord(self, arg0: FloatVec2) -> None: ...
+    @property
+    def tint(self) -> FloatVec3:
+        """
+        The tint colour for the vertex.
+        """
+
+    @tint.setter
+    def tint(self, arg0: FloatVec3) -> None: ...
+
+def merge_block_meshes(meshes: collections.abc.Sequence[BlockMesh]) -> BlockMesh:
+    """
+    Merge multiple block mesh objects into one block mesh.
+    """
+
+CUBE_FACE_LUT: dict  # value = {'down': array([0, 4, 5, 1]), 'up': array([3, 7, 6, 2]), 'north': array([4, 0, 2, 6]), 'east': array([5, 4, 6, 7]), 'south': array([1, 5, 7, 3]), 'west': array([0, 1, 3, 2])}
+FACE_KEYS: dict  # value = {None: <BlockMeshCullDirection.CullNone: 0>, 'up': <BlockMeshCullDirection.CullUp: 1>, 'down': <BlockMeshCullDirection.CullDown: 2>, 'north': <BlockMeshCullDirection.CullNorth: 3>, 'east': <BlockMeshCullDirection.CullEast: 4>, 'south': <BlockMeshCullDirection.CullSouth: 5>, 'west': <BlockMeshCullDirection.CullWest: 6>}
+TRI_FACE: numpy.ndarray  # value = array([0, 1, 2, 0, 2, 3], dtype=uint32)
+UV_ROTATION_LUT: list = [0, 3, 2, 3, 2, 1, 0, 1]