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

pylitematic/__init__.py

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

pylitematic/block_property.py

@@ -94,10 +94,10 @@ class Properties(dict):
     def to_string(self) -> str:
         return str(self)
 
-    @staticmethod
-    def from_string(string: str) -> Properties:
+    @classmethod
+    def from_string(cls, string: str) -> Properties:
         if string in ("", "[]"):
-            return Properties()
+            return cls()
 
         if not (string.startswith("[") and string.endswith("]")):
             raise ValueError(f"Invalid properties string {string!r}")
@@ -113,18 +113,18 @@ class Properties(dict):
                 ValueError(f"Duplicate property name {name!r}")
             props[name] = PropertyValue.from_string(string=val_str).get()
 
-        return Properties(props)
+        return cls(props)
 
     def to_nbt(self) -> nbtlib.Compound:
         return nbtlib.Compound(
             {name: value.to_nbt() for name, value in sorted(super().items())})
 
-    @staticmethod
-    def from_nbt(nbt: nbtlib.Compound) -> Properties:
+    @classmethod
+    def from_nbt(cls, nbt: nbtlib.Compound) -> Properties:
         props = {}
         for name, value in nbt.items():
             props[name] = PropertyValue.from_nbt(nbt=value).get()
-        return Properties(props)
+        return cls(props)
 
 
 class PropertyValue(ABC):
@@ -204,20 +204,20 @@ class PropertyValue(ABC):
     def to_string(self) -> str:
         return str(self)
 
-    @staticmethod
-    def from_string(string: str) -> PropertyValue:
+    @classmethod
+    def from_string(cls, string: str) -> PropertyValue:
         try:
             value = json.loads(string)
         except json.JSONDecodeError:
             value = string
-        return PropertyValue.value_factory(value)
+        return cls.value_factory(value)
 
     def to_nbt(self) -> nbtlib.String:
         return nbtlib.String(self)
 
-    @staticmethod
-    def from_nbt(nbt: nbtlib.String) -> PropertyValue:
-        return PropertyValue.from_string(str(nbt))
+    @classmethod
+    def from_nbt(cls, nbt: nbtlib.String) -> PropertyValue:
+        return cls.from_string(str(nbt))
 
 
 class BooleanValue(PropertyValue):

pylitematic/block_state.py

@@ -74,15 +74,15 @@ class BlockState:
     def to_string(self) -> str:
         return str(self)
 
-    @staticmethod
-    def from_string(string: str) -> BlockState:
+    @classmethod
+    def from_string(cls, string: str) -> BlockState:
         idx = string.find("[") # basic parsing to separate block:id[name=value]
         if idx == -1:
             id, props = string, ""
         else:
             id, props = string[:idx], string[idx:]
 
-        state = BlockState(id)
+        state = cls(id)
         state._props = Properties.from_string(props)
         return state
 
@@ -93,19 +93,19 @@ class BlockState:
             nbt["Properties"] = self._props.to_nbt()
         return nbt
 
-    @staticmethod
-    def from_nbt(nbt: Compound) -> BlockState:
-        state = BlockState(str(nbt["Name"]))
+    @classmethod
+    def from_nbt(cls, nbt: Compound) -> BlockState:
+        state = cls(str(nbt["Name"]))
         state._props = Properties.from_nbt(nbt.get("Properties", Compound()))
         return state
 
     def with_id(self, id: str) -> BlockState:
-        state = BlockState(id)
+        state = type(self)(id)
         state._props = deepcopy(self._props)
         return state
 
     def with_props(self, **props: Any) -> BlockState:
-        state = BlockState(self.id)
+        state = type(self)(self.id)
         new_props = deepcopy(self._props)
         for name, value in props.items():
             if value is None:

pylitematic/geometry.py

@@ -1,8 +1,10 @@
 from __future__ import annotations
 
 from dataclasses import dataclass
+import enum
 import nbtlib
 import numpy as np
+from typing import Iterator
 
 
 @dataclass(frozen=True)
@@ -12,134 +14,89 @@ class Vec3i:
     _c: int
 
     def __post_init__(self) -> None:
-        object.__setattr__(self, "_a", self._to_int(self._a))
-        object.__setattr__(self, "_b", self._to_int(self._b))
-        object.__setattr__(self, "_c", self._to_int(self._c))
+        object.__setattr__(self, "_a", int(self._a))
+        object.__setattr__(self, "_b", int(self._b))
+        object.__setattr__(self, "_c", int(self._c))
+
+    def __getitem__(self, index: int) -> int:
+        return tuple(self)[index]
 
     def __str__(self) -> str:
         return str(list(self))
 
