pylitematic 0.0.0__tar.gz → 0.0.1__tar.gz

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

@@ -1,18 +1,18 @@
 Metadata-Version: 2.4
 Name: pylitematic
-Version: 0.0.0
+Version: 0.0.1
 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/nieswand/pylitematic
-Project-URL: Repository, https://github.com/nieswand/pylitematic
-Project-URL: Issues, https://github.com/nieswand/pylitematic/issues
+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: Programming Language :: Python :: 3
-Requires-Python: >=3.7
+Requires-Python: >=3.10.12
 Description-Content-Type: text/markdown
 Requires-Dist: bitpacking>=0.1.0
-Requires-Dist: nbtlib>=1.6
-Requires-Dist: numpy>=1.21
+Requires-Dist: nbtlib>=2.0.4
+Requires-Dist: numpy>=2.2.6
 
 # pylitematic
 
@@ -25,5 +25,5 @@ Load, modify, and save [Litematica](https://litematica.org/) schematics
 
 `pylitematic` is available on pypi:
 ```bash
-pip install --upgrade pylitematic
+python3 -m pip install --upgrade pylitematic
 ```

{pylitematic-0.0.0 → pylitematic-0.0.1}/README.md

@@ -9,5 +9,5 @@ Load, modify, and save [Litematica](https://litematica.org/) schematics
 
 `pylitematic` is available on pypi:
 ```bash
-pip install --upgrade pylitematic
+python3 -m pip install --upgrade pylitematic
 ```

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

@@ -1,30 +1,30 @@
 [build-system]
-requires = ["setuptools>=61.0"]
+requires = ["setuptools>=59.6.0"]
 build-backend = "setuptools.build_meta"
 
 [project]
 name = "pylitematic"
-version = "0.0.0"
+version = "0.0.1"
 description = "Load, modify, and save Litematica schematics"
 authors = [
     { name="Boscawinks", email="bosca.winks@gmx.de" }
 ]
 dependencies = [
     "bitpacking >=0.1.0",
-    "nbtlib >=1.6",
-    "numpy >=1.21"
+    "nbtlib >=2.0.4",
+    "numpy >=2.2.6"
 ]
 readme = "README.md"
-requires-python = ">=3.7"
+requires-python = ">=3.10.12"
 license = { text = "GPL-3.0-only" }
 classifiers = [
     "Programming Language :: Python :: 3",
 ]
 
 [project.urls]
-Homepage = "https://github.com/nieswand/pylitematic"
-Repository = "https://github.com/nieswand/pylitematic"
-Issues = "https://github.com/nieswand/pylitematic/issues"
+Homepage = "https://github.com/boscawinks/pylitematic"
+Repository = "https://github.com/boscawinks/pylitematic"
+Issues = "https://github.com/boscawinks/pylitematic/issues"
 
 [tool.setuptools.packages.find]
 where = ["src"]

pylitematic-0.0.1/src/pylitematic/__init__.py

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

pylitematic-0.0.1/src/pylitematic/block_property.py

@@ -0,0 +1,325 @@
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+import json
+import nbtlib
+import re
+from typing import Any
+
+
+PROPERTY_NAME_REGEX: str = r"[a-z][a-z0-9_]*"
+PROPERTY_NAME_PATTERN: re.Pattern = re.compile(PROPERTY_NAME_REGEX)
+
+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):
+        props = {}
+        for name, value in dict(*args, **kwargs).items():
+            self.validate_name(name)
+            props[name] = PropertyValue.value_factory(value)
+        super().__init__(props)
+
+    def __getitem__(self, key):
+        return super().__getitem__(key).get()
+
+    def __setitem__(self, key, value):
+        if key not in self:
+            self.validate_name(key)
+            super().__setitem__(key, PropertyValue.value_factory(value))
+        else:
+            super().__getitem__(key).set(value)
+
+    def __lt__(self, other: Any) -> bool:
+        if not isinstance(other, Properties):
+            return NotImplemented
+        return sorted(self.items()) < sorted(other.items())
+
+    def __hash__(self) -> int:
+        return hash(tuple(sorted(self)))
+
+    def __str__(self) -> str:
+        props_str = [f"{n}={v}" for n, v in sorted(super().items())]
+        return f"[{','.join(props_str)}]"
+
+    def __repr__(self) -> str:
+        props_reps = [f"{n}: {v!r}" for n, v in sorted(super().items())]
+        return f"{type(self).__name__}({', '.join(props_reps)})"
+
+    def get(self, key, default=None):
+        value = super().get(key, None)
+        if value is None:
+            return default
+        return value.get()
+
+    def setdefault(self, key, default=None):
+        if key not in self:
+            self[key] = default
+        return self[key]
+
+    def update(self, *args, **kwargs):
+        for name, value in dict(*args, **kwargs).items():
+            self[name] = value
+
+    def pop(self, key, default=None):
+        value = super().pop(key, None)
+        if value is None:
+            return default
+        return value.get()
+
+    def popitem(self):
+        name, value = super().popitem()
+        return name, value.get()
+
+    def values(self):
+        for value in super().values():
+            yield value.get()
+
+    def items(self):
+        for key, value in super().items():
+            yield key, value.get()
+
+    @staticmethod
+    def is_valid_name(name: str) -> bool:
+        return PROPERTY_NAME_PATTERN.fullmatch(name) is not None
+
+    @staticmethod
+    def validate_name(name: str) -> None:
+        if not Properties.is_valid_name(name=name):
+            raise ValueError(f"Invalid property name {name!r}")
+
+    def to_string(self) -> str:
+        return str(self)
+
+    @staticmethod
+    def from_string(string: str) -> Properties:
+        if string in ("", "[]"):
+            return Properties()
+
+        if not (string.startswith("[") and string.endswith("]")):
+            raise ValueError(f"Invalid properties string {string!r}")
+        string = string[1:-1]
+
+        props = {}
+        for prop in string.split(","):
+            try:
+                name, val_str = prop.split("=")
+            except ValueError as exc:
+                raise ValueError(f"Invalid property string {string!r}") from exc
+            if name in props:
+                ValueError(f"Duplicate property name {name!r}")
+            props[name] = PropertyValue.from_string(string=val_str).get()
+
+        return Properties(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:
+        props = {}
+        for name, value in nbt.items():
+            props[name] = PropertyValue.from_nbt(nbt=value).get()
+        return Properties(props)
+
+
+class PropertyValue(ABC):
+
+    __slots__ = ("_value")
+    __registry: dict[type, type[PropertyValue]] = {}
+
+    def __init_subclass__(cls, **kwargs) -> None:
+        super().__init_subclass__(**kwargs)
+        py_type = cls.python_type()
+        if py_type in cls.__registry:
+            raise ValueError(
+                f"Duplicate Value subclass for type {py_type.__name__!r}:"
+                f" {cls.__registry[py_type].__name__} vs {cls.__name__}")
+        cls.__registry[py_type] = cls
+
+    def __init__(self, value: Any) -> None:
+        self.set(value)
+
+    def __str__(self) -> str:
+        return json.dumps(self._value)
+
+    def __repr__(self) -> str:
+        return f"{type(self).__name__}({self._value!r})"
+
+    def __hash__(self) -> int:
+        return hash((self.__class__, self._value))
+
+    def __eq__(self, other: Any) -> bool:
+        if not isinstance(other, self.__class__):
+            return NotImplemented
+        return self._value == other._value
+
+    def __lt__(self, other: Any) -> bool:
+        if not isinstance(other, PropertyValue):
+            return NotImplemented
+        return self._value < other._value
+
+    @classmethod
+    @abstractmethod
+    def is_valid_value(cls, value: Any) -> bool:
+        ...
+
+    @classmethod
+    def validate_value(cls, value: Any) -> None:
+        if not isinstance(value, cls.python_type()):
+            raise TypeError(
+                f"{cls.__name__} expects value of type"
+                f" {cls.python_type().__name__}, got {type(value).__name__}"
+                f" ({value!r})")
+        if not cls.is_valid_value(value):
+            raise ValueError(f"Invalid value {value!r} for {cls.__name__}")
+
+    def get(self) -> Any:
+        return self._value
+
+    def set(self, value: Any) -> None:
+        self.validate_value(value=value)
+        self._value = self.python_type()(value)
+
+    @classmethod
+    @abstractmethod
+    def python_type(cls) -> type:
+        """Return the native Python type this Value corresponds to."""
+
+    @staticmethod
+    def value_factory(value: Any) -> PropertyValue:
+        reg = PropertyValue.__registry
+        sub_cls = reg.get(type(value))
+        if sub_cls is None:
+            opt_str = ", ".join(map(lambda x: x.__name__, reg))
+            raise TypeError(
+                f"No Value subclass registered for {type(value).__name__} value"
+                f" {value!r}. Classes registered for: {opt_str}")
+        return sub_cls(value)
+
+    def to_string(self) -> str:
+        return str(self)
+
+    @staticmethod
+    def from_string(string: str) -> PropertyValue:
+        try:
+            value = json.loads(string)
+        except json.JSONDecodeError:
+            value = string
+        return PropertyValue.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))
+
+
+class BooleanValue(PropertyValue):
+
+    @classmethod
+    def is_valid_value(cls, value: Any) -> bool:
+        return True
+
+    @classmethod
+    def python_type(cls) -> type:
+        """Return the native Python type a BooleanValue corresponds to."""
+        return bool
+
+
+class IntegerValue(PropertyValue):
+
+    @classmethod
+    def is_valid_value(cls, value: Any) -> bool:
+        return value >= 0
+
+    @classmethod
+    def python_type(cls) -> type:
+        """Return the native Python type an IntegerValue corresponds to."""
+        return int
+
+
+class EnumValue(PropertyValue):
+
+    def __str__(self) -> str:
+        return self._value
+
+    @classmethod
+    def is_valid_value(cls, value: Any) -> bool:
+        return ENUM_VALUE_PATTERN.fullmatch(value) is not None
+
+    @classmethod
+    def python_type(cls) -> type:
+        """Return the native Python type an EnumValue corresponds to."""
+        return str

