pylitematic 0.0.1__tar.gz → 0.0.2__tar.gz

{pylitematic-0.0.1 → pylitematic-0.0.2}/PKG-INFO

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

{pylitematic-0.0.1 → pylitematic-0.0.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "pylitematic"
-version = "0.0.1"
+version = "0.0.2"
 description = "Load, modify, and save Litematica schematics"
 authors = [
     { name="Boscawinks", email="bosca.winks@gmx.de" }

{pylitematic-0.0.1 → pylitematic-0.0.2}/src/pylitematic/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "0.0.1"
+__version__ = "0.0.2"
 
 from .block_state import BlockState
 from .geometry import BlockPosition, Size3D

{pylitematic-0.0.1 → pylitematic-0.0.2}/src/pylitematic/geometry.py

@@ -19,11 +19,14 @@ class Vec3i:
     def __str__(self) -> str:
         return str(list(self))
 
+    def __len__(self) -> int:
+        return 3
+
     def __add__(self, other) -> Vec3i:
         arr = np.array(self)
-        other_arr = self._to_array(other)
+        other = self._to_array(other)
         try:
-            result = arr + other_arr
+            result = arr + other
         except Exception:
             return NotImplemented
         return type(self)(*result.astype(int))
@@ -33,9 +36,9 @@ class Vec3i:
 
     def __sub__(self, other) -> Vec3i:
         arr = np.array(self)
-        other_arr = self._to_array(other)
+        other = self._to_array(other)
         try:
-            result = arr - other_arr
+            result = arr - other
         except Exception:
             return NotImplemented
         return type(self)(*result.astype(int))
@@ -48,13 +51,34 @@ class Vec3i:
             return NotImplemented
         return type(self)(*result.astype(int))
 
-    def __mul__(self, scalar: int) -> Vec3i:
-        return type(self)(
-            self._a * scalar, self._b * scalar, self._c * scalar)
+    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))
+
+    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))
 
-    def __floordiv__(self, scalar: int) -> Vec3i:
-        return type(self)(
-            self._a // scalar, self._b // scalar, self._c // scalar)
+    def __rfloordiv__(self, other) -> Vec3i:
+        arr = np.array(self)
+        try:
+            result = other // arr
+        except Exception:
+            return NotImplemented
+        return type(self)(*result.astype(int))
 
     def __neg__(self) -> Vec3i:
         return type(self)(-self._a, -self._b, -self._c)

{pylitematic-0.0.1 → pylitematic-0.0.2}/src/pylitematic/region.py

@@ -1,12 +1,15 @@
 from __future__ import annotations
 
 from bitpacking import bitpack, bitunpack
+from functools import cached_property
 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 ResourceLocation
 
 
 AIR = BlockState("air")
@@ -22,27 +25,77 @@ class Region:
         self._size: Size3D = Size3D(*size)
 
         self._palette: list[BlockState] = [AIR]
-        self._palette_map: dict[BlockState, int] = {AIR: 0} # FIXME
-        self._blocks = np.zeros(abs(self._size))
+        self._palette_map: dict[BlockState, int] = {AIR: 0}
+        self._blocks = np.zeros(abs(self._size), dtype=int)
+
         self._entities: list[nbtlib.Compound] = []
         self._tile_entities: list[nbtlib.Compound] = []
         self._block_ticks: list[nbtlib.Compound] = []
         self._fluid_ticks: list[nbtlib.Compound] = []
 
-    def __getitem__(self, key):
+    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, ResourceLocation):
+            return any(
+                (bs.id == item and np.any(self._blocks == idx))
+                for bs, idx in self._palette_map.items())
+        else:
+            return False
+
+    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 _key_to_index(self, key):
         if isinstance(key, BlockPosition):
-            index = self._blocks[key.x, key.y, key.z]
-            return self._palette[index]
+            index = tuple(key)
+        else:
+            index = self._expand_index(key)
+        return self._to_internal(index)
 
-        indices = self._blocks[key]
+    def __getitem__(self, key):
+        index = self._key_to_index(key)
+        indices = self._blocks[index]
         if np.isscalar(indices):
             return self._palette[indices]
 
         return np.array(self._palette, dtype=object)[indices]
 
     def __setitem__(self, key, value) -> None:
-        if isinstance(key, BlockPosition):
-            key = key.to_tuple()
+        index = self._key_to_index(key)
 
         if isinstance(value, list):
             value = np.array(value, dtype=object)
@@ -52,11 +105,10 @@ class Region:
             if value not in self._palette_map:
                 self._palette_map[value] = len(self._palette)
                 self._palette.append(value)
-            index = self._palette_map[value]
-            self._blocks[key] = index
+            self._blocks[index] = self._palette_map[value]
 
         elif isinstance(value, np.ndarray):
-            if value.shape != self._blocks[key].shape:
+            if value.shape != self._blocks[index].shape:
                 raise ValueError(
                     "Shape mismatch between assigned array and target slice")
 
@@ -69,7 +121,7 @@ class Region:
                     self._palette.append(state)
                 idx.append(self._palette_map[state])
             index_array = np.array(idx, dtype=int)[xdi].reshape(value.shape)
-            self._blocks[key] = index_array
+            self._blocks[index] = index_array
         else:
             raise TypeError(
                 "Value must be a BlockState or a list of BlockStates")
@@ -119,18 +171,37 @@ class Region:
         )
         return nbtlib.LongArray([twos.to_signed(x, 64) for x in chunks])
 