+    def __repr__(self) -> str:
+        return (
+            f"{type(self).__name__}(a={self._a}, b={self._b}, c={self._c})")
+
     def __len__(self) -> int:
         return 3
 
+    def __iter__(self) -> Iterator[int]:
+        return iter((self._a, self._b, self._c))
+
+    def __neg__(self) -> Vec3i:
+        return type(self)(*(-i for i in self))
+
+    def __abs__(self) -> Vec3i:
+        return type(self)(*(abs(i) for i in self))
+
+    def __array__(self, dtype: type | None = None, copy: bool = True):
+        arr = np.array(tuple(self), dtype=dtype)
+        return arr.copy() if copy else arr
+
     def __add__(self, other) -> Vec3i:
-        arr = np.array(self)
-        other = self._to_array(other)
-        try:
-            result = arr + other
-        except Exception:
-            return NotImplemented
-        return type(self)(*result.astype(int))
+        return type(self)(*(np.array(self) + other))
 
     def __radd__(self, other) -> Vec3i:
         return self.__add__(other)
 
     def __sub__(self, other) -> Vec3i:
-        arr = np.array(self)
-        other = self._to_array(other)
-        try:
-            result = arr - other
-        except Exception:
-            return NotImplemented
-        return type(self)(*result.astype(int))
+        return self.__add__(-other)
 
     def __rsub__(self, other) -> Vec3i:
-        arr = np.array(self)
-        try:
-            result = other - arr
-        except Exception:
-            return NotImplemented
-        return type(self)(*result.astype(int))
+        return -self.__sub__(other)
 
     def __mul__(self, other) -> Vec3i:
-        arr = np.array(self)
-        other = self._to_array(other)
-        try:
-            result = arr * other
-        except Exception:
-            return NotImplemented
-        return type(self)(*result.astype(int))
+        return type(self)(*(np.array(self) * other))
 
     def __rmul__(self, other) -> Vec3i:
         return self.__mul__(other)
 
     def __floordiv__(self, other) -> Vec3i:
