pylitematic 0.0.4__py3-none-any.whl → 0.0.5__py3-none-any.whl

pylitematic/__init__.py

@@ -1,7 +1,6 @@
-__version__ = "0.0.4"
+__version__ = "0.0.5"
 
-from .block_state import BlockState
+from .block_state import AIR, BlockId, BlockState
 from .geometry import BlockPosition, Direction, Size3D
 from .region import Region
-from .resource_location import BlockId
 from .schematic import Schematic

pylitematic/block_palette.py

@@ -0,0 +1,129 @@
+from __future__ import annotations
+
+import copy
+import nbtlib
+import numpy as np
+from typing import Iterator
+
+from .block_state import AIR, BlockId, BlockState
+
+
+class BlockPalette:
+    def __init__(self):
+        self._states: list[BlockState] = []
+        self._map: dict[BlockState, int] = {}
+        self.add_state(AIR)
+
+    def __len__(self):
+        return len(self._states)
+
+    def __str__(self) -> str:
+        return str({str(s): i for s, i in self._map.items()})
+
+    def __repr__(self) -> str:
+        return f"{type(self).__name__}({self._map})"
+
+    def __contains__(self, key) -> bool:
+        # TODO: add BlockId comparison?
+        if not isinstance(key, BlockState):
+            return NotImplemented
+        return key in self._map
+
+    def __eq__(self, other) -> bool | np.ndarray[bool]:
+        if not isinstance(other, (BlockState, BlockId)):
+            return NotImplemented
+        return np.array(self) == other
+
+    def __iter__(self) -> Iterator[tuple[BlockState, int]]:
+        return self.items()
+
+    def __array__(self, dtype: type | None = None, copy: bool = True):
+        arr = np.array(self._states, dtype=object)
+        return arr.copy() if copy else arr
+
+    def states(self) -> Iterator[BlockState]:
+        for state in self._map.keys():
+            yield state
+
+    def indices(self) -> Iterator[int]:
+        for index in self._map.values():
+            yield index
+
+    def items(self) -> Iterator[tuple[BlockState, int]]:
+        for state, index in self._map.items():
+            yield state, index
+
+    @property
+    def bits_per_state(self) -> int:
+        return max(2, (len(self) - 1).bit_length())
+
+    def copy(self) -> BlockPalette:
+        pal = BlockPalette()
+        pal._states = copy.deepcopy(self._states)
+        pal._map = copy.deepcopy(self._map)
+        return pal
+
+    def clear(self) -> None:
+        self._states.clear()
+        self._map.clear()
+        self.add_state(AIR)
+
+    def add_state(self, state: BlockState) -> int:
+        if state in self:
+            return self._map[state]
+        else:
+            index = len(self)
+            self._states.append(state)
+            self._map[state] = index
+            return index
+
+    def get_state(
+        self,
+        index: int | np.ndarray[int],
+    ) -> BlockState | np.ndarray[BlockState]:
+        return np.array(self._states, dtype=object)[np.array(index, dtype=int)]
+
+    def get_index(
+        self,
+        state: BlockState | np.ndarray[BlockState],
+        add_missing: bool = False,
+    ) -> int | np.ndarray[int]:
+        state = np.asarray(state, dtype=object)
+        unique_states, xdi = np.unique(state, return_inverse=True)
+        idx = []
+        for block in unique_states:
+            if block not in self and not add_missing:
+                raise KeyError(f"BlockState '{block!s}' not found in palette.")
+            idx.append(self.add_state(block))
+
+        index = np.array(idx, dtype=int)[xdi].reshape(state.shape)
+        return index.item() if np.isscalar(index) else index
+
+    def reduce(self, indices: np.ndarray[int]) -> None:
+        if not (isinstance(indices, np.ndarray) and indices.dtype == int):
+            raise TypeError("'indices' has to be a numpy array of integers")
+
+        unique_idx = np.unique(indices)
+        if 0 not in unique_idx:
+            # always include minecraft:air as the first entry in the palette
+            unique_idx = np.insert(unique_idx, 0, 0)
+        self._states = np.array(self._states, dtype=object)[unique_idx].tolist()
+        self._map = {state: i for i, state in enumerate(self._states)}
+
+        old_new_map = {old: new for new, old in enumerate(unique_idx)}
+        lookup = np.full(max(old_new_map) + 1, -1, dtype=int)
+        for old, new in old_new_map.items():
+            lookup[old] = new
+        return lookup[indices]
+
+    def to_nbt(self) -> nbtlib.List[nbtlib.Compound]:
+        pal = [state.to_nbt() for state in self._states]
+        return nbtlib.List[nbtlib.Compound](pal)
+
+    @classmethod
+    def from_nbt(cls, nbt: nbtlib.List[nbtlib.Compound]) -> BlockPalette:
+        states = [BlockState.from_nbt(block) for block in nbt]
+        pal = cls()
+        pal._states = states
+        pal._map = {state: i for i, state in enumerate(states)}
+        return pal

pylitematic/block_state.py

@@ -1,11 +1,22 @@
 from __future__ import annotations
 
 from copy import deepcopy
+from dataclasses import dataclass
 from nbtlib import Compound
 from typing import Any, Iterator
 
-from .resource_location import BlockId
 from .block_property import Properties
+from .resource_location import ResourceLocation
+
+
+@dataclass(frozen=True, order=True)
+class BlockId(ResourceLocation):
+
+    def __eq__(self, other: Any) -> bool:
+        if isinstance(other, BlockState):
+            return self == other.id
+        else:
+            return super().__eq__(other)
 
 
 class BlockState:
