Use nbtlib to parse ItemStack NBT tags and use them in spotlight pages (close #85)

Author: object-Object

noxfile.py

@@ -316,6 +316,11 @@ def dummy_setup(session: nox.Session):
                                         "item": "minecraft:stone",
                                         "anchor": "spotlight",
                                     },
+                                    {
+                                        "type": "patchouli:spotlight",
+                                        "text": "spotlight with named item!",
+                                        "item": """minecraft:stone{display:{Name:'{"text":"dirt?","color":"white"}'}}""",
+                                    },
                                 ],
                             },
                             "entries/patchistuff.json": {

pyproject.toml

@@ -44,6 +44,7 @@ dependencies = [
     "moderngl[headless]~=5.10",
     "moderngl-window~=2.4",
     "more_itertools~=10.1",
+    "nbtlib==1.12.1",
     "networkx~=3.2",
     "ordered-set~=4.1",
     "packaging~=23.2",

src/hexdoc/core/resource.py

@@ -4,15 +4,22 @@
 
 from __future__ import annotations
 
+import json
 import logging
 import re
 from fnmatch import fnmatch
 from pathlib import Path
 from typing import Annotated, Any, ClassVar, Literal, Self, TypeVar
 
+from nbtlib import (
+    Compound,
+    Path as NBTPath,
+    parse_nbt,  # pyright: ignore[reportUnknownVariableType]
+)
 from pydantic import (
     BeforeValidator,
     ConfigDict,
+    JsonValue,
     TypeAdapter,
     field_validator,
     model_serializer,
@@ -86,6 +93,7 @@ def resloc_json_schema_extra(
     config=DEFAULT_CONFIG
     | ConfigDict(
         json_schema_extra=resloc_json_schema_extra,
+        arbitrary_types_allowed=True,
     ),
 )
 class BaseResourceLocation:
@@ -255,9 +263,40 @@ class ItemStack(BaseResourceLocation, regex=_make_regex(count=True, nbt=True)):
     count: int | None = None
     nbt: str | None = None
 
+    _data: Compound | None = None
+
     def __init_subclass__(cls, **kwargs: Any):
         super().__init_subclass__(regex=cls._from_str_regex, **kwargs)
 
+    def __post_init__(self):
+        object.__setattr__(self, "_data", _parse_nbt(self.nbt))
+
+    @property
+    def data(self):
+        return self._data
+
+    def get_name(self) -> str | None:
+        if self.data is None:
+            return None
+
+        component_json = self.data.get(NBTPath("display.Name"))  # pyright: ignore[reportUnknownVariableType, reportUnknownMemberType]
+        if not isinstance(component_json, str):
+            return None
+
+        try:
+            component: JsonValue = json.loads(component_json)
+        except ValueError:
+            return None
+
+        if not isinstance(component, dict):
+            return None
+
+        name = component.get("text")
+        if not isinstance(name, str):
+            return None
+
+        return name
+
     @override
     def i18n_key(self, root: str = "item") -> str:
         return super().i18n_key(root)
@@ -300,3 +339,18 @@ def _add_hashtag_to_tag(value: Any):
 AssumeTag = Annotated[_T, BeforeValidator(_add_hashtag_to_tag)]
 """Validator that adds `#` to the start of strings, and sets `ResourceLocation.is_tag`
 to `True`."""
+
+
+def _parse_nbt(nbt: str | None) -> Compound | None:
+    if nbt is None:
+        return None
+
+    try:
+        result = parse_nbt(nbt)
+    except ValueError as e:
+        raise ValueError(f"Failed to parse sNBT literal '{nbt}': {e}") from e
+
+    if not isinstance(result, Compound):
+        raise ValueError(f"Expected Compound, got {type(result)}: {result}")
+
+    return result

src/hexdoc/minecraft/assets/with_texture.py

@@ -69,7 +69,9 @@ def load_id(cls, item: ItemStack, context: ContextSource):
         """Implements InlineModel."""
 
         i18n = I18n.of(context)
-        if item.path.startswith("texture"):
+        if (name := item.get_name()) is not None:
+            pass
+        elif item.path.startswith("texture"):
             name = i18n.localize_texture(item.id)
         else:
             name = i18n.localize_item(item)

test/core/test_resource.py

@@ -23,50 +23,100 @@ def test_resourcelocation(s: str, expected: ResourceLocation, str_prefix: str):
     assert str(actual) == str_prefix + s
 
 
-item_stacks: list[tuple[str, ItemStack, str]] = [
+item_stacks: list[tuple[str, ItemStack, str, str | None]] = [
     (
         "stone",
         ItemStack("minecraft", "stone", None, None),
         "minecraft:",
+        None,
     ),
     (
         "hexcasting:patchouli_book",
         ItemStack("hexcasting", "patchouli_book", None, None),
         "",
+        None,
     ),
     (
         "minecraft:stone#64",
         ItemStack("minecraft", "stone", 64, None),
         "",
+        None,
     ),
     (
-        "minecraft:diamond_pickaxe{display:{Lore:['A really cool pickaxe']}",
+        "minecraft:diamond_pickaxe{display:{Lore:['A really cool pickaxe']}}",
         ItemStack(
             "minecraft",
             "diamond_pickaxe",
             None,
-            "{display:{Lore:['A really cool pickaxe']}",
+            "{display:{Lore:['A really cool pickaxe']}}",
         ),
         "",
+        None,
     ),
     (
-        "minecraft:diamond_pickaxe#64{display:{Lore:['A really cool pickaxe']}",
+        "minecraft:diamond_pickaxe#64{display:{Lore:['A really cool pickaxe']}}",
         ItemStack(
             "minecraft",
             "diamond_pickaxe",
             64,
-            "{display:{Lore:['A really cool pickaxe']}",
+            "{display:{Lore:['A really cool pickaxe']}}",
         ),
         "",
+        None,
+    ),
+    (
+        """minecraft:diamond_pickaxe{display:{Name:'{"text": "foo"}'}}""",
+        ItemStack(
+            "minecraft",
+            "diamond_pickaxe",
+            None,
+            """{display:{Name:'{"text": "foo"}'}}""",
+        ),
+        "",
+        "foo",
+    ),
+    (
+        """minecraft:diamond_pickaxe{display:{Name:'{"text": "foo}'}}""",
+        ItemStack(
+            "minecraft",
+            "diamond_pickaxe",
+            None,
+            """{display:{Name:'{"text": "foo}'}}""",
+        ),
+        "",
+        None,
+    ),
+    (
+        """minecraft:diamond_pickaxe{displayy:{Name:'{"text": "foo"}'}}""",
+        ItemStack(
+            "minecraft",
+            "diamond_pickaxe",
+            None,
+            """{displayy:{Name:'{"text": "foo"}'}}""",
+        ),
+        "",
+        None,
+    ),
+    (
+        """minecraft:diamond_pickaxe{display:{Namee:'{"text": "foo"}'}}""",
+        ItemStack(
+            "minecraft",
+            "diamond_pickaxe",
+            None,
+            """{display:{Namee:'{"text": "foo"}'}}""",
+        ),
+        "",
+        None,
     ),
 ]
 
 
-@pytest.mark.parametrize("s,expected,str_prefix", item_stacks)
-def test_itemstack(s: str, expected: ItemStack, str_prefix: str):
+@pytest.mark.parametrize("s,expected,str_prefix,name", item_stacks)
+def test_itemstack(s: str, expected: ItemStack, str_prefix: str, name: str | None):
     actual = ItemStack.from_str(s)
     assert actual == expected
     assert str(actual) == str_prefix + s
+    assert actual.get_name() == name
 
 
 @pytest.mark.parametrize(