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

pylitematic/__init__.py

@@ -1,7 +1,6 @@
-__version__ = "0.0.3"
+__version__ = "0.0.5"
 
-from .block_state import BlockState
-from .geometry import BlockPosition, Size3D
+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_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

@@ -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):
@@ -74,15 +93,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 +112,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:
@@ -117,3 +136,6 @@ class BlockState:
 
     def without_props(self) -> BlockState:
         return BlockState(self.id)
+
+
+AIR = BlockState("air")

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 type(self)(*(np.array(self) - 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/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()