-        arr = np.array(self)
-        other = self._to_array(other)
-        try:
-            result = arr // other
-        except Exception:
-            return NotImplemented
-        return type(self)(*result.astype(int))
+        return type(self)(*(np.array(self) // other))
 
     def __rfloordiv__(self, other) -> Vec3i:
-        arr = np.array(self)
-        try:
-            result = other // arr
-        except Exception:
-            return NotImplemented
-        return type(self)(*result.astype(int))
+        return type(self)(*(other // np.array(self)))
 
-    def __neg__(self) -> Vec3i:
-        return type(self)(-self._a, -self._b, -self._c)
+    def __truediv__(self, other) -> Vec3i:
+        return self.__floordiv__(other)
 
-    def __getitem__(self, index: int) -> int:
-        return self.to_tuple()[index]
+    def __rtruediv__(self, other) -> Vec3i:
+        return self.__rfloordiv__(other)
 
-    def __iter__(self):
-        return iter(self.to_tuple())
+    def __mod__(self, other) -> Vec3i:
+        return type(self)(*(np.array(self) % other))
 
-    def __abs__(self) -> Vec3i:
-        return type(self)(*np.abs(self))
+    def __rmod__(self, other) -> Vec3i:
+        return type(self)(*(other % np.array(self)))
+
+    def __eq__(self, other):
+        return np.array(self) == other
+
+    def __ne__(self, other):
+        return np.invert(self.__eq__(other))
 
     def __lt__(self, other):
-        return np.array(self) < self._to_array(other)
+        return np.array(self) < other
 
     def __le__(self, other):
-        return np.array(self) <= self._to_array(other)
+        return np.array(self) <= other
 
     def __gt__(self, other):
-        return np.array(self) > self._to_array(other)
+        return np.array(self) > other
 
     def __ge__(self, other):
-        return np.array(self) >= self._to_array(other)
-
-    def __eq__(self, other):
-        return np.array(self) == self._to_array(other)
-
-    def __ne__(self, other):
-        return np.array(self) != self._to_array(other)
-
-    def __array__(self, dtype: type | None = None, copy: bool = True):
-        arr = np.array([self._a, self._b, self._c], dtype=dtype)
-        if copy:
-            return arr.copy()
-        else:
-            return arr
-
-    def _to_array(self, other):
-        if isinstance(other, Vec3i):
-            return np.array(other)
-        else:
-            return other
-
-    @staticmethod
-    def _to_int(value) -> int:
-        if isinstance(value, (int, np.integer)):
-            return int(value)
-        elif isinstance(value, float):
-            if value.is_integer():
-                return int(value)
-        raise TypeError(
-            f"{type(value).__name__} value {value!r} is not"
-            " int, numpy integer, or whole float")
-
-    def to_tuple(self) -> tuple[int, int, int]:
-        return (self._a, self._b, self._c)
-
-    @classmethod
-    def from_tuple(cls, t: tuple[int, int, int]) -> Vec3i:
-        return cls(*t)
+        return np.array(self) >= other
 
     def to_nbt(self) -> nbtlib.Compound:
         return nbtlib.Compound({
@@ -172,6 +129,15 @@ class BlockPosition(Vec3i):
         return f"{type(self).__name__}(x={self.x}, y={self.y}, z={self.z})"
 
 
+class Direction(BlockPosition, enum.Enum):
+    NORTH = 0,  0, -1
+    SOUTH = 0,  0,  1
+    WEST = -1,  0,  0
+    EAST =  1,  0,  0
+    UP =    0,  1,  0
+    DOWN =  0, -1,  0
+
+
 @dataclass(frozen=True)
 class Size3D(Vec3i):
 
@@ -192,16 +158,14 @@ class Size3D(Vec3i):
             f"{type(self).__name__}("
             f"width={self.width}, height={self.height}, length={self.length})")
 
-    def end(self, axis: tuple[int,...] | int | None = None) -> BlockPosition:
-        limit = self - np.sign(self)
-
-        if axis is None:
-            return BlockPosition(*limit)
+    @property
+    def volume(self) -> int:
+        return abs(self.width * self.height * self.length)
 
-        if not isinstance(axis, tuple):
-            axis = (axis, )
+    @property
+    def limit(self) -> BlockPosition:
+        return BlockPosition(*(self - self.sign))
 
-        ret = np.zeros_like(limit, dtype=int)
-        for ax in axis:
-            ret[ax] = limit[ax]
-        return BlockPosition(*ret)
+    @property
+    def sign(self) -> BlockPosition:
+        return BlockPosition(*np.sign(self))

pylitematic/region.py

@@ -1,7 +1,9 @@
 from __future__ import annotations
 
+from abc import ABC, abstractmethod
 from bitpacking import bitpack, bitunpack
 from functools import cached_property
+from itertools import product
 import nbtlib
 import numpy as np
 import twos
@@ -21,130 +23,63 @@ class Region:
         size: tuple[int, int, int] | Size3D,
         origin: tuple[int, int, int] | BlockPosition = (0, 0, 0),
     ):
-        self._origin: BlockPosition = BlockPosition(*origin)
-        self._size: Size3D = Size3D(*size)
+        if not isinstance(size, Size3D):
+            size = Size3D(*size)
+        self._size: Size3D = size
 
-        self._palette: list[BlockState] = [AIR]
-        self._palette_map: dict[BlockState, int] = {AIR: 0}
+        if not isinstance(origin, BlockPosition):
+            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)
 
-        # TODO: Add support
+        # TODO: Add support for (tile) entities and ticks
         self._entities = nbtlib.List[nbtlib.Compound]()
         self._tile_entities = nbtlib.List[nbtlib.Compound]()
         self._block_ticks = nbtlib.List[nbtlib.Compound]()
         self._fluid_ticks = nbtlib.List[nbtlib.Compound]()
 
-    def __contains__(self, item) -> bool:
-        if isinstance(item, BlockPosition):
-            return all(self.lower <= item) and all(item <= self.upper)
-        elif isinstance(item, BlockState):
-            index = self._palette_map.get(item)
-            if index is None:
-                return False
-            return np.any(self._blocks == index)
-        elif isinstance(item, BlockId):
-            return any(
-                (bs.id == item and np.any(self._blocks == idx))
-                for bs, idx in self._palette_map.items())
-        else:
-            return False
-
-    def __eq__(self, other) -> bool:
-        palette = np.array(self._palette, dtype=object)
+        self._local = LocalRegionView(self)
+        self._world = WorldRegionView(self)
+        self._numpy = NumpyRegionView(self)
 
-        if isinstance(other, BlockState):
-            matches = np.array([state == other for state in palette])
-            return matches[self._blocks]
-
-        elif isinstance(other, BlockId):
-            matches = np.array([state.id == other for state in palette])
-            return matches[self._blocks]
-
-        else:
-            return NotImplemented
-
-    def __getitem__(self, key):
-        index = self._key_to_index(key)
-        indices = self._blocks[index]
-        if np.isscalar(indices):
-            return self._palette[indices]
+    @property
+    def local(self) -> LocalRegionView:
+        return self._local
 
-        return np.array(self._palette, dtype=object)[indices]
+    @property
+    def world(self) -> WorldRegionView:
+        return self._world
 
-    def __setitem__(self, key, value) -> None:
-        index = self._key_to_index(key)
+    @property
+    def numpy(self) -> NumpyRegionView:
+        return self._numpy
 
-        if isinstance(value, list):
-            value = np.array(value, dtype=object)
+    def __contains__(self, item) -> bool:
+        return item in self.local
 
-        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]
+    def __eq__(self, other) -> bool:
+        return self.local == other
 
-        elif isinstance(value, np.ndarray):
-            if value.shape != self._blocks[index].shape:
-                raise ValueError(
-                    "Shape mismatch between assigned array and target slice")
+    def __ne__(self, other) -> bool:
+        return self.local != other
 
-            # look up (or add) indices for all BlockStates
-            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])
-            index_array = np.array(idx, dtype=int)[xdi].reshape(value.shape)
-            self._blocks[index] = index_array
-        else:
-            raise TypeError(
-                "Value must be a BlockState or a list of BlockStates")
+    def __getitem__(self, key):
+        return self.local[key]
 