@@ -42,10 +53,18 @@ class BlockState:
 
     def __eq__(self, other: Any) -> bool:
         if isinstance(other, str):
-            other = BlockState.from_string(other)
-        elif not isinstance(other, BlockState):
+            try:
+                other = BlockState.from_string(other)
+                return self == other
+            except ValueError:
+                return False
+
+        if isinstance(other, BlockId):
+            return self.id == other
+        elif isinstance(other, BlockState):
+            return (self.id, self._props) == (other.id, other._props)
+        else:
             return NotImplemented
-        return (self.id, self._props) == (other.id, other._props)
 
     def __lt__(self, other: Any) -> bool:
         if not isinstance(other, BlockState):
@@ -117,3 +136,6 @@ class BlockState:
 
     def without_props(self) -> BlockState:
         return BlockState(self.id)
+
+
+AIR = BlockState("air")

pylitematic/geometry.py

@@ -51,7 +51,7 @@ class Vec3i:
         return self.__add__(other)
 
     def __sub__(self, other) -> Vec3i:
-        return self.__add__(-other)
+        return type(self)(*(np.array(self) - other))
 
     def __rsub__(self, other) -> Vec3i:
         return -self.__sub__(other)

pylitematic/property_cache.py

@@ -0,0 +1,52 @@
+import functools
+
+
+class cached_property:
+    def __init__(self, func):
+        self.func = func
+        self.name = func.__name__
+        functools.update_wrapper(self, func)
+
+    def __get__(self, instance, owner=None):
+        if instance is None:
+            return self
+
+        if not hasattr(instance, "_cache"):
+            raise AttributeError("Instance must have a '_cache' attribute")
+
+        cache = instance._cache
+        if self.name not in cache:
+            cache[self.name] = self.func(instance)
+        return cache[self.name]
+
+
+def clears_cache(func):
+    @functools.wraps(func)
+    def wrapper(self, *args, **kwargs):
+        if hasattr(self, "_cache"):
+            self._cache.clear()
+        return func(self, *args, **kwargs)
+    return wrapper
+
+
+class PropertyCache(dict):
+    def __getattr__(self, name):
+        try:
+            return self[name]
+        except KeyError:
+            raise AttributeError(f"No cached value for {name!r}")
+
+    def __setattr__(self, name, value):
+        self[name] = value
+
+    def __delattr__(self, name):
+        try:
+            del self[name]
+        except KeyError:
+            raise AttributeError(f"No cached value named {name!r}")
+
+
+class PropertyCacheMixin:
+    def __init__(self, *args, **kwargs) -> None:
+        super().__init__(*args, **kwargs)
+        self._cache = PropertyCache()

pylitematic/region.py

@@ -2,19 +2,16 @@ from __future__ import annotations
 
 from abc import ABC, abstractmethod
 from bitpacking import bitpack, bitunpack
-from functools import cached_property
+import copy
 from itertools import product
 import nbtlib
 import numpy as np
 import twos
 from typing import Iterator
 
-from .block_state import BlockState
-from .geometry import BlockPosition, Size3D
-from .resource_location import BlockId
-
-
-AIR = BlockState("air")
+from .block_palette import BlockPalette
+from .block_state import AIR, BlockId, BlockState
+from .geometry import BlockPosition, Direction, Size3D
 
 
 class Region:
@@ -31,9 +28,8 @@ class Region:
             origin = BlockPosition(*origin)
         self._origin: BlockPosition = origin
 
-        self._palette: list[BlockState] = [AIR] # TODO: add clear method
-        self._palette_map: dict[BlockState, int] = {AIR: 0} # TODO: bind tighter to _palette
-        self._blocks = np.zeros(abs(self._size), dtype=int)
+        self._palette: BlockPalette = BlockPalette()
+        self._index_array = np.zeros(abs(self._size), dtype=int)
 
         # TODO: Add support for (tile) entities and ticks
         self._entities = nbtlib.List[nbtlib.Compound]()
@@ -44,6 +40,7 @@ class Region:
         self._local = LocalRegionView(self)
         self._world = WorldRegionView(self)
         self._numpy = NumpyRegionView(self)
+        self._view = self._local
 
     @property
     def local(self) -> LocalRegionView:
@@ -57,67 +54,92 @@ class Region:
     def numpy(self) -> NumpyRegionView:
         return self._numpy
 
+    def set_default_view(self, view: _RegionView) -> None:
+        self._view = view
+
     def __contains__(self, item) -> bool:
-        return item in self.local
+        return item in self._view
+
+    def __eq__(self, other) -> np.ndarray[bool]:
+        return self._view == other
+
+    def __ne__(self, other) -> np.ndarray[bool]:
+        return self._view != other
 
-    def __eq__(self, other) -> bool:
-        return self.local == other
+    def __lt__(self, other) -> np.ndarray[bool]:
+        return self._view < other
 
-    def __ne__(self, other) -> bool:
-        return self.local != other
+    def __gt__(self, other) -> np.ndarray[bool]:
+        return self._view > other
 
     def __getitem__(self, key):
-        return self.local[key]
+        return self._view[key]
 
     def __setitem__(self, key, value) -> None:
-        self.local[key] = value
+        self._view[key] = value
 
     def __iter__(self) -> tuple[BlockPosition, BlockState]:
-        return iter(self.local)
-
-    def compact_palette(self) -> None:
-        # TODO: determine all appropriate places to call this method
-        idx = np.unique(self._blocks)
-        if 0 not in idx:
-            # always include minecraft:air as the first entry in the palette
-            idx = np.insert(idx, 0, 0)
-        index_map = {old: new for new, old in enumerate(idx)}
+        return iter(self._view)
 
-        # compacted palette and mapping
-        palette = np.array(self._palette, dtype=object)[idx].tolist()
-        palette_map = {res: idx for idx, res in enumerate(palette)}
+    def clear(self) -> None:
+        self._palette.clear()
+        self._index_array = np.zeros(abs(self._size), dtype=int)
 
-        lookup = np.full(max(index_map) + 1, -1, dtype=int)
-        for old, new in index_map.items():
-            lookup[old] = new
-        self._blocks = lookup[self._blocks]
+        self._entities.clear()
+        self._tile_entities.clear()
+        self._block_ticks.clear()
+        self._fluid_ticks.clear()
 
-        self._palette = palette
-        self._palette_map = palette_map
+    def copy(
+        self,
+        origin: tuple[int, int, int] | BlockPosition | None = None,
+    ) -> Region:
+        """Return a copy of the Region."""
+        if origin is None:
+            origin = self._origin
+
+        reg = Region(size=self._size, origin=origin)
+        reg._index_array = copy.deepcopy(self._index_array)
+        reg._palette = self._palette.copy()
+
+        reg._entities = copy.deepcopy(self._entities)
+        reg._tile_entities = copy.deepcopy(self._tile_entities)
+        reg._block_ticks = copy.deepcopy(self._block_ticks)
+        reg._fluid_ticks = copy.deepcopy(self._fluid_ticks)
+        reg._view = type(self._view)(reg)
+
+        return reg
+
+    def flip(self, axis: int | tuple[int] | None = None) -> None:
+        # TODO
+        # * flip size and possibly change origin?
+        # * handle entities
+        # * change BlockState properties accordingly
+        self._index_array = np.flip(self._index_array, axis=axis)
+
+    def reduce_palette(self) -> None:
+        self._index_array = self._palette.reduce(self._index_array)
 
     # block state en- / decoding (NBT)
-    def _bits_per_state(self) -> int:
-        return max(2, (len(self._palette) - 1).bit_length())
-
     def _decode_block_states(
         self,
         data: nbtlib.LongArray,
     ) -> np.ndarray[int]:
         states = bitunpack(
             chunks=[twos.to_unsigned(x, 64) for x in data],
-            field_width=self._bits_per_state(),
+            field_width=self._palette.bits_per_state,
             chunk_width=64,
         )
-        states = list(states)[:self.volume]
+        states = list(states)[:self.volume] # remove trailing bit fields
         shape = (abs(self.height), abs(self.length), abs(self.width))
         states = np.asarray(states, dtype=int).reshape(shape) # y,z,x
         return states.transpose(2, 0, 1) # x,y,z
 
     def _encode_block_states(self) -> nbtlib.LongArray:
-        states = self._blocks.transpose(1, 2, 0).ravel() # x,y,z to y,z,x
+        states = self._index_array.transpose(1, 2, 0).ravel() # x,y,z to y,z,x
         chunks = bitpack(
             states.tolist(),
-            field_width=self._bits_per_state(),
+            field_width=self._palette.bits_per_state,
             chunk_width=64,
         )
         return nbtlib.LongArray([twos.to_signed(x, 64) for x in chunks])
@@ -146,31 +168,79 @@ class Region:
     def origin(self) -> BlockPosition:
         return self._origin
 
-    @property
-    def block_count(self) -> int:
-        # TODO: Add filter BlockStates / BlockIds and rename to count()
-        return np.sum(self != AIR).item()
+    @origin.setter
+    def origin(self, value: tuple[int, int, int] | BlockPosition) -> None:
+        if not isinstance(value, BlockPosition):
+            value = BlockPosition(*value)
+        self._origin = value
+
+    def count(self, block: BlockState | BlockId) -> int:
+        return np.sum(self == block).item()
 
     @property
     def lower(self) -> BlockPosition:
         return self.local.lower
+        # return self._view.lower
 
     @property
     def upper(self) -> BlockPosition:
         return self.local.upper
+        # return self._view.upper
 
     @property
     def bounds(self) -> tuple[BlockPosition, BlockPosition]:
         return self.local.bounds
+        # return self._view.bounds
 
     def items(self) -> Iterator[tuple[BlockPosition, BlockState]]:
-        return self.local.items()
+        return self._view.items()
 
     def positions(self) -> Iterator[BlockPosition]:
-        return self.local.positions()
+        return self._view.positions()
 
     def blocks(self) -> Iterator[BlockState]:
-        return self.local.blocks()
+        return self._view.blocks()
+
+    def where(
+        self,
+        mask: np.ndarray[bool] | BlockState | BlockId,
+        x: BlockState | np.ndarray[BlockState],
+        y: BlockState | np.ndarray[BlockState]| None = None,
+    ) -> None:
+        self._view.where(mask, x, y)
+
+    def poswhere(
+        self,
+        mask: np.ndarray[bool] | BlockState | BlockId,
+    ) -> list[BlockPosition]:
+        """Return a list of BlockPositions at which `mask` applies."""
+        return self._view.poswhere(mask)
+
+    # masking relative to BlockState / BlockId
+    def relative_to(
+        self,
+        block: BlockState | BlockId,
+        direction: BlockPosition, # absolute direction
+    ) -> np.ndarray[bool]:
+        return self._view.relative_to(block, direction)
+
+    def above_of(self, block: BlockState | BlockId) -> np.ndarray[bool]:
+        return self._view.above_of(block)
+
+    def below_of(self, block: BlockState | BlockId) -> np.ndarray[bool]:
+        return self._view.below_of(block)
+
+    def north_of(self, block: BlockState | BlockId) -> np.ndarray[bool]:
+        return self._view.north_of(block)
+
+    def south_of(self, block: BlockState | BlockId) -> np.ndarray[bool]:
+        return self._view.south_of(block)
+
+    def west_of(self, block: BlockState | BlockId) -> np.ndarray[bool]:
+        return self._view.west_of(block)
+
+    def east_of(self, block: BlockState | BlockId) -> np.ndarray[bool]:
+        return self._view.east_of(block)
 
     # block position transformations
     def world_to_local(self, world: BlockPosition) -> BlockPosition:
@@ -198,8 +268,7 @@ class Region:
         nbt["Position"] = self._origin.to_nbt()
         nbt["Size"] = self._size.to_nbt()
 
-        pal = [block.to_nbt() for block in self._palette]
-        nbt["BlockStatePalette"] = nbtlib.List[nbtlib.Compound](pal)
+        nbt["BlockStatePalette"] = self._palette.to_nbt()
         nbt["BlockStates"] = self._encode_block_states()
 
         nbt["Entities"] = self._entities
@@ -216,10 +285,8 @@ class Region:
 
         region = cls(origin=pos, size=size)
 
-        region._palette = [
-            BlockState.from_nbt(block) for block in nbt["BlockStatePalette"]]
-        region._palette_map = {bl: i for i, bl in enumerate(region._palette)}
-        region._blocks = region._decode_block_states(nbt["BlockStates"])
+        region._index_array = region._decode_block_states(nbt["BlockStates"])
+        region._palette = BlockPalette.from_nbt(nbt["BlockStatePalette"])
 
         region._entities = nbt["Entities"]
         region._tile_entities = nbt["TileEntities"]
@@ -233,27 +300,26 @@ class _RegionView(ABC):
 
     def __init__(self, region: Region) -> None:
         self.region = region
-        # TODO: add support for (tile) entities and ticks
 
     @property
-    def _blocks(self) -> np.ndarray[int]:
-        return self.region._blocks
+    def _index_array(self) -> np.ndarray[int]:
+        return self.region._index_array
 
     @property
-    def _palette(self) -> list[BlockState]:
+    def _palette(self) -> BlockPalette:
         return self.region._palette
 
-    @property
-    def _palette_map(self) -> dict[BlockState, int]:
-        return self.region._palette_map
-
     @abstractmethod
     def position_to_index(self, pos: BlockPosition) -> tuple[int, int, int]:
-        ...
+        """Convert a BlockPosition in the view's coordinate system to the
+        corresponding 3D index in the internal storage array.
+        """
 
     @abstractmethod
     def index_to_position(self, index: tuple[int, int, int]) -> BlockPosition:
-        ...
+        """Convert a 3D index in the internal storage array to the corresponding
+        BlockPosition in the view's coordinate system.
+        """
 
     @abstractmethod
     def _align_array(self, arr: np.ndarray) -> np.ndarray:
@@ -263,17 +329,24 @@ class _RegionView(ABC):
     def _transform_index(self, index):
         ...
 
+    def _state_array(self) -> np.ndarray[BlockState]:
+        return self._palette.get_state(self._index_array)
+
+    def _block_mask(self, block: BlockState | BlockId) -> np.ndarray[bool]:
+        if not isinstance(block, (BlockState, BlockId)):
+            raise TypeError(f"'block' needs to be BlockState or BlockId")
+        matches = self._palette == block
+        return matches[self._index_array]
+
     def __getitem__(self, key):
+        # TODO: allow 'key' to be a BlockState / BlockId
         if isinstance(key, BlockPosition):
             # return self.at(key) # TODO
             key = tuple(key)
         index = self._transform_index(key)
 
-        indices = self._blocks[index]
-        if np.isscalar(indices):
-            return self._palette[indices]
-        else:
-            return np.array(self._palette, dtype=object)[indices]
+        indices = self._index_array[index]
+        return self._palette.get_state(indices)
 
     def __setitem__(self, key, value):
         if isinstance(key, BlockPosition):
@@ -286,13 +359,12 @@ class _RegionView(ABC):
 
         if isinstance(value, BlockState):
             # assign single BlockState to slice
-            if value not in self._palette_map:
-                self._palette_map[value] = len(self._palette)
-                self._palette.append(value)
-            self._blocks[index] = self._palette_map[value]
+            if value not in self._palette:
+                self._palette.add_state(value)
+            self._index_array[index] = self._palette.get_index(value)
 
         elif isinstance(value, np.ndarray):
-            if value.shape != self._blocks[index].shape:
+            if value.shape != self._index_array[index].shape:
                 # TODO: allow casting
                 raise ValueError(
                     "Shape mismatch between assigned array and target slice")
@@ -301,12 +373,11 @@ class _RegionView(ABC):
             unique_states, xdi = np.unique(value, return_inverse=True)
             idx = []
             for state in unique_states:
-                if state not in self._palette_map:
-                    self._palette_map[state] = len(self._palette)
-                    self._palette.append(state)
-                idx.append(self._palette_map[state])
+                if state not in self._palette:
+                    self._palette.add_state(state)
+                idx.append(self._palette.get_index(state))
             index_array = np.array(idx, dtype=int)[xdi].reshape(value.shape)
-            self._blocks[index] = index_array
+            self._index_array[index] = index_array
         else:
             raise TypeError(
                 "Value must be a BlockState or a list of BlockStates")
@@ -316,21 +387,39 @@ class _RegionView(ABC):
             return all(self.lower <= item) and all(item <= self.upper)
 
         elif isinstance(item, BlockState):
-            index = self._palette_map.get(item)
-            if index is None:
+            if not item in self._palette:
                 return False
-            return index in self._blocks
-            # return np.any(self._blocks == index).item()
+            return self._palette.get_index(item) in self._index_array
 
         elif isinstance(item, BlockId):
             return any(
-                # bs.id == item and np.any(self._blocks == idx)
-                bs.id == item and idx in self._blocks
-                for bs, idx in self._palette_map.items())
+                bs.id == item and idx in self._index_array
+                for bs, idx in self._palette.items())
 
         else:
             return False
 
+    def __eq__(self, other) -> np.ndarray[bool]:
+        if not isinstance(other, (BlockState, BlockId)):
+            return NotImplemented
+        mask = self._block_mask(other)
+        return self._align_array(mask)
+
+    def __ne__(self, other) -> np.ndarray[bool]:
+        if not  isinstance(other, (BlockState, BlockId)):
+            return NotImplemented
+        return np.invert(self.__eq__(other))
+
+    def __lt__(self, other) -> np.ndarray[bool]:
+        if not  isinstance(other, (BlockState, BlockId)):
+            return NotImplemented
+        return self.below_of(other)
+
+    def __gt__(self, other) -> np.ndarray[bool]:
+        if not  isinstance(other, (BlockState, BlockId)):
+            return NotImplemented
+        return self.above_of(other)
+
     def __iter__(self) -> Iterator[tuple[BlockPosition, BlockState]]:
         return self.items()
 
@@ -348,29 +437,86 @@ class _RegionView(ABC):
             yield BlockPosition(x, y, z)
 
     def blocks(self) -> Iterator[BlockState]:
-        indices = self._align_array(self._blocks).transpose(2, 1, 0).ravel()
-        palette = np.array(self._palette, dtype=object)
-        for block in palette[indices]:
+        indices = self._align_array(self._index_array).transpose(2, 1, 0)
+        for block in self._palette.get_state(indices.ravel()):
             yield block
 
-    def __eq__(self, other) -> np.ndarray[bool]:
-        palette = np.array(self._palette, dtype=object)
+    def where(
+        self,
+        mask: np.ndarray[bool] | BlockState | BlockId,
+        x: BlockState | np.ndarray[BlockState],
+        y: BlockState | np.ndarray[BlockState] | None = None,
+    ) -> None:
+        # TODO: allow 'mask' to be a BlockState / BlockId array
+        # TODO: allow 'x' and 'y' to be Region / _RegionView
 
-        if isinstance(other, BlockState):
-            matches = np.array([state == other for state in palette])
-            mask = matches[self._blocks]
+        if isinstance(mask, (BlockState | BlockId)):
+            mask = self == mask
 
-        elif isinstance(other, BlockId):
-            matches = np.array([state.id == other for state in palette])
-            mask = matches[self._blocks]
+        self[mask] = x
+        if y is not None:
+            self[np.invert(mask)] = y
 
-        else:
-            return NotImplemented
+    def poswhere(
+        self,
+        mask: np.ndarray[bool] | BlockState | BlockId,
+    ) -> list[BlockPosition]:
+        """Return a list of BlockPositions at which `mask` applies."""
+
+        if isinstance(mask, (BlockState | BlockId)):
+            mask = self == mask
+        mask = self._align_array(mask)
+        return [self.index_to_position(x) for x in np.argwhere(mask)]
 
+    def _move_mask(
+        self,
+        mask: np.ndarray[bool],
+        direction: BlockPosition,
+    ) -> np.ndarray[bool]:
+        result = np.zeros_like(mask, dtype=bool)
+
+        slices_src = [slice(None)] * self._index_array.ndim
+        slices_dst = [slice(None)] * self._index_array.ndim
+
+        for axis, dim in enumerate(direction):
+            if dim == 0:
+                continue
+            elif dim > 0:
+                slices_src[axis] = slice(0, -dim)
+                slices_dst[axis] = slice(dim, None)
+            else:
+                slices_src[axis] = slice(-dim, None)
+                slices_dst[axis] = slice(0, dim)
+
+        result[tuple(slices_dst)] = mask[tuple(slices_src)]
+        return result
+
+    def relative_to(
+        self,
+        block: BlockState | BlockId,
+        direction: BlockPosition,
+    ) -> np.ndarray[bool]:
+        mask = self._block_mask(block)
+        mask = self._move_mask(mask, direction)
         return self._align_array(mask)
 
