pylitematic 0.0.2__tar.gz → 0.0.3__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pylitematic
-Version: 0.0.2
+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.2 → pylitematic-0.0.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "pylitematic"
-version = "0.0.2"
+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.2 → pylitematic-0.0.3}/src/pylitematic/__init__.py

@@ -1,7 +1,7 @@
-__version__ = "0.0.2"
+__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.2 → 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.2 → 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.2 → pylitematic-0.0.3}/src/pylitematic/geometry.py

@@ -191,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.2 → pylitematic-0.0.3}/src/pylitematic/region.py

@@ -9,7 +9,7 @@ from typing import Iterator
 
 from .block_state import BlockState
 from .geometry import BlockPosition, Size3D
-from .resource_location import ResourceLocation
+from .resource_location import BlockId
 
 
 AIR = BlockState("air")
@@ -28,10 +28,11 @@ class Region:
         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] = []
+        # 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):
@@ -41,50 +42,26 @@ class Region:
             if index is None:
                 return False
             return np.any(self._blocks == index)
-        elif isinstance(item, ResourceLocation):
+        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 _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 __eq__(self, other) -> bool:
+        palette = np.array(self._palette, dtype=object)
 
-    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)
+        if isinstance(other, BlockState):
+            matches = np.array([state == other for state in palette])
+            return matches[self._blocks]
 
-    def _from_internal(self, index: tuple[int, int, int]) -> BlockPosition:
-        return self.lower + index
+        elif isinstance(other, BlockId):
+            matches = np.array([state.id == other for state in palette])
+            return matches[self._blocks]
 
-    def _key_to_index(self, key):
-        if isinstance(key, BlockPosition):
-            index = tuple(key)
         else:
-            index = self._expand_index(key)
-        return self._to_internal(index)
+            return NotImplemented
 
     def __getitem__(self, key):
         index = self._key_to_index(key)
@@ -126,6 +103,44 @@ class Region:
             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
@@ -171,14 +186,6 @@ 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
@@ -193,7 +200,7 @@ class Region:
 
     @cached_property
     def limit(self) -> BlockPosition:
-        return self.inclusive_end(pos=self._origin, size=self._size)
+        return self._origin + self._size.end()
 
     @cached_property
     def start(self) -> BlockPosition:
@@ -201,7 +208,7 @@ class Region:
 
     @cached_property
     def end(self) -> BlockPosition:
-        return self.inclusive_end(pos=self.start, size=self._size)
+        return self._size.end()
 
     @property
     def width(self) -> int:

{pylitematic-0.0.2 → 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.2 → 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
@@ -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.2 → pylitematic-0.0.3}/src/pylitematic.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pylitematic
-Version: 0.0.2
+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.2 → 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.2 → 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.2 → 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.2/src/pylitematic/test.py

@@ -1,39 +0,0 @@
-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")