-    def _expand_index(self, index):
-        if not isinstance(index, tuple):
-            index = (index,)
-        ndim = self._blocks.ndim
-        result = []
-        for item in index:
-            if item is Ellipsis:
-                result.extend([slice(None)] * (ndim - len(index) + 1))
-            else:
-                result.append(item)
-        while len(result) < ndim:
-            result.append(slice(None))
-        return tuple(result)
-
-    def _to_internal(self, pos):
-        index = []
-        for i, item in enumerate(pos):
-            offset = self.lower[i]
-            if isinstance(item, int):
-                index.append(item - offset)
-            elif isinstance(item, slice):
-                start = item.start - offset if item.start is not None else None
-                stop = item.stop - offset if item.stop is not None else None
-                index.append(slice(start, stop, item.step))
-            else:
-                index.append(item)
-        return tuple(index)
-
-    def _from_internal(self, index: tuple[int, int, int]) -> BlockPosition:
-        return self.lower + index
+    def __setitem__(self, key, value) -> None:
+        self.local[key] = value
 
-    def _key_to_index(self, key):
-        if isinstance(key, BlockPosition):
-            index = tuple(key)
-        else:
-            index = self._expand_index(key)
-        return self._to_internal(index)
+    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)
-        # always include minecraft:air in a palette
         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)}
 
@@ -160,6 +95,7 @@ class Region:
         self._palette = palette
         self._palette_map = palette_map
 
+    # block state en- / decoding (NBT)
     def _bits_per_state(self) -> int:
         return max(2, (len(self._palette) - 1).bit_length())
 
@@ -190,114 +126,72 @@ class Region:
     def size(self) -> Size3D:
         return self._size
 
-    @cached_property
-    def sign(self) -> Size3D:
-        return Size3D(*np.sign(self._size))
-
-    @property
-    def origin(self) -> BlockPosition:
-        return self._origin
-
-    @cached_property
-    def limit(self) -> BlockPosition:
-        return self._origin + self._size.end()
-
-    @cached_property
-    def start(self) -> BlockPosition:
-        return BlockPosition(0, 0, 0)
-
-    @cached_property
-    def end(self) -> BlockPosition:
-        return self._size.end()
-
     @property
     def width(self) -> int:
-        return self._size.width
+        return self.size.width
 
     @property
     def height(self) -> int:
-        return self._size.height
+        return self.size.height
 
     @property
     def length(self) -> int:
-        return self._size.length
+        return self.size.length
 
     @property
     def volume(self) -> int:
-        return np.prod(self.shape).item()
+        return self.size.volume
 
     @property
-    def block_count(self) -> int:
-        # TODO: Add filter BlockState and rename to count()
-        return np.count_nonzero(self._blocks)
+    def origin(self) -> BlockPosition:
+        return self._origin
 
     @property
