seals and charms

src/config/profile_models.py

@@ -9,6 +9,7 @@
 from src.config.helper import check_greater_than_zero, validate_percent
 from src.item.data.item_type import ItemType  # noqa: TC001
 from src.item.data.rarity import ItemRarity
+from src.scripts import correct_name
 
 MODULE_LOGGER = logging.getLogger(__name__)
 
@@ -19,6 +20,26 @@ def _parse_item_type_or_rarities(data: str | list[str]) -> list[str]:
     return data
 
 
+def _is_item_rarity(data: str) -> bool:
+    return any(rarity.value.lower() == data.lower() for rarity in ItemRarity)
+
+
+def _parse_name_or_rarities(data: str | list[str] | dict[str, str | list[str]]) -> dict[str, str | list[str]]:
+    if isinstance(data, dict):
+        return data
+    if isinstance(data, str):
+        if _is_item_rarity(data):
+            return {"rarities": [data]}
+        return {"name": data}
+    if isinstance(data, list):
+        if not data:
+            msg = "list cannot be empty"
+            raise ValueError(msg)
+        return {"rarities": data}
+    msg = "must be str or list"
+    raise ValueError(msg)
+
+
 class AffixAspectFilterModel(BaseModel):
     model_config = ConfigDict(extra="forbid")
     name: str
@@ -295,19 +316,28 @@ def name_must_exist(cls, name: str) -> str:
     @model_validator(mode="before")
     @classmethod
     def parse_data(cls, data: str | list[str] | dict[str, str | list[str]]) -> dict[str, str | list[str]]:
-        if isinstance(data, dict):
-            return data
-        if isinstance(data, str):
-            if any(rarity.value.lower() == data.lower() for rarity in ItemRarity):
-                return {"rarities": [data]}
-            return {"name": data}
-        if isinstance(data, list):
-            if not data:
-                msg = "list cannot be empty"
-                raise ValueError(msg)
-            return {"rarities": data}
-        msg = "must be str or list"
-        raise ValueError(msg)
+        return _parse_name_or_rarities(data)
+
+    @field_validator("rarities", mode="before")
+    @classmethod
+    def parse_rarities(cls, data: str | list[str]) -> list[str]:
+        return _parse_item_type_or_rarities(data)
+
+
+class NameRarityFilterModel(BaseModel):
+    model_config = ConfigDict(extra="forbid")
+    name: str | None = None
+    rarities: list[ItemRarity] = []
+
+    @field_validator("name")
+    @classmethod
+    def normalize_name(cls, name: str | None) -> str | None:
+        return correct_name(name)
+
+    @model_validator(mode="before")
+    @classmethod
+    def parse_data(cls, data: str | list[str] | dict[str, str | list[str]]) -> dict[str, str | list[str]]:
+        return _parse_name_or_rarities(data)
 
     @field_validator("rarities", mode="before")
     @classmethod
@@ -319,8 +349,10 @@ class ProfileModel(BaseModel):
     model_config = ConfigDict(extra="forbid", populate_by_name=True)
     affixes: list[DynamicItemFilterModel] = Field(default=[], alias="Affixes")
     aspect_upgrades: list[str] = Field(default=[], alias="AspectUpgrades")
+    charms: list[NameRarityFilterModel] = Field(default=[], alias="Charms")
     global_uniques: list[GlobalUniqueModel] = Field(default=[], alias="GlobalUniques")
     name: str
+    seals: list[NameRarityFilterModel] = Field(default=[], alias="Seals")
     sigils: SigilFilterModel = Field(
         default=SigilFilterModel(blacklist=[], whitelist=[], priority=SigilPriority.blacklist), alias="Sigils"
     )

src/item/data/item_type.py

@@ -75,6 +75,10 @@ def is_sigil(item_type: ItemType) -> bool:
     return item_type in [ItemType.Sigil, ItemType.EscalationSigil]
 
 
+def is_horadric_spellcraft(item_type: ItemType) -> bool:
+    return item_type in [ItemType.HoradricSeal, ItemType.Charm]
+
+
 def is_jewelry(item_type: ItemType) -> bool:
     return item_type in [ItemType.Amulet, ItemType.Ring]
 

