pylitematic 0.0.1__tar.gz → 0.0.3__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pylitematic
-Version: 0.0.1
+Version: 0.0.3
 Summary: Load, modify, and save Litematica schematics
 Author-email: Boscawinks <bosca.winks@gmx.de>
 License: GPL-3.0-only
@@ -13,6 +13,9 @@ Description-Content-Type: text/markdown
 Requires-Dist: bitpacking>=0.1.0
 Requires-Dist: nbtlib>=2.0.4
 Requires-Dist: numpy>=2.2.6
+Requires-Dist: twos>=0.0.1
+Provides-Extra: dev
+Requires-Dist: pytest; extra == "dev"
 
 # pylitematic
 

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

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "pylitematic"
-version = "0.0.1"
+version = "0.0.3"
 description = "Load, modify, and save Litematica schematics"
 authors = [
     { name="Boscawinks", email="bosca.winks@gmx.de" }
@@ -12,7 +12,8 @@ authors = [
 dependencies = [
     "bitpacking >=0.1.0",
     "nbtlib >=2.0.4",
-    "numpy >=2.2.6"
+    "numpy >=2.2.6",
+    "twos >= 0.0.1"
 ]
 readme = "README.md"
 requires-python = ">=3.10.12"
@@ -21,6 +22,11 @@ classifiers = [
     "Programming Language :: Python :: 3",
 ]
 
+[project.optional-dependencies]
+dev = [
+    "pytest"
+]
+
 [project.urls]
 Homepage = "https://github.com/boscawinks/pylitematic"
 Repository = "https://github.com/boscawinks/pylitematic"

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

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

{pylitematic-0.0.1 → pylitematic-0.0.3}/src/pylitematic/block_property.py

@@ -14,72 +14,6 @@ ENUM_VALUE_REGEX: str = r"[a-z]+(_[a-z]+)*" # snake case
 ENUM_VALUE_PATTERN: re.Pattern = re.compile(ENUM_VALUE_REGEX)
 
 
-class Property():
-
-    __slots__ = ("_name", "_value")
-
-    def __init__(self, name: str, value: Any | PropertyValue) -> None:
-        if not PROPERTY_NAME_PATTERN.fullmatch(name):
-            raise ValueError(f"Invalid property name {name!r}")
-        self._name = name
-
-        if not isinstance(value, PropertyValue):
-            value = PropertyValue.value_factory(value=value)
-        self._value = value
-
-    def __str__(self) -> str:
-        return f"{self._name}={self._value}"
-
-    def __repr__(self) -> str:
-        return (
-            f"{type(self).__name__}("
-            f"name: {self._name}, value: {self._value!r})")
-
-    def __eq__(self, other: Any) -> bool:
-        if not isinstance(other, Property):
-            return NotImplemented
-        return (self.name, self.value) == (other.name, other.value)
-
-    def __lt__(self, other: Any) -> bool:
-        if not isinstance(other, Property):
-            return NotImplemented
-        return (self.name, self.value) < (other.name, other.value)
-
-    @property
-    def name(self) -> str:
-        return self._name
-
-    @property
-    def value(self) -> Any:
-        return self._value.get()
-
-    @value.setter
-    def value(self, value: Any) -> None:
-        self._value.set(value)
-
-    def to_string(self) -> str:
-        return str(self)
-
-    @staticmethod
-    def from_string(string: str, value: str | None = None) -> Property:
-        if value is None:
-            # tread string as "name=value"
-            try:
-                string, value = string.split("=")
-            except ValueError as exc:
-                raise ValueError(f"Invalid property string {string!r}") from exc
-        return Property(name=string, value=PropertyValue.from_string(value))
-
-    def to_nbt(self) -> tuple[str, nbtlib.String]:
-        # return nbtlib.Compound(Name=nbtlib.String(self._name), Value=self._value.to_nbt()})
-        return self._name, self._value.to_nbt()
-
-    @staticmethod
-    def from_nbt(name: str, nbt: nbtlib.String) -> Property:
-        # return Property.from_string(name=nbt["Name"], value=str(nbt["Value"]))
-        return Property.from_string(string=name, value=str(nbt))
-
-
 class Properties(dict):
 
     def __init__(self, *args, **kwargs):

{pylitematic-0.0.1 → pylitematic-0.0.3}/src/pylitematic/block_state.py

@@ -4,7 +4,7 @@ from copy import deepcopy
 from nbtlib import Compound
 from typing import Any, Iterator
 
-from .resource_location import ResourceLocation
+from .resource_location import BlockId
 from .block_property import Properties
 
 
@@ -12,8 +12,15 @@ class BlockState:
 
     __slots__ = ("_id", "_props")
 
-    def __init__(self, _id: str, **props: Any) -> None:
-        self._id: ResourceLocation = ResourceLocation.from_string(_id)
+    def __init__(self, _id: str | BlockId, **props: Any) -> None:
+        if isinstance(_id, str):
+            _id = BlockId.from_string(_id)
+        elif not isinstance(_id, BlockId):
+            raise TypeError(
+                f"'_id' has to be str or {BlockId.__name__}, got"
+                f" {type(_id).__name__}")
+        self._id: BlockId = _id
+
         self._props: Properties = Properties(**props)
 
     def __getitem__(self, name: str) -> Any:
@@ -58,8 +65,8 @@ class BlockState:
             f"id: {self._id!r}, props: {self._props!r})")
 
     @property
-    def id(self) -> str:
-        return str(self._id)
+    def id(self) -> BlockId:
+        return self._id
 
     def props(self) -> Iterator[tuple[str, Any]]:
         return self._props.items()

{pylitematic-0.0.1 → pylitematic-0.0.3}/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)
@@ -167,3 +191,17 @@ class Size3D(Vec3i):
         return (
             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)