-    def shape(self) -> tuple[int, int, int]:
-        return self._blocks.shape
+    def block_count(self) -> int:
+        # TODO: Add filter BlockStates / BlockIds and rename to count()
+        return np.sum(self != AIR).item()
 
-    @cached_property
+    @property
     def lower(self) -> BlockPosition:
-        return BlockPosition(*np.min((self.start, self.end), axis=0))
+        return self.local.lower
 
-    @cached_property
+    @property
     def upper(self) -> BlockPosition:
-        return BlockPosition(*np.max((self.start, self.end), axis=0))
+        return self.local.upper
 
-    @cached_property
+    @property
     def bounds(self) -> tuple[BlockPosition, BlockPosition]:
-        return self.lower, self.upper
+        return self.local.bounds
 
-    @cached_property
-    def global_lower(self) -> BlockPosition:
-        return BlockPosition(*np.min((self.origin, self.limit), axis=0))
+    def items(self) -> Iterator[tuple[BlockPosition, BlockState]]:
+        return self.local.items()
 
-    @cached_property
-    def global_upper(self) -> BlockPosition:
-        return BlockPosition(*np.max((self.origin, self.limit), axis=0))
+    def positions(self) -> Iterator[BlockPosition]:
+        return self.local.positions()
 
-    @cached_property
-    def global_bounds(self) -> tuple[BlockPosition, BlockPosition]:
-        return self.global_lower, self.global_upper
+    def blocks(self) -> Iterator[BlockState]:
+        return self.local.blocks()
 
-    def blocks(
-        self,
-        include: BlockState | list[BlockState] | None = None,
-        exclude: BlockState | list[BlockState] | None = None,
-        ignore_props: bool = False,
-    ) -> Iterator[tuple[BlockPosition, BlockState]]:
-        if isinstance(include, BlockState):
-            include = [include]
-        if isinstance(exclude, BlockState):
-            exclude = [exclude]
-
-        for z, y, x in np.ndindex(self.shape[::-1]):
-            pos = BlockPosition(x, y, z) * self.sign
-            state = self[pos]
-
-            if exclude:
-                if not ignore_props:
-                    if state in exclude:
-                        continue
-                else:
-                    if any(state.id == ex.id for ex in exclude):
-                        continue
+    # block position transformations
+    def world_to_local(self, world: BlockPosition) -> BlockPosition:
+        return world - self._origin
 
-            if include:
-                if not ignore_props:
-                    if state not in include:
-                        continue
-                else:
-                    if not any(state.id == s.id for s in include):
-                        continue
+    def local_to_world(self, local: BlockPosition) -> BlockPosition:
+        return self._origin + local
 
-            yield pos, state
+    def local_to_numpy(self, local: BlockPosition) -> BlockPosition:
+        return BlockPosition(*self.local.position_to_index(local))
 
-    def to_global(self, local_pos: BlockPosition) -> BlockPosition:
-        return self._origin + local_pos
+    def numpy_to_local(self, index: BlockPosition) -> BlockPosition:
+        return self.local.index_to_position(tuple(index))
 
-    def to_local(self, global_pos: BlockPosition) -> BlockPosition:
-        return global_pos - self._origin
+    def world_to_numpy(self, world: BlockPosition) -> BlockPosition:
+        return BlockPosition(*self.world.position_to_index(world))
 
+    def numpy_to_world(self, index: BlockPosition) -> BlockPosition:
+        return self.world.index_to_position(tuple(index))
+
+    # NBT conversion
     def to_nbt(self) -> nbtlib.Compound:
         nbt = nbtlib.Compound()
 
@@ -315,12 +209,12 @@ class Region:
 
         return nbt
 
-    @staticmethod
-    def from_nbt(nbt: nbtlib.Compound) -> Region:
+    @classmethod
+    def from_nbt(cls, nbt: nbtlib.Compound) -> Region:
         pos = BlockPosition.from_nbt(nbt["Position"])
         size = Size3D.from_nbt(nbt["Size"])
 
-        region = Region(origin=pos, size=size)
+        region = cls(origin=pos, size=size)
 
         region._palette = [
             BlockState.from_nbt(block) for block in nbt["BlockStatePalette"]]
@@ -333,3 +227,259 @@ class Region:
         region._fluid_ticks = nbt["PendingFluidTicks"]
 
         return region