-    def __ne__(self, other) -> np.ndarray[bool]:
-        return np.invert(self.__eq__(other))
+    def above_of(self, block: BlockState | BlockId) -> np.ndarray[bool]:
+        return self.relative_to(block, Direction.UP)
+
+    def below_of(self, block: BlockState | BlockId) -> np.ndarray[bool]:
+        return self.relative_to(block, Direction.DOWN)
+
+    def north_of(self, block: BlockState | BlockId) -> np.ndarray[bool]:
+        return self.relative_to(block, Direction.NORTH)
+
+    def south_of(self, block: BlockState | BlockId) -> np.ndarray[bool]:
+        return self.relative_to(block, Direction.SOUTH)
+
+    def west_of(self, block: BlockState | BlockId) -> np.ndarray[bool]:
+        return self.relative_to(block, Direction.WEST)
+
+    def east_of(self, block: BlockState | BlockId) -> np.ndarray[bool]:
+        return self.relative_to(block, Direction.EAST)
 
     property
     @abstractmethod
@@ -382,15 +528,15 @@ class _RegionView(ABC):
     def size(self) -> Size3D:
         ...
 
-    @cached_property
+    @property
     def limit(self) -> BlockPosition:
         return self.origin + self.size.limit
 
-    @cached_property
+    @property
     def lower(self) -> BlockPosition:
         return BlockPosition(*np.min((self.origin, self.limit), axis=0))
 
-    @cached_property
+    @property
     def upper(self) -> BlockPosition:
         return BlockPosition(*np.max((self.origin, self.limit), axis=0))
 
@@ -404,10 +550,13 @@ class NumpyRegionView(_RegionView):
     @property
     def origin(self) -> BlockPosition:
         return BlockPosition(0, 0, 0)
+        # reg_size = self.region._size
+        # return BlockPosition(*np.where(reg_size, 0, -(reg_size + 1)))
 
     @property
     def size(self) -> Size3D:
         return abs(self.region._size)
+        # return self.region._size
 
     def position_to_index(self, pos: BlockPosition) -> tuple[int, int, int]:
         return tuple(pos)
@@ -428,7 +577,7 @@ class _OrientedView(_RegionView):
     def size(self) -> Size3D:
         return self.region._size
 
-    @cached_property
+    @property
     def negative_axes(self) -> tuple[int,...]:
         return tuple(np.argwhere(self.size < 0).flatten().tolist())
 
@@ -463,7 +612,7 @@ class _OrientedView(_RegionView):
         elif isinstance(key, np.ndarray) and key.dtype == bool:
             # boolean indexing
             key = self._align_array(key)
-            if key.shape != self._blocks.shape:
+            if key.shape != self._index_array.shape:
                 raise IndexError("Boolean index must match region shape.")
             return key
 

pylitematic/resource_location.py

@@ -67,7 +67,3 @@ class ResourceLocation:
     @classmethod
     def from_nbt(cls, nbt: nbtlib.String) -> ResourceLocation:
         return cls.from_string(str(nbt))
-
-
-class BlockId(ResourceLocation):
-    ...

pylitematic/schematic.py

@@ -9,7 +9,8 @@ import twos
 from typing import Iterator
 
 from pylitematic.geometry import BlockPosition, Size3D
-from pylitematic.region import Region
+from pylitematic.region import AIR, Region
+from pylitematic.block_state import AIR
 
 
 DEFAULT_VERSION_MAJOR: int = 7
@@ -75,8 +76,6 @@ class Schematic:
         self.version_minor = version_minor
         self.mc_version = mc_version
 
-        self.modified: bool = True
-
     def __getitem__(self, key):
         return self._regions[key]
 
@@ -123,7 +122,8 @@ class Schematic:
 
     @property
     def blocks(self) -> int:
-        return sum(reg.block_count for reg in self._regions.values())
+        return sum(
+            reg.volume - reg.count(AIR) for reg in self._regions.values())
 
     @property
     def region_count(self) -> int:
@@ -158,7 +158,11 @@ class Schematic:
     def modified_at(self) -> datetime:
         return datetime.fromtimestamp(int(self._modified_at / 1000))
 
+    def clear(self) -> None:
+        self._regions = {}
+
     def save(self, path: pathlib.Path | str) -> None:
+        self._modified_at = int(time.time() * 1000)
         file = nbtlib.File(self.to_nbt())
         file.save(path, gzipped=True, byteorder="big")
 
@@ -170,6 +174,10 @@ class Schematic:
         return cls.from_nbt(nbt)
 
     def to_nbt(self) -> nbtlib.Compound:
+        if not self.region_count:
+            raise ValueError(
+                f"Schematic {self.name!r} needs at least one region")
+
         nbt = nbtlib.Compound()
 
         # meta data
@@ -193,7 +201,7 @@ class Schematic:
         # regions
         regions = nbtlib.Compound()
         for name, region in self.regions():
-            region.compact_palette()
+            region.reduce_palette()
             regions[name] = region.to_nbt()
         nbt["Regions"] = regions
 

pylitematic/test.py

@@ -1,72 +1,79 @@
-import numpy as np
-import pathlib
-from pylitematic import BlockPosition, BlockId, BlockState, Region, Schematic, Size3D
+from pylitematic import (
+    BlockPosition,
+    BlockId,
+    BlockState,
+    Region,
+    Schematic,
+    Size3D,
+)
 
