pylitematic 0.0.2__tar.gz → 0.0.4__tar.gz

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

@@ -1,18 +1,24 @@
 Metadata-Version: 2.4
 Name: pylitematic
-Version: 0.0.2
+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
 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.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "pylitematic"
-version = "0.0.2"
+version = "0.0.4"
 description = "Load, modify, and save Litematica schematics"
 authors = [
     { name="Boscawinks", email="bosca.winks@gmx.de" }
@@ -12,13 +12,22 @@ 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"
 license = { text = "GPL-3.0-only" }
 classifiers = [
+    "Development Status :: 2 - Pre-Alpha",
     "Programming Language :: Python :: 3",
+    "Operating System :: OS Independent",
+    "Topic :: Utilities"
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest"
 ]
 
 [project.urls]

pylitematic-0.0.4/src/pylitematic/__init__.py

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

{pylitematic-0.0.2 → pylitematic-0.0.4}/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):
@@ -160,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}")
@@ -179,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):
@@ -270,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-0.0.2 → pylitematic-0.0.4}/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()
@@ -67,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
 
@@ -86,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-0.0.4/src/pylitematic/geometry.py

@@ -0,0 +1,171 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+import enum
+import nbtlib
+import numpy as np
+from typing import Iterator
+
+
+@dataclass(frozen=True)
+class Vec3i:
+    _a: int
+    _b: int
+    _c: int
+
+    def __post_init__(self) -> None:
+        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:
+        return type(self)(*(np.array(self) + other))
+
+    def __radd__(self, other) -> Vec3i:
+        return self.__add__(other)
+
+    def __sub__(self, other) -> Vec3i:
+        return self.__add__(-other)
+
+    def __rsub__(self, other) -> Vec3i:
+        return -self.__sub__(other)
+
+    def __mul__(self, other) -> Vec3i:
+        return type(self)(*(np.array(self) * other))
+
+    def __rmul__(self, other) -> Vec3i:
+        return self.__mul__(other)
+
+    def __floordiv__(self, other) -> Vec3i:
+        return type(self)(*(np.array(self) // other))
+
+    def __rfloordiv__(self, other) -> Vec3i:
+        return type(self)(*(other // np.array(self)))
+
+    def __truediv__(self, other) -> Vec3i:
+        return self.__floordiv__(other)
+
+    def __rtruediv__(self, other) -> Vec3i:
+        return self.__rfloordiv__(other)
+
+    def __mod__(self, other) -> Vec3i:
+        return type(self)(*(np.array(self) % other))
+
+    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) < other
+
+    def __le__(self, other):
+        return np.array(self) <= other
+
+    def __gt__(self, other):
+        return np.array(self) > other
+
+    def __ge__(self, other):
+        return np.array(self) >= other
+
+    def to_nbt(self) -> nbtlib.Compound:
+        return nbtlib.Compound({
+            "x": nbtlib.Int(self._a),
+            "y": nbtlib.Int(self._b),
+            "z": nbtlib.Int(self._c),
+        })
+
+    @classmethod
+    def from_nbt(cls, nbt: nbtlib.Compound) -> Vec3i:
+        return cls(int(nbt["x"]), int(nbt["y"]), int(nbt["z"]))
+
+
+@dataclass(frozen=True)
+class BlockPosition(Vec3i):
+
+    @property
+    def x(self) -> int:
+        return self._a
+
+    @property
+    def y(self) -> int:
+        return self._b
+
+    @property
+    def z(self) -> int:
+        return self._c
+
+    def __repr__(self) -> str:
+        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):
+
+    @property
+    def width(self) -> int:
+        return self._a
+
+    @property
+    def height(self) -> int:
+        return self._b
+
+    @property
+    def length(self) -> int:
+        return self._c
+
+    def __repr__(self) -> str:
+        return (
+            f"{type(self).__name__}("
+            f"width={self.width}, height={self.height}, length={self.length})")
+
+    @property
+    def volume(self) -> int:
+        return abs(self.width * self.height * self.length)
+
+    @property
+    def limit(self) -> BlockPosition:
+        return BlockPosition(*(self - self.sign))
+
+    @property
+    def sign(self) -> BlockPosition:
+        return BlockPosition(*np.sign(self))