src/item/descr/read_descr_tts.py

@@ -14,6 +14,7 @@
     ItemType,
     is_armor,
     is_consumable,
+    is_horadric_spellcraft,
     is_jewelry,
     is_non_sigil_mapping,
     is_sigil,
@@ -276,7 +277,7 @@ def _create_base_item_from_tts(tts_item: list[str]) -> Item | None:
     starting_item_type_index = 1
     if item.rarity == ItemRarity.Mythic:
         starting_item_type_index = 2
-    elif item.rarity == ItemRarity.Common:
+    elif item.rarity == ItemRarity.Common and search_string_split[0] != ItemRarity.Common.value:
         starting_item_type_index = 0
     item.item_type = _get_item_type(" ".join(search_string_split[starting_item_type_index:]))
     item.name = correct_name(tts_item[0])
@@ -451,6 +452,7 @@ def read_descr_mixed(img_item_descr: np.ndarray) -> Item | None:
     if any([
         is_consumable(item.item_type),
         is_non_sigil_mapping(item.item_type),
+        is_horadric_spellcraft(item.item_type),
         is_sigil(item.item_type),
         is_socketable(item.item_type),
         item.item_type in [ItemType.Material, ItemType.Tribute],
@@ -501,6 +503,7 @@ def read_descr() -> Item | None:
     if any([
         is_consumable(item.item_type),
         is_non_sigil_mapping(item.item_type),
+        is_horadric_spellcraft(item.item_type),
         is_socketable(item.item_type),
         item.item_type in [ItemType.Material, ItemType.Tribute, ItemType.Cache, ItemType.LairBossKey],
         item.seasonal_attribute == SeasonalAttribute.sanctified,

src/item/filter.py

@@ -17,6 +17,7 @@
     AffixFilterModel,
     DynamicItemFilterModel,
     GlobalUniqueModel,
+    NameRarityFilterModel,
     ProfileModel,
     SigilConditionModel,
     SigilFilterModel,
@@ -67,6 +68,8 @@ class Filter:
     aspect_upgrade_filters = {}
     paragon_filters = {}
     global_unique_filters = {}
+    seal_filters = {}
+    charm_filters = {}
     sigil_filters = {}
     tribute_filters = {}
 
@@ -236,31 +239,52 @@ def _check_sigil(self, item: Item) -> FilterResult:
             res.matched.append(MatchedFilter(f"{profile_name}"))
         return res
 
-    def _check_tribute(self, item: Item) -> FilterResult:
+    def _check_name_rarity_filters(
+        self,
+        item: Item,
+        item_filters: dict[str, list[NameRarityFilterModel | TributeFilterModel]],
+        section_name: str,
+        mythic_name: str,
+    ) -> FilterResult:
         res = FilterResult(keep=False, matched=[])
-        if not self.tribute_filters.items():
-            LOGGER.info(f"{item.original_name} -- Matched Tributes")
+        if not item_filters.items():
+            LOGGER.info(f"{item.original_name} -- Matched {section_name}")
             res.keep = True
-            res.matched.append(MatchedFilter("Tributes not filtered"))
+            res.matched.append(MatchedFilter(f"{section_name} not filtered"))
 
         if item.rarity == ItemRarity.Mythic:
-            LOGGER.info(f"{item.original_name} -- Matched mythic tribute, always kept")
+            LOGGER.info(f"{item.original_name} -- Matched mythic {section_name.lower()}, always kept")
             res.keep = True
-            res.matched.append(MatchedFilter("Mythic Tribute"))
+            res.matched.append(MatchedFilter(mythic_name))
 
-        for profile_name, profile_filter in self.tribute_filters.items():
+        for profile_name, profile_filter in item_filters.items():
             for filter_item in profile_filter:
-                if filter_item.name and not item.name.startswith(filter_item.name):
+                if filter_item.name and not (item.name or "").startswith(filter_item.name):
                     continue
 
                 if filter_item.rarities and item.rarity not in filter_item.rarities:
                     continue
 
-                LOGGER.info(f"{item.original_name} -- Matched {profile_name}.Tributes")
+                LOGGER.info(f"{item.original_name} -- Matched {profile_name}.{section_name}")
                 res.keep = True
                 res.matched.append(MatchedFilter(f"{profile_name}"))
         return res
 
+    def _check_tribute(self, item: Item) -> FilterResult:
+        return self._check_name_rarity_filters(
+            item=item, item_filters=self.tribute_filters, section_name="Tributes", mythic_name="Mythic Tribute"
+        )
+
+    def _check_seal(self, item: Item) -> FilterResult:
+        return self._check_name_rarity_filters(
+            item=item, item_filters=self.seal_filters, section_name="Seals", mythic_name="Mythic Seal"
+        )
+
+    def _check_charm(self, item: Item) -> FilterResult:
+        return self._check_name_rarity_filters(
+            item=item, item_filters=self.charm_filters, section_name="Charms", mythic_name="Mythic Charm"
+        )
+
     def _check_global_unique_filter(self, item: Item) -> FilterResult:
         res = FilterResult(keep=False, matched=[])
 
@@ -479,6 +503,8 @@ def load_files(self):
         self.affix_filters: dict[str, list[DynamicItemFilterModel]] = {}
         self.aspect_upgrade_filters: dict[str, list[str]] = {}
         self.paragon_filters: dict[str, object] = {}
+        self.seal_filters: dict[str, list[NameRarityFilterModel]] = {}
+        self.charm_filters: dict[str, list[NameRarityFilterModel]] = {}
         self.sigil_filters: dict[str, SigilFilterModel] = {}
         self.tribute_filters: dict[str, list[TributeFilterModel]] = {}
         self.global_unique_filters: dict[str, list[GlobalUniqueModel]] = {}
@@ -539,6 +565,12 @@ def load_files(self):
                 if data.aspect_upgrades:
                     self.aspect_upgrade_filters[data.name] = data.aspect_upgrades
                     sections.append(ASPECT_UPGRADES_LABEL)
+                if data.seals:
+                    self.seal_filters[data.name] = data.seals
+                    sections.append("Seals")
+                if data.charms:
+                    self.charm_filters[data.name] = data.charms
+                    sections.append("Charms")
                 if data.sigils and (data.sigils.blacklist or data.sigils.whitelist):
                     self.sigil_filters[data.name] = data.sigils
                     sections.append("Sigils")
@@ -575,6 +607,12 @@ def should_keep(self, item: Item) -> FilterResult:
         if item.item_type == ItemType.Tribute:
             return self._check_tribute(item)
 
+        if item.item_type == ItemType.HoradricSeal:
+            return self._check_seal(item)
+
+        if item.item_type == ItemType.Charm:
+            return self._check_charm(item)
+
         if item.item_type is None or item.power is None:
             return res
 

src/scripts/vision_mode_with_highlighting.py

@@ -372,6 +372,8 @@ def evaluate_item_and_queue_draw(self, item_descr: Item):
                                 item_descr_with_loc = item_descr
                             else:
                                 item_descr_with_loc = src.item.descr.read_descr_tts.read_descr_mixed(cropped_descr)
+                                if item_descr_with_loc is None:
+                                    item_descr_with_loc = item_descr
                             res = Filter().should_keep(item_descr_with_loc)
                             match = res.keep
 

tests/config/models_test.py

@@ -23,6 +23,7 @@
     GlobalUniqueModel,
     ItemFilterModel,
     ItemRarity,
+    NameRarityFilterModel,
     ProfileModel,
     SigilConditionModel,
     SigilFilterModel,
@@ -590,6 +591,31 @@ def test_rarities_parse_list(self) -> None:
         assert ItemRarity.Legendary in model.rarities
 
 
+class TestNameRarityFilterModel:
+    """Test generic name and rarity filters."""
+
+    def test_name_is_normalized(self) -> None:
+        """Test item names are normalized for matching TTS item names."""
+        model = NameRarityFilterModel.model_validate("Faint Charm")
+        assert model.name == "faint_charm"
+
+    def test_parse_from_string_rarity(self) -> None:
+        """Test parsing every rarity string."""
+        for rarity in ItemRarity:
+            model = NameRarityFilterModel.model_validate(rarity.value)
+            assert rarity in model.rarities
+
+    def test_parse_from_list(self) -> None:
+        """Test parsing from a rarity list."""
+        model = NameRarityFilterModel.model_validate([ItemRarity.Legendary.value, ItemRarity.Unique.value])
+        assert model.rarities == [ItemRarity.Legendary, ItemRarity.Unique]
+
+    def test_parse_empty_list_fails(self) -> None:
+        """Test that empty lists fail."""
+        with pytest.raises(ValidationError, match="list cannot be empty"):
+            NameRarityFilterModel.model_validate([])
+
+
 class TestSigilConditionModel:
     """Test SigilConditionModel."""
 
@@ -669,13 +695,17 @@ def test_camelcase_input(self) -> None:
             GlobalUniques=[GlobalUniqueModel(minPower=800)],
             Sigils={"blacklist": [], "whitelist": [], "priority": "blacklist"},
             Tributes=[],
+            Seals=["legendary"],
+            Charms=["rare"],
             Paragon=None,
         )
         assert model.name == "test_profile"
         assert model.affixes == []
         assert model.aspect_upgrades == []
         assert len(model.global_uniques) == 1
         assert model.global_uniques[0].min_power == 800
+        assert model.seals[0].rarities == [ItemRarity.Legendary]
+        assert model.charms[0].rarities == [ItemRarity.Rare]
 
     def test_snake_case_input(self) -> None:
         """Test loading with snake_case (new format)."""
@@ -686,13 +716,17 @@ def test_snake_case_input(self) -> None:
             global_uniques=[GlobalUniqueModel(min_power=900)],
             sigils={"blacklist": [], "whitelist": [], "priority": "blacklist"},
             tributes=[],
+            seals=["faint seal"],
+            charms=["faint charm"],
             paragon=None,
         )
         assert model.name == "test_profile"
         assert model.affixes == []
         assert model.aspect_upgrades == []
         assert len(model.global_uniques) == 1
         assert model.global_uniques[0].min_power == 900
+        assert model.seals[0].name == "faint_seal"
+        assert model.charms[0].name == "faint_charm"
 
     def test_mixed_naming(self) -> None:
         """Test mixing both naming conventions."""
@@ -747,6 +781,8 @@ def test_export_snake_case(self) -> None:
         assert "affixes" in exported
         assert "aspect_upgrades" in exported
         assert "global_uniques" in exported
+        assert "seals" in exported
+        assert "charms" in exported
         assert "sigils" in exported
         assert "tributes" in exported
         assert "paragon" in exported
@@ -758,6 +794,8 @@ def test_export_snake_case(self) -> None:
         assert "Affixes" not in exported
         assert "AspectUpgrades" not in exported
         assert "GlobalUniques" not in exported
+        assert "Seals" not in exported
+        assert "Charms" not in exported
         assert "minPower" not in exported["global_uniques"][0]
 
     def test_export_camelcase(self) -> None:
@@ -769,6 +807,8 @@ def test_export_camelcase(self) -> None:
         assert "Affixes" in exported
         assert "AspectUpgrades" in exported
         assert "GlobalUniques" in exported
+        assert "Seals" in exported
+        assert "Charms" in exported
         assert "Sigils" in exported
         assert "Tributes" in exported
         assert "Paragon" in exported
@@ -780,6 +820,8 @@ def test_export_camelcase(self) -> None:
         assert "affixes" not in exported
         assert "aspect_upgrades" not in exported
         assert "global_uniques" not in exported
+        assert "seals" not in exported
+        assert "charms" not in exported
         assert "min_power" not in exported["GlobalUniques"][0]
 
     def test_defaults(self) -> None:
@@ -790,6 +832,8 @@ def test_defaults(self) -> None:
         assert model.affixes == []
         assert model.aspect_upgrades == []
         assert model.global_uniques == []
+        assert model.seals == []
+        assert model.charms == []
         assert model.tributes == []
         assert model.paragon is None
         assert model.sigils.blacklist == []