-# path = pathlib.Path("/mnt/d/minecraft/schematics/Litematica/test/subs.litematic")
-# path = pathlib.Path("/mnt/d/minecraft/schematics/Litematica/test/regions.litematic")
-# path = pathlib.Path("/mnt/d/minecraft/schematics/Litematica/test/creeper_test.litematic")
-# stone = BlockState.from_string("minecraft:stone")
-# dirt = BlockState.from_string("minecraft:dirt")
-# s = Schematic.load(path)
-# print(f"{s.volume=} {s.size=} {s.bounds=}")
-# for name, reg in s.regions():
-#     print(name)
-#     print(f"\t{reg.shape=} {reg.volume=} {reg.block_count=}")
-#     print(f"\t{reg.origin=!s} {reg.limit=!s}")
-#     print(f"\t{reg.start=!s} {reg.end=!s}")
-#     print(f"\t{reg.lower=!s} {reg.upper=!s} {reg.size=}")
-#     # print(f"\t{reg[..., 1, 0]}")
-#     # print(f"\t{reg[:][1][0]}")
-#     # print(f"\t{reg[BlockPosition(0, 1, 0)]}")
-#     # reg[1,1,1] = BlockState.from_string("minecraft:stone")
-#     # print("lol: ", reg[reg.end])
-#     # reg[0,:,0] = BlockState("minecraft:obsidian")
-#     # reg[0,:,0] = [dirt, stone, dirt]
-#     # print(reg[...,0])
-#     # print(reg[np.array([BlockPosition(0, 0, 0), BlockPosition(1, 1, 1)])])
-#     # print(f"\t{reg[:]}")
-#     # for pos, state in reg.blocks(exclude_air=True):
-#     #     print(pos, state)
-#     # for pos, state in reg.blocks((BlockState("oak_log", axis="x"), BlockState("spruce_log", axis="z")), ignore_props=True):
-#     # reg[...,-1] = stone
-#     for pos, state in reg.blocks(exclude=BlockState("air")):
-#         print(f"\t{pos} {reg._to_internal(pos)}: {state}")
-#     for pos, state in reg.blocks(include=BlockState("lime_wool")):
-#         reg[pos] = BlockState("minecraft:blue_wool")
-#     for pos, state in reg.blocks(include=BlockState("tripwire"), ignore_props=True):
-#         reg[pos] = BlockState("minecraft:glass")
-#     # print(BlockState("oak_log", axis="x") in reg)
-#     # print(BlockPosition(1, 1, 0) in reg)
-#     # print(ResourceLocation("birch_log") in reg)
-#     # print(reg[0,:,2])
-# s.save("/mnt/d/minecraft/schematics/Litematica/test/aaa.litematic")
 
 air = BlockState("air")
 stone = BlockState("stone")
 dirt = BlockState("dirt")
 grass = BlockState("grass_block")
+water = BlockState("water")
+lava = BlockState("lava")
+sand = BlockState("sand")
+
 cobble = BlockState("cobblestone")
 mossy_cobble = BlockState("mossy_cobblestone")
+
 snow = BlockState("snow_block")
+ice = BlockState("ice")
 pumpkin = BlockState("carved_pumpkin", facing="west")
+jack = BlockState("jack_o_lantern", facing="west")
 
-ground = Region(size=Size3D(16, 9, 16), origin=BlockPosition(0, 0, 0))
-ground.local[:,:5,:] = stone
-ground.local[:,5:8,:] = dirt
-ground.local[:,8:,:] = grass
+ground = Region(size=Size3D(16, 9, 16))
+ground.local[:,:5,:] = stone # 4 stone layers
+ground.local[:,5:8,:] = dirt # 3 dirt layers
+ground[(ground > dirt) & (ground == BlockId("air"))] = grass # grass above exposed dirt
+ground.numpy[2:5,-1,2:5] = water # small pond
+ground[ground.relative_to(water, BlockPosition(4, 0, 0))] = lava # lava pool
 
 boulder = Region(size=(4, 4, 4), origin=ground.origin+[6, ground.height, 6])
-boulder[:] = mossy_cobble
-boulder.numpy[:,-2:,:] = cobble
+boulder[:] = mossy_cobble # fill with mossy cobblestone
+boulder.numpy[:,-2:,:] = cobble # upper two layers of cobblestone
+
+snow_man = Region(
+    size=(1, -3, 1), origin=boulder.origin+[2, boulder.upper.y+3, 1])
+snow_man.set_default_view(snow_man.numpy)
+snow_man[...] = snow # fill with snow
+snow_man[0,-1,0] = pumpkin # pumpkin on top
+
+snow_woman = snow_man.copy(origin=snow_man.origin+[-1, 0, 1])
+# snow_woman[snow_woman == snow] = ice # replace snow with ice
+snow_woman.where(snow, ice, jack) # replace snow with ice and rest with lanterns
 
-# snow_man = Region(size=(1, 3, 1), origin=boulder.origin+[1, boulder.height, 1])
-snow_man = Region(size=(1, -3, 1), origin=boulder.origin+[1, boulder.upper.y+3, 1])
-snow_man[...] = snow
-# snow_man.numpy[:,:2,:] = [[[snow], [snow]]]
-snow_man[0,snow_man.upper.y,0] = pumpkin
+clones = []
+start = BlockPosition(1, ground.upper.y, ground.upper.z-1)
+for i in range(5):
+    clones.append(
+        snow_man.copy(origin=start+(i * 3, 3, -i)))
 