+
+
+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
+
+    @property
+    def _palette(self) -> list[BlockState]:
+        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]:
+        ...
+
+    @abstractmethod
+    def index_to_position(self, index: tuple[int, int, int]) -> BlockPosition:
+        ...
+
+    @abstractmethod
+    def _align_array(self, arr: np.ndarray) -> np.ndarray:
+        ...
+
+    @abstractmethod
+    def _transform_index(self, index):
+        ...
+
+    def __getitem__(self, key):
+        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]
+
+    def __setitem__(self, key, value):
+        if isinstance(key, BlockPosition):
+            # return self.set_at(key, value) # TODO
+            key = tuple(key)
+        index = self._transform_index(key)
+
+        if isinstance(value, list):
+            value = np.array(value, dtype=object)
+
+        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]
+
+        elif isinstance(value, np.ndarray):
+            if value.shape != self._blocks[index].shape:
+                # TODO: allow casting
+                raise ValueError(
+                    "Shape mismatch between assigned array and target slice")
+
+            # look up (or add) indices for all BlockStates
+            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])
+            index_array = np.array(idx, dtype=int)[xdi].reshape(value.shape)
+            self._blocks[index] = index_array
+        else:
+            raise TypeError(
+                "Value must be a BlockState or a list of BlockStates")
+
+    def __contains__(self, item) -> bool:
+        if isinstance(item, BlockPosition):
+            return all(self.lower <= item) and all(item <= self.upper)
+
+        elif isinstance(item, BlockState):
+            index = self._palette_map.get(item)
+            if index is None:
+                return False
+            return index in self._blocks
+            # return np.any(self._blocks == index).item()
+
+        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())
+
+        else:
+            return False
+
+    def __iter__(self) -> Iterator[tuple[BlockPosition, BlockState]]:
+        return self.items()
+
+    def items(self) -> Iterator[tuple[BlockPosition, BlockState]]:
+        for pos, block in zip(self.positions(), self.blocks()):
+            yield pos, block
+
+    def positions(self) -> Iterator[BlockPosition]:
+        ranges = [
+            range(start, stop, step)
+            for start, stop, step
+            in zip(self.origin, self.origin + self.size, self.size.sign)
+        ]
+        for z, y, x in product(*reversed(ranges)):
+            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]:
+            yield block
+
+    def __eq__(self, other) -> np.ndarray[bool]:
+        palette = np.array(self._palette, dtype=object)
+
+        if isinstance(other, BlockState):
+            matches = np.array([state == other for state in palette])
+            mask = matches[self._blocks]
+
+        elif isinstance(other, BlockId):
+            matches = np.array([state.id == other for state in palette])
+            mask = matches[self._blocks]
+
+        else:
+            return NotImplemented
+
+        return self._align_array(mask)
+
+    def __ne__(self, other) -> np.ndarray[bool]:
+        return np.invert(self.__eq__(other))
+
+    property
+    @abstractmethod
+    def origin(self) -> BlockPosition:
+        ...
+
+    @property
+    @abstractmethod
+    def size(self) -> Size3D:
+        ...
+
+    @cached_property
+    def limit(self) -> BlockPosition:
+        return self.origin + self.size.limit
+
+    @cached_property
+    def lower(self) -> BlockPosition:
+        return BlockPosition(*np.min((self.origin, self.limit), axis=0))
+
+    @cached_property
+    def upper(self) -> BlockPosition:
+        return BlockPosition(*np.max((self.origin, self.limit), axis=0))
+
+    @property
+    def bounds(self) -> tuple[BlockPosition, BlockPosition]:
+        return self.lower, self.upper
+
+
+class NumpyRegionView(_RegionView):
+
+    @property
+    def origin(self) -> BlockPosition:
+        return BlockPosition(0, 0, 0)
+
+    @property
+    def size(self) -> Size3D:
+        return abs(self.region._size)
+
+    def position_to_index(self, pos: BlockPosition) -> tuple[int, int, int]:
+        return tuple(pos)
+
+    def index_to_position(self, index: tuple[int, int, int]) -> BlockPosition:
+        return BlockPosition(*index)
+
+    def _align_array(self, arr: np.ndarray) -> np.ndarray:
+        return arr
+
+    def _transform_index(self, index):
+        return index
+
+
+class _OrientedView(_RegionView):
+
+    @property
+    def size(self) -> Size3D:
+        return self.region._size
+
+    @cached_property
+    def negative_axes(self) -> tuple[int,...]:
+        return tuple(np.argwhere(self.size < 0).flatten().tolist())
+
+    def position_to_index(self, pos: BlockPosition) -> tuple[int, int, int]:
+        return pos - self.lower
+
+    def index_to_position(self, index: tuple[int, int, int]) -> BlockPosition:
+        return self.lower + index
+
+    def _align_array(self, arr: np.ndarray) -> np.ndarray:
+        return np.flip(arr, axis=self.negative_axes)
+
+    def _transform_index(self, key):
+        if isinstance(key, (int, np.integer, slice, type(Ellipsis))):
+            key = (key,)
+
+        if isinstance(key, tuple):
+            key = list(key)
+            for i, k in enumerate(key):
+                offset = self.lower[i]
+                if isinstance(k, (int, np.integer)):
+                    key[i] = k - offset
+                elif isinstance(k, slice):
+                    start = k.start - offset if k.start is not None else None
+                    stop = k.stop - offset if k.stop is not None else None
+                    key[i] = slice(start, stop, k.step)
+                else:
+                    # Ellipsis
+                    key[i] = k
+            return tuple(key)
+
+        elif isinstance(key, np.ndarray) and key.dtype == bool:
+            # boolean indexing
+            key = self._align_array(key)
+            if key.shape != self._blocks.shape:
+                raise IndexError("Boolean index must match region shape.")
+            return key
+
+        else:
+            return key
+
+
+class LocalRegionView(_OrientedView):
+
+    @property
+    def origin(self) -> BlockPosition:
+        return BlockPosition(0, 0, 0)
+
+
+class WorldRegionView(_OrientedView):
+
+    @property
+    def origin(self) -> BlockPosition:
+        return self.region._origin