pylitematic-0.0.1/src/pylitematic/block_state.py

@@ -0,0 +1,112 @@
+from __future__ import annotations
+
+from copy import deepcopy
+from nbtlib import Compound
+from typing import Any, Iterator
+
+from .resource_location import ResourceLocation
+from .block_property import Properties
+
+
+class BlockState:
+
+    __slots__ = ("_id", "_props")
+
+    def __init__(self, _id: str, **props: Any) -> None:
+        self._id: ResourceLocation = ResourceLocation.from_string(_id)
+        self._props: Properties = Properties(**props)
+
+    def __getitem__(self, name: str) -> Any:
+        try:
+            return self._props[name]
+        except KeyError as exc:
+            raise KeyError(
+                f"{type(self).__name__} '{self}' does not"
+                f" have {name!r} property") from exc
+
+    # def __getattr__(self, name: str) -> Any:
+    #     return self[name]
+
+    def __contains__(self, name: str) -> bool:
+        return name in self._props
+
+    def __len__(self) -> int:
+        return len(self._props)
+
+    def __eq__(self, other: Any) -> bool:
+        if isinstance(other, str):
+            other = BlockState.from_string(other)
+        elif not isinstance(other, BlockState):
+            return NotImplemented
+        return (self.id, self._props) == (other.id, other._props)
+
+    def __lt__(self, other: Any) -> bool:
+        if not isinstance(other, BlockState):
+            return NotImplemented
+        return (self.id, self._props) < (other.id, other._props)
+
+    def __hash__(self) -> int:
+        return hash((self._id, self._props))
+
+    def __str__(self) -> str:
+        props_str = "" if not self._props else str(self._props)
+        return f"{self.id}{props_str}"
+
+    def __repr__(self) -> str:
+        return (
+            f"{type(self).__name__}("
+            f"id: {self._id!r}, props: {self._props!r})")
+
+    @property
+    def id(self) -> str:
+        return str(self._id)
+
+    def props(self) -> Iterator[tuple[str, Any]]:
+        return self._props.items()
+
+    def to_string(self) -> str:
+        return str(self)
+
+    @staticmethod
+    def from_string(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._props = Properties.from_string(props)
+        return state
+
+    def to_nbt(self) -> Compound:
+        nbt = Compound()
+        nbt["Name"] = self._id.to_nbt()
+        if self._props:
+            nbt["Properties"] = self._props.to_nbt()
+        return nbt
+
+    @staticmethod
+    def from_nbt(nbt: Compound) -> BlockState:
+        state = BlockState(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._props = deepcopy(self._props)
+        return state
+
+    def with_props(self, **props: Any) -> BlockState:
+        state = BlockState(self.id)
+        new_props = deepcopy(self._props)
+        for name, value in props.items():
+            if value is None:
+                del new_props[name]
+            else:
+                new_props[name] = value
+        state._props = new_props
+        return state
+
+    def without_props(self) -> BlockState:
+        return BlockState(self.id)

pylitematic-0.0.1/src/pylitematic/geometry.py

@@ -0,0 +1,169 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+import nbtlib
+import numpy as np
+
+
+@dataclass(frozen=True)
+class Vec3i:
+    _a: int
+    _b: int
+    _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))
+
+    def __str__(self) -> str:
+        return str(list(self))
+
+    def __add__(self, other) -> Vec3i:
+        arr = np.array(self)
+        other_arr = self._to_array(other)
+        try:
+            result = arr + other_arr
+        except Exception:
+            return NotImplemented
+        return type(self)(*result.astype(int))
+
+    def __radd__(self, other) -> Vec3i:
+        return self.__add__(other)
+
+    def __sub__(self, other) -> Vec3i:
+        arr = np.array(self)
+        other_arr = self._to_array(other)
+        try:
+            result = arr - other_arr
+        except Exception:
+            return NotImplemented
+        return type(self)(*result.astype(int))
+
+    def __rsub__(self, other) -> Vec3i:
+        arr = np.array(self)
+        try:
+            result = other - arr
+        except Exception:
+            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 __floordiv__(self, scalar: int) -> Vec3i:
+        return type(self)(
+            self._a // scalar, self._b // scalar, self._c // scalar)
+
+    def __neg__(self) -> Vec3i:
+        return type(self)(-self._a, -self._b, -self._c)
+
+    def __getitem__(self, index: int) -> int:
+        return self.to_tuple()[index]
+
+    def __iter__(self):
+        return iter(self.to_tuple())
+
+    def __abs__(self) -> Vec3i:
+        return type(self)(*np.abs(self))
+
+    def __lt__(self, other):
+        return np.array(self) < self._to_array(other)
+
+    def __le__(self, other):
+        return np.array(self) <= self._to_array(other)
+
+    def __gt__(self, other):
+        return np.array(self) > self._to_array(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)
+
+    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})"
+
+
+@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})")