-schem = Schematic(name="a_scene", author="Boscawinks", description="A simple scene")
+cuboid = Region(origin=(14, ground.upper.y+3, 4), size=(-2,-3,-4))
+cuboid[:,-2:0,:] = sand
+cuboid.where((cuboid < air) & (cuboid == sand), stone)
+for pos, block in cuboid.numpy.items():
+    print(f"{pos}:\t{block}")
+
+schem = Schematic(
+    name="a_scene", author="Boscawinks", description="A simple scene")
 schem.add_region("ground", ground)
 schem.add_region("boulder", boulder)
 schem.add_region("snow_man", snow_man)
-schem.save(f"/mnt/d/minecraft/schematics/Litematica/test/{schem.name}.litematic")
+schem.add_region("snow_woman", snow_woman)
+for i, clone in enumerate(clones):
+    schem.add_region(f"clone_{i+1}", clone)
+schem.add_region("cuboid", cuboid)
+schem.save(
+    f"/mnt/d/minecraft/schematics/Litematica/test/{schem.name}.litematic")
+
+# print(boulder[...,-1])
+
+# from pathlib import Path
+# path = Path("/mnt/d/minecraft/schematics/Litematica/turtle/turtle_8x8.litematic")
+# turtle = Schematic.load(path)
+# for name, reg in turtle.regions():
+#     reg[reg != BlockState("air")] = BlockState("blue_wool")
+# turtle.save(path.with_suffix(".blue.litematic"))

{pylitematic-0.0.4.dist-info → pylitematic-0.0.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pylitematic
-Version: 0.0.4
+Version: 0.0.5
 Summary: Load, modify, and save Litematica schematics
 Author-email: Boscawinks <bosca.winks@gmx.de>
 License: GPL-3.0-only

pylitematic-0.0.5.dist-info/RECORD

@@ -0,0 +1,14 @@
+pylitematic/__init__.py,sha256=KlmeOfpqQ64bSbOTEj2IcLwARfwzg3kTbUtBpRAgpU0,188
+pylitematic/block_palette.py,sha256=9k1rzLgmoUK2jkuKo4v0nuE37wVFvDF3jja59NqYY_Y,4280
+pylitematic/block_property.py,sha256=HGxDSngEr-tcwuZPGn6ohHQQ65OL4MaTP9ytDAvuSCw,7714
+pylitematic/block_state.py,sha256=4CQ5V6dbXuGY3vRp2wXJCqPIV9xIHZbuzJ7JgY7oLA4,4064
+pylitematic/geometry.py,sha256=gPsvjnp6tSpQ1uA9hbsKO4EdjdMuxV2wm6KwxFaedSQ,4211
+pylitematic/property_cache.py,sha256=BFY-fh6xDBpJTZ2QBndeJKYVAObVwMLA4TYfXiiCBcA,1358
+pylitematic/region.py,sha256=_08u-lbR3MxBQIngRZq-72lS9X73ynUR1Vpu0J_jtN4,20468
+pylitematic/resource_location.py,sha256=VgTPayrTc0xJNM6smG9vseajFGVccL2wwtLKUyG9qYo,2125
+pylitematic/schematic.py,sha256=Nm7gV6e0ayYSJK8lhcjnm5_c5KGC-MSRTzpTbqfvKcA,8367
+pylitematic/test.py,sha256=9OQzQONGjs6TqyinwdSk6o9yysXe2EKSiOeHM45hGIM,2663
+pylitematic-0.0.5.dist-info/METADATA,sha256=dOGSClod9zp_e8LFQiNHDKM8lzZNE7QIxNZCXyoaT6I,1159
+pylitematic-0.0.5.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+pylitematic-0.0.5.dist-info/top_level.txt,sha256=sYUxm6O7Dh5TzuP-kPFe2FHJWUuwHFO69vN2VBiEG4A,12
+pylitematic-0.0.5.dist-info/RECORD,,

pylitematic-0.0.4.dist-info/RECORD

@@ -1,12 +0,0 @@
-pylitematic/__init__.py,sha256=Cu9tl3jcE6c1VPcMFkrNq5ddWhGZFd7OT_lhItHBdsI,213
-pylitematic/block_property.py,sha256=HGxDSngEr-tcwuZPGn6ohHQQ65OL4MaTP9ytDAvuSCw,7714
-pylitematic/block_state.py,sha256=PuwE3b7zf8Gw-wV3DOXYYwfvLrUJmkj0H_XC7yGMKdw,3540
-pylitematic/geometry.py,sha256=x_rjJ0gO7uhUJqEg9es8nzD-p3rCiSM9vpdwF7JukAM,4194
-pylitematic/region.py,sha256=iMX95qkd-OAWP8GUyi-_DBYgtphy8djgLb5lRR_Ssu8,15150
-pylitematic/resource_location.py,sha256=bqw3Oh9Bx-oWZdm-Qj_FoqpNOh3gc6DPvKqCm6DIDSo,2168
-pylitematic/schematic.py,sha256=nKH5EjU2ZvuJzjyO84kmKrcKI0jqmNfzq1UXNIroKYQ,8090
-pylitematic/test.py,sha256=weexc1mKqC7f2Uayd3KuXLsXBOvMCmLGqZrekyeVEiI,3284
-pylitematic-0.0.4.dist-info/METADATA,sha256=pKIVzFpc22EELK8IyPmlM2UB5999l_SGozXuZucRRDQ,1159
-pylitematic-0.0.4.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-pylitematic-0.0.4.dist-info/top_level.txt,sha256=sYUxm6O7Dh5TzuP-kPFe2FHJWUuwHFO69vN2VBiEG4A,12
-pylitematic-0.0.4.dist-info/RECORD,,