pylitematic/resource_location.py

@@ -50,8 +50,8 @@ class ResourceLocation:
     def to_string(self) -> str:
         return str(self)
 
-    @staticmethod
-    def from_string(string: str) -> ResourceLocation:
+    @classmethod
+    def from_string(cls, string: str) -> ResourceLocation:
         match = LOCATION_PATTERN.fullmatch(string)
         if not match:
             raise ValueError(f"Invalid resource location string {string!r}")
@@ -59,14 +59,14 @@ class ResourceLocation:
         namespace = match.group("namespace")
         path = match.group("path")
 
-        return ResourceLocation(path=path, namespace=namespace)
+        return cls(path=path, namespace=namespace)
 
     def to_nbt(self) -> nbtlib.String:
         return nbtlib.String(self)
 
-    @staticmethod
-    def from_nbt(nbt: nbtlib.String) -> ResourceLocation:
-        return ResourceLocation.from_string(str(nbt))
+    @classmethod
+    def from_nbt(cls, nbt: nbtlib.String) -> ResourceLocation:
+        return cls.from_string(str(nbt))
 
 
 class BlockId(ResourceLocation):

pylitematic/schematic.py

@@ -70,6 +70,7 @@ class Schematic:
         self._created_at = round(time.time() * 1000)
         self._modified_at = self._created_at
 
+        # TODO: use packaging.version.Version
         self.version_major = version_major
         self.version_minor = version_minor
         self.mc_version = mc_version
@@ -104,10 +105,11 @@ class Schematic:
 
     @property
     def bounds(self) -> tuple[BlockPosition, BlockPosition]:
+        # TODO: make cached and update on region add / remove
         lowers = []
         uppers = []
         for reg in self._regions.values():