+
+        if not isinstance(axis, tuple):
+            axis = (axis, )
+
+        ret = np.zeros_like(limit, dtype=int)
+        for ax in axis:
+            ret[ax] = limit[ax]
+        return BlockPosition(*ret)

{pylitematic-0.0.1 → pylitematic-0.0.3}/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 BlockId
 
 
 AIR = BlockState("air")
@@ -22,27 +25,54 @@ 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._entities: list[nbtlib.Compound] = []
-        self._tile_entities: list[nbtlib.Compound] = []
-        self._block_ticks: list[nbtlib.Compound] = []
-        self._fluid_ticks: list[nbtlib.Compound] = []
+        self._palette_map: dict[BlockState, int] = {AIR: 0}
+        self._blocks = np.zeros(abs(self._size), dtype=int)
+
+        # TODO: Add support
+        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 __getitem__(self, key):
-        if isinstance(key, BlockPosition):
-            index = self._blocks[key.x, key.y, key.z]
-            return self._palette[index]
+    def __eq__(self, other) -> bool:
+        palette = np.array(self._palette, dtype=object)
 
-        indices = self._blocks[key]
+        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]
 
         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 +82,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,11 +98,49 @@ 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")
 
+    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 = tuple(key)
+        else:
+            index = self._expand_index(key)
+        return self._to_internal(index)
+
     def compact_palette(self) -> None:
         idx = np.unique(self._blocks)
         # always include minecraft:air in a palette
@@ -123,14 +190,25 @@ 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
 
-    @property
+    @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._origin + np.where(
-            self._size > 0, self._size - 1, self._size + 1)
+        return self._size.end()
 
     @property
     def width(self) -> int:
@@ -149,33 +227,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.3}/src/pylitematic/resource_location.py

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

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

@@ -8,8 +8,8 @@ import time
 import twos
 from typing import Iterator
 
-from .geometry import BlockPosition, Size3D
-from .region import Region
+from pylitematic.geometry import BlockPosition, Size3D
+from pylitematic.region import Region
 
 
 DEFAULT_VERSION_MAJOR: int = 7
@@ -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:
@@ -142,7 +142,6 @@ class Schematic:
 
     def add_region(self, name: str, region: Region) -> None:
         self._regions[name] = region
-        self._update()
 
     def remove_region(self, name: str) -> Region:
         return self._regions.pop(name)
@@ -214,7 +213,10 @@ class Schematic:
 
         name = meta["Name"].unpack()
         author = meta["Author"].unpack()
-        description = meta["Description"].unpack()
+        try:
+            desc = meta["Description"].unpack()
+        except KeyError:
+            desc = ""
 
         preview = meta.get("PreviewImageData")
         if preview is not None:
@@ -248,7 +250,7 @@ class Schematic:
         schem = Schematic(
             name=name,
             author=author,
-            description=description,
+            description=desc,
             regions=regions,
             preview=preview,
             version_major=major,

pylitematic-0.0.3/src/pylitematic/test.py

@@ -0,0 +1,71 @@
+import numpy as np
+import pathlib
+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")
+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
+
+boulder = Region(size=(4, 4, 4), origin=ground.origin+[6, ground.height, 6])
+boulder[:] = 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[0,snow_man.upper.y,0] = pumpkin
+
+schem = Schematic(name="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.1 → pylitematic-0.0.3}/src/pylitematic.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pylitematic
-Version: 0.0.1
+Version: 0.0.3
 Summary: Load, modify, and save Litematica schematics
 Author-email: Boscawinks <bosca.winks@gmx.de>
 License: GPL-3.0-only
@@ -13,6 +13,9 @@ Description-Content-Type: text/markdown
 Requires-Dist: bitpacking>=0.1.0
 Requires-Dist: nbtlib>=2.0.4
 Requires-Dist: numpy>=2.2.6
+Requires-Dist: twos>=0.0.1
+Provides-Extra: dev
+Requires-Dist: pytest; extra == "dev"
 
 # pylitematic
 

{pylitematic-0.0.1 → pylitematic-0.0.3}/src/pylitematic.egg-info/SOURCES.txt

@@ -14,4 +14,5 @@ src/pylitematic.egg-info/dependency_links.txt
 src/pylitematic.egg-info/requires.txt
 src/pylitematic.egg-info/top_level.txt
 tests/test_block_property.py
-tests/test_resource_location.py
+tests/test_resource_location.py
+tests/test_schematic.py

{pylitematic-0.0.1 → pylitematic-0.0.3}/src/pylitematic.egg-info/requires.txt

@@ -1,3 +1,7 @@
 bitpacking>=0.1.0
 nbtlib>=2.0.4
 numpy>=2.2.6
+twos>=0.0.1
+
+[dev]
+pytest

{pylitematic-0.0.1 → pylitematic-0.0.3}/tests/test_block_property.py

@@ -6,7 +6,6 @@ from pylitematic.block_property import (
     BooleanValue,
     EnumValue,
     IntegerValue,
-    Property,
     PropertyValue,
 )
 
@@ -50,44 +49,3 @@ def test_value():
 
     with pytest.raises(TypeError):
         PropertyValue.value_factory(value=3.14)
-
-
-def test_property():
-    # TODO
-    # * test sorting of properties
-
-    def check_prop(
-        prop: Property,
-        name: str,
-        target: Any,
-        string: str,
-        nbt: tuple[str, String],
-    ) -> None:
-        assert prop.name == name
-        assert prop.value == target
-        prop.value = target
-        assert str(prop) == string
-        assert prop.to_string() == string
-        assert prop.to_nbt() == nbt
-
-    proto_props = [
-        ("enabled", True, "true", String("true"), "enabled=true"),
-        ("facing", "north", "north", String("north"), "facing=north"),
-        ("age", 42, "42", String("42"), "age=42"),
-    ]
-
-    for name, target, string, nbt, prop_string in proto_props:
-        prop = Property(name=name, value=target)
-        check_prop(prop, name, target, prop_string, (name, nbt))
-        prop = Property.from_string(string=name, value=string)
-        check_prop(prop, name, target, prop_string, (name, nbt))
-        prop = Property.from_string(string=prop_string)
-        check_prop(prop, name, target, prop_string, (name, nbt))
-        prop = Property.from_nbt(name=name, nbt=nbt)
-        check_prop(prop, name, target, prop_string, (name, nbt))
-
-    with pytest.raises(TypeError):
-        Property(name="float", value=3.14)
-
-    with pytest.raises(ValueError):
-        Property(name="Uppercase", value=1)

pylitematic-0.0.3/tests/test_schematic.py

@@ -0,0 +1,40 @@
+from pylitematic import BlockPosition, BlockState, Region, Schematic, Size3D
+
+
+def test_schematic(tmp_path):
+    air = BlockState("air")
+    stone = BlockState("stone")
+    dirt = BlockState("dirt")
+    grass = BlockState("grass_block")
+    cobble = BlockState("mossy_cobblestone")
+    snow = BlockState("snow_block")
+    pumpkin = BlockState("carved_pumpkin", facing="west")
+
+    ground = Region(size=Size3D(16, 9, 16))
+    ground[:,:5,:] = stone
+    ground[:,5:8,:] = dirt
+    ground[:,8:,:] = grass
+
+    boulder = Region(
+        size=(4, 4, 4), origin=ground.origin+[6, ground.height, 6])
+    for pos, block in boulder.blocks():
+        if block == air:
+            boulder[pos] = cobble
+    # ^ since region is empty, this is equivalent to boulder[:] = cobble
+
+    snow_man = Region(
+        size=(1, 3, 1), origin=boulder.origin+[1, boulder.height, 1])
+    snow_man[:] = snow
+    snow_man[BlockPosition(0, 2, 0)] = pumpkin
+
+    schem = Schematic(
+        name="scene", author="Boscawinks", description="A simple scene")
+    schem.add_region("ground", ground)
+    schem.add_region("boulder", boulder)
+    schem.add_region("snow_man", snow_man)
+
+    save_path = tmp_path / f"{schem.name}.litematic"
+    schem.save(save_path)
+
+    copy = schem.load(save_path)
+    assert copy.to_nbt() == schem.to_nbt()

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")