+    @staticmethod
+    def inclusive_end(
+        size: Size3D,
+        pos: BlockPosition = BlockPosition(0, 0, 0),
+    ) -> BlockPosition:
+        return pos + (size - np.sign(size))
+        # return pos + np.where(size > 0, size - 1, size + 1)
+
     @property
     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
 
-    @property
+    @cached_property
+    def limit(self) -> BlockPosition:
+        return self.inclusive_end(pos=self._origin, size=self._size)
+
+    @cached_property
+    def start(self) -> BlockPosition:
+        return BlockPosition(0, 0, 0)
+
+    @cached_property
     def end(self) -> BlockPosition:
-        return self._origin + np.where(
-            self._size > 0, self._size - 1, self._size + 1)
+        return self.inclusive_end(pos=self.start, size=self._size)
 
     @property
     def width(self) -> int:
@@ -149,33 +220,76 @@ class Region:
         return np.prod(self.shape).item()
 
     @property
-    def blocks(self) -> int: # TODO: rename
+    def block_count(self) -> int:
+        # TODO: Add filter BlockState and rename to count()
         return np.count_nonzero(self._blocks)
 
     @property
     def shape(self) -> tuple[int, int, int]:
         return self._blocks.shape
 
-    @property
+    @cached_property
     def lower(self) -> BlockPosition:
-        return BlockPosition(*np.min((self.origin, self.end), axis=0))
+        return BlockPosition(*np.min((self.start, self.end), axis=0))
 
-    @property
+    @cached_property
     def upper(self) -> BlockPosition:
-        return BlockPosition(*np.max((self.origin, self.end), axis=0))
+        return BlockPosition(*np.max((self.start, self.end), axis=0))
 
-    @property
+    @cached_property
     def bounds(self) -> tuple[BlockPosition, BlockPosition]:
         return self.lower, self.upper
 
-    # def count(self, block: BlockState, ignore_props: bool = False) -> int:
-    #     ...
+    @cached_property
+    def global_lower(self) -> BlockPosition:
+        return BlockPosition(*np.min((self.origin, self.limit), axis=0))
 
-    def global_position(self, pos: BlockPosition) -> BlockPosition:
-        return self._origin + pos
+    @cached_property
+    def global_upper(self) -> BlockPosition:
+        return BlockPosition(*np.max((self.origin, self.limit), axis=0))
 
-    def local_position(self, pos: BlockPosition) -> BlockPosition:
-        return pos - self._origin
+    @cached_property
+    def global_bounds(self) -> tuple[BlockPosition, BlockPosition]:
+        return self.global_lower, self.global_upper
+
+    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
+
+            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
+
+            yield pos, state
+
+    def to_global(self, local_pos: BlockPosition) -> BlockPosition:
+        return self._origin + local_pos
+
+    def to_local(self, global_pos: BlockPosition) -> BlockPosition:
+        return global_pos - self._origin
 
     def to_nbt(self) -> nbtlib.Compound:
         nbt = nbtlib.Compound()

{pylitematic-0.0.1 → pylitematic-0.0.2}/src/pylitematic/schematic.py

@@ -107,7 +107,7 @@ class Schematic:
         lowers = []
         uppers = []
         for reg in self._regions.values():
-            lower, upper = reg.bounds
+            lower, upper = reg.global_bounds
             lowers.append(lower)
             uppers.append(upper)
         return (
@@ -121,7 +121,7 @@ class Schematic:
 
     @property
     def blocks(self) -> int:
-        return sum(reg.blocks for reg in self._regions.values())
+        return sum(reg.block_count for reg in self._regions.values())
 
     @property
     def region_count(self) -> int:

pylitematic-0.0.2/src/pylitematic/test.py

@@ -0,0 +1,39 @@
+import numpy as np
+import pathlib
+from pylitematic import BlockPosition, BlockState, ResourceLocation, Schematic
+
+path = pathlib.Path("/mnt/d/minecraft/schematics/Litematica/test/subs.litematic")
+path = pathlib.Path("/mnt/d/minecraft/schematics/Litematica/test/creeper_test.litematic")
+path = pathlib.Path("/mnt/d/minecraft/schematics/Litematica/test/regions.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):
+    for pos, state in reg.blocks(exclude=BlockState("air")):
+        print(pos, reg._to_internal(pos), state)
+    for pos, state in reg.blocks(include=BlockState("air")):
+        reg[pos] = BlockState("minecraft:netherrack")
+    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")

{pylitematic-0.0.1 → pylitematic-0.0.2}/src/pylitematic.egg-info/PKG-INFO

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

pylitematic-0.0.1/src/pylitematic/test.py

@@ -1,23 +0,0 @@
-import pathlib
-from pylitematic import BlockPosition, BlockState, Schematic
-
-
-path = pathlib.Path("/mnt/d/minecraft/schematics/Litematica/test/subs.litematic")
-path = pathlib.Path("/mnt/d/minecraft/schematics/Litematica/test/creeper_test.litematic")
-path = pathlib.Path("/mnt/d/minecraft/schematics/Litematica/test/regions.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.blocks=}")
-    print(f"\t{reg.origin=!s} {reg.end=!s}")
-    print(f"\t{reg.lower=} {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")
-    reg[0,:,0] = [dirt, stone, dirt]
-    print(f"\t{reg[:]}")
-s.save("/mnt/d/minecraft/schematics/Litematica/test/pylitematic.litematic")