-            lower, upper = reg.global_bounds
+            lower, upper = reg.world.bounds
             lowers.append(lower)
             uppers.append(upper)
         return (
@@ -142,9 +144,11 @@ class Schematic:
 
     def add_region(self, name: str, region: Region) -> None:
         self._regions[name] = region
+        # TODO: re-calculate bounding box
 
     def remove_region(self, name: str) -> Region:
         return self._regions.pop(name)
+        # TODO: re-calculate bounding box
 
     @property
     def created_at(self) -> datetime:
@@ -158,15 +162,14 @@ class Schematic:
         file = nbtlib.File(self.to_nbt())
         file.save(path, gzipped=True, byteorder="big")
 
-    @staticmethod
-    def load(path: pathlib.Path | str) -> Schematic:
+    @classmethod
+    def load(cls, path: pathlib.Path | str) -> Schematic:
         if isinstance(path, str):
             path = pathlib.Path(path)
         nbt = nbtlib.File.load(path.expanduser(), True)
-        return Schematic.from_nbt(nbt)
+        return cls.from_nbt(nbt)
 
     def to_nbt(self) -> nbtlib.Compound:
-        # self._update()
         nbt = nbtlib.Compound()
 
         # meta data
@@ -202,8 +205,8 @@ class Schematic:
 
         return nbt
 
-    @staticmethod
-    def from_nbt(nbt: nbtlib.Compound) -> Schematic:
+    @classmethod
+    def from_nbt(cls, nbt: nbtlib.Compound) -> Schematic:
         # meta data
         try:
             meta = nbt["Metadata"]
@@ -247,7 +250,7 @@ class Schematic:
 
         mc_version = nbt.get("MinecraftDataVersion")
 
-        schem = Schematic(
+        schem = cls(
             name=name,
             author=author,
             description=desc,

pylitematic/test.py

@@ -45,27 +45,28 @@ air = BlockState("air")
 stone = BlockState("stone")
 dirt = BlockState("dirt")
 grass = BlockState("grass_block")
-cobble = BlockState("mossy_cobblestone")
+cobble = BlockState("cobblestone")
+mossy_cobble = BlockState("mossy_cobblestone")
 snow = BlockState("snow_block")
 pumpkin = BlockState("carved_pumpkin", facing="west")
 
 ground = Region(size=Size3D(16, 9, 16), origin=BlockPosition(0, 0, 0))
-ground[:,:5,:] = stone
-ground[:,5:8,:] = dirt
-ground[:,8:,:] = grass
+ground.local[:,:5,:] = stone
+ground.local[:,5:8,:] = dirt
+ground.local[:,8:,:] = grass
 
 boulder = Region(size=(4, 4, 4), origin=ground.origin+[6, ground.height, 6])
-boulder[:] = cobble
+boulder[:] = mossy_cobble
+boulder.numpy[:,-2:,:] = cobble
 
 # 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.height+2, 1])
-snow_man[:] = snow
+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
 
-schem = Schematic(name="scene", author="Boscawinks", description="A simple scene")
+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")
-
-print(snow_man == snow)

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

@@ -1,13 +1,16 @@
 Metadata-Version: 2.4
 Name: pylitematic
-Version: 0.0.3
+Version: 0.0.4
 Summary: Load, modify, and save Litematica schematics
 Author-email: Boscawinks <bosca.winks@gmx.de>
 License: GPL-3.0-only
 Project-URL: Homepage, https://github.com/boscawinks/pylitematic
 Project-URL: Repository, https://github.com/boscawinks/pylitematic
 Project-URL: Issues, https://github.com/boscawinks/pylitematic/issues
+Classifier: Development Status :: 2 - Pre-Alpha
 Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Utilities
 Requires-Python: >=3.10.12
 Description-Content-Type: text/markdown
 Requires-Dist: bitpacking>=0.1.0

pylitematic-0.0.4.dist-info/RECORD

@@ -0,0 +1,12 @@
+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,,

pylitematic-0.0.3.dist-info/RECORD

@@ -1,12 +0,0 @@
-pylitematic/__init__.py,sha256=-yLTtTzD7kRpeKMbUTYNy67zkFkxUP8V1DnPXhS3ZFY,202
-pylitematic/block_property.py,sha256=4wwsQrxyNGDcrktpd4tD0Vzv-a1OxWYMj0H05GDiT-I,7739
-pylitematic/block_state.py,sha256=tMRoY6jPtt2M85DR9U9dnQh2Ukp6pP_65xXzMIFeUEo,3546
-pylitematic/geometry.py,sha256=kt2buIJovAymAtaGQYmmWj7ypOt1xI8s--LHkbTPUlM,5399
-pylitematic/region.py,sha256=0bUcK9oVyhNDzfxTjZmVLwMddrIdxvJX-cXkWL8BRSE,11097
-pylitematic/resource_location.py,sha256=gHVE1RTRHtc8DWSlXa0WUom68tRlJy8LU5dOzuONV98,2186
-pylitematic/schematic.py,sha256=SLz4NQNBJkLXV9Oj0fVOE-daP4MRsdYAnnl1vKzJv_Q,7928
-pylitematic/test.py,sha256=9uch5L58o9QVJI50jUcbuulEswYzDgtYnRiIP991jFo,3162
-pylitematic-0.0.3.dist-info/METADATA,sha256=ES-4UDWi6DQU6fCSNrgf5FLMDX_jh1g7k6kx9fmiX70,1033
-pylitematic-0.0.3.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-pylitematic-0.0.3.dist-info/top_level.txt,sha256=sYUxm6O7Dh5TzuP-kPFe2FHJWUuwHFO69vN2VBiEG4A,12
-pylitematic-0.0.3.dist-info/RECORD,,