hvbrowser 0.2.0__tar.gz → 0.2.2__tar.gz

{hvbrowser-0.2.0 → hvbrowser-0.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: hvbrowser
-Version: 0.2.0
+Version: 0.2.2
 Summary: Browser automation APIs for HentaiVerse.
 Project-URL: Homepage, https://github.com/Kuan-Lun/hvbrowser
 Project-URL: Tracker, https://github.com/Kuan-Lun/hvbrowser/issues
@@ -13,13 +13,13 @@ Classifier: License :: OSI Approved :: GNU Affero General Public License v3 or l
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python :: 3.14
 Requires-Python: <3.15,>=3.14
-Requires-Dist: hbrowser<0.37,>=0.36.3
+Requires-Dist: hbrowser<0.37,>=0.36.4
 Provides-Extra: dev
 Requires-Dist: black>=26.5.1; extra == 'dev'
-Requires-Dist: mypy>=2.1.0; extra == 'dev'
-Requires-Dist: pymarkdownlnt>=0.9.38; extra == 'dev'
+Requires-Dist: mypy>=2.3.0; extra == 'dev'
+Requires-Dist: pymarkdownlnt>=0.9.39; extra == 'dev'
 Requires-Dist: pytest>=9.1.1; extra == 'dev'
-Requires-Dist: ruff>=0.15.20; extra == 'dev'
+Requires-Dist: ruff>=0.16.3; extra == 'dev'
 Description-Content-Type: text/markdown
 
 # HVBrowser

{hvbrowser-0.2.0 → hvbrowser-0.2.2}/pyproject.toml

@@ -1,17 +1,17 @@
 [build-system]
-requires = ["hatchling"]
+requires = ["hatchling>=1.32.0"]
 build-backend = "hatchling.build"
 
 [project]
 name = "hvbrowser"
-version = "0.2.0"
+version = "0.2.2"
 description = "Browser automation APIs for HentaiVerse."
 readme = "README.md"
 authors = [{ name = "Kuan-Lun Wang" }]
 license = "AGPL-3.0-or-later"
 license-files = ["LICENSE"]
 requires-python = ">=3.14,<3.15"
-dependencies = ["hbrowser>=0.36.3,<0.37"]
+dependencies = ["hbrowser>=0.36.4,<0.37"]
 
 classifiers = [
     "Development Status :: 3 - Alpha",
@@ -24,9 +24,9 @@ classifiers = [
 [project.optional-dependencies]
 dev = [
     "black>=26.5.1",
-    "ruff>=0.15.20",
-    "mypy>=2.1.0",
-    "pymarkdownlnt>=0.9.38",
+    "ruff>=0.16.3",
+    "mypy>=2.3.0",
+    "pymarkdownlnt>=0.9.39",
     "pytest>=9.1.1",
 ]
 

{hvbrowser-0.2.0 → hvbrowser-0.2.2}/src/hvbrowser/equipment_repair.py

@@ -1,27 +1,81 @@
 """Typed inspection and repair operations for equipped gear."""
 
 import logging
-import re
 from dataclasses import dataclass
 from enum import StrEnum
 from typing import Any, Protocol
+from urllib.parse import parse_qs, urlsplit
 
 from .maintenance_navigation import (
     MaintenanceNavigationBlockedError,
     MaintenanceNavigator,
+    classify_maintenance_navigation_blocker,
 )
-from .realm import Realm, RealmNavigator
+from .realm import Realm, RealmNavigator, realm_from_url
 from .runtime import setup_logger
+from .urls import HENTAIVERSE_ISEKAI_ROOT_URL, HENTAIVERSE_ROOT_URL
 
 logger = setup_logger(__name__)
 
-_EQUIPMENT_COUNT_XPATH = "//label[@id='equipcount']"
-_REPAIR_SUBMIT_XPATH = "//input[@id='equipsubmit']"
+_EQUIPMENT_COUNT_XPATH = "//*[@id='equipform']//label[@id='equipcount']"
+_REPAIR_SUBMIT_XPATH = "//*[@id='equipform']//input[@id='equipsubmit']"
+_ARMORY_MENU_XPATH = (
+    "//*[@id='child_Bazaar']"
+    "//*[@onclick and contains(@onclick, 's=Bazaar') "
+    "and contains(@onclick, 'ss=am')]"
+    " | //*[@id='child_Bazaar']//a[contains(@href, 's=Bazaar') "
+    "and contains(@href, 'ss=am')]"
+)
 _REPAIR_TAB_XPATH = (
-    "//div[contains(@class, 'armory_tab') "
-    "and contains(normalize-space(.), 'Repair')]"
+    "//*[@id='armory_left']/a[contains(@href, 'screen=repair') "
+    "and ./*[contains(concat(' ', normalize-space(@class), ' '), "
+    "' armory_tab ')]]"
+)
+_REPAIR_SELECTED_PAGE_XPATH = (
+    "//*[@id='armory_outer']["
+    ".//*[@id='armory_left']/a[contains(@href, 'screen=repair')]"
+    "/*[contains(concat(' ', normalize-space(@class), ' '), ' armory_tab ') "
+    "and contains(concat(' ', normalize-space(@class), ' '), ' armory_cur ')] "
+    "and .//*[@id='filterbar']/a[contains(@href, 'filter=equipped')]"
+    "/*[contains(concat(' ', normalize-space(@class), ' '), ' cfbs ')]"
+    "]"
 )
-_EQUIPMENT_COUNT_PATTERN = re.compile(r"Selected [0-9]+ of ([0-9]+) matching")
+_EQUIPMENT_STATE_SCRIPT = """
+(() => {
+    const equipForm = document.getElementById("equipform");
+    const equipList = document.getElementById("equiplist");
+    const selectableCount = (
+        typeof selectable_count !== "number"
+        || !Number.isInteger(selectable_count)
+        || selectable_count < 0
+    ) ? null : selectable_count;
+    return {
+        hasEquipForm: Boolean(equipForm),
+        hasEquipList: Boolean(equipList),
+        selectableCount,
+        empty: Boolean(
+            equipList
+            && (
+                equipList.querySelector(".eqempty")
+                || equipList.querySelector("tr.eqselall > th > p")
+            )
+        ),
+        rowCount: equipList
+            ? equipList.querySelectorAll('tr[onmouseover*="hover_equip"]').length
+            : null,
+    };
+})()
+"""
+_ARMORY_MENU_VISIBILITY_ATTEMPTS = 20
+_ARMORY_MENU_VISIBILITY_INTERVAL_SECONDS = 0.1
+_ARMORY_URLS = {
+    Realm.PERSISTENT: (
+        f"{HENTAIVERSE_ROOT_URL}/" "?s=Bazaar&ss=am&screen=repair&filter=equipped"
+    ),
+    Realm.ISEKAI: (
+        f"{HENTAIVERSE_ISEKAI_ROOT_URL}" "?s=Bazaar&ss=am&screen=repair&filter=equipped"
+    ),
+}
 
 
 class EquipmentRepairOutcome(StrEnum):
@@ -60,6 +114,10 @@ class EquipmentRepairPageError(RuntimeError):
     """The Armory Repair page did not expose the expected structure."""
 
 
+class _EquipmentRepairNavigationSafetyError(EquipmentRepairPageError):
+    """The current battle state, origin, or realm could not be trusted."""
+
+
 class EquipmentRepairSubmissionError(RuntimeError):
     """A repair was submitted but its outcome is unknown or unconfirmed."""
 
@@ -71,6 +129,8 @@ class EquipmentRepairStateChangedError(RuntimeError):
 class _EquipmentRepairDriver(Protocol):
     page: Any
 
+    async def get(self, url: str) -> None: ...
+
     async def wait(
         self,
         fun: Any,
@@ -193,6 +253,44 @@ class EquipmentRepairClient:
         )
 
     async def _navigate(self, realm: Realm) -> None:
+        try:
+            await self._open_repair_from_menu(realm)
+            return
+        except MaintenanceNavigationBlockedError:
+            raise
+        except _EquipmentRepairNavigationSafetyError:
+            raise
+        except EquipmentRepairPageError as error:
+            logger.warning(
+                "Armory menu navigation did not open Repair; retrying through "
+                "the realm-scoped direct URL: realm=%s error_type=%s",
+                realm.value,
+                type(error).__name__,
+            )
+
+        await self._open_repair_directly(realm)
+
+    async def _open_repair_from_menu(self, realm: Realm) -> None:
+        await self._open_armory_from_menu(realm)
+        repair = await self._find_repair_tab()
+
+        try:
+            await self.driver.wait(
+                repair.click,
+                ischangeurl=True,
+            )
+        except Exception as error:
+            try:
+                await self._ensure_navigation_is_safe("after opening Repair")
+            except MaintenanceNavigationBlockedError as blocked:
+                raise blocked from error
+            except _EquipmentRepairNavigationSafetyError as safety_error:
+                raise safety_error from error
+            raise EquipmentRepairPageError("Unable to open Repair tab") from error
+
+        await self._verify_repair_destination(realm)
+
+    async def _open_armory_from_menu(self, realm: Realm) -> None:
         try:
             bazaar = await self.maintenance.select_bazaar(
                 realm,
@@ -204,9 +302,7 @@ class EquipmentRepairClient:
             raise EquipmentRepairPageError("Unable to open Bazaar") from error
 
         try:
-            armory_elements = await self.page.xpath(
-                "//div[contains(text(), 'The Armory')]", timeout=5
-            )
+            armory_elements = await self.page.xpath(_ARMORY_MENU_XPATH, timeout=5)
         except Exception as error:
             raise EquipmentRepairPageError(
                 "Unable to find The Armory menu entry"
@@ -214,16 +310,112 @@ class EquipmentRepairClient:
         if not armory_elements:
             raise EquipmentRepairPageError("Unable to find The Armory menu entry")
 
+        armory = armory_elements[0]
         try:
             await bazaar.mouse_move()
-            await armory_elements[0].mouse_move()
+            await self._wait_for_armory_menu(armory)
+            await armory.mouse_move()
             await self.driver.wait(
-                armory_elements[0].mouse_click,
+                armory.mouse_click,
                 ischangeurl=True,
             )
+        except EquipmentRepairPageError:
+            raise
         except Exception as error:
             raise EquipmentRepairPageError("Unable to open The Armory") from error
 
+    async def _wait_for_armory_menu(self, armory: Any) -> None:
+        last_error: Exception | None = None
+        for attempt in range(_ARMORY_MENU_VISIBILITY_ATTEMPTS):
+            try:
+                position = await armory.get_position()
+            except Exception as error:
+                last_error = error
+            else:
+                if position is not None:
+                    return
+
+            if attempt + 1 < _ARMORY_MENU_VISIBILITY_ATTEMPTS:
+                try:
+                    await self.page.wait(_ARMORY_MENU_VISIBILITY_INTERVAL_SECONDS)
+                except Exception as error:
+                    raise EquipmentRepairPageError(
+                        "Unable to wait for The Armory menu entry"
+                    ) from error
+
+        page_error = EquipmentRepairPageError(
+            "The Armory menu entry did not become visible"
+        )
+        if last_error is None:
+            raise page_error
+        raise page_error from last_error
+
+    async def _open_repair_directly(self, realm: Realm) -> None:
+        await self._ensure_navigation_is_safe("before direct Armory navigation")
+        try:
+            await self.driver.get(_ARMORY_URLS[realm])
+        except Exception as error:
+            try:
+                await self._ensure_navigation_is_safe("after direct Armory navigation")
+            except MaintenanceNavigationBlockedError as blocked:
+                raise blocked from error
+            except _EquipmentRepairNavigationSafetyError as safety_error:
+                raise safety_error from error
+            raise EquipmentRepairPageError(
+                "Unable to open The Armory through its direct URL"
+            ) from error
+
+        await self._verify_repair_destination(realm)
+
+    async def _ensure_navigation_is_safe(self, context: str) -> None:
+        try:
+            blocker = await classify_maintenance_navigation_blocker(self.page)
+        except Exception as error:
+            raise _EquipmentRepairNavigationSafetyError(
+                f"Unable to verify battle state {context}"
+            ) from error
+        if blocker is not None:
+            raise MaintenanceNavigationBlockedError(blocker)
+
+    async def _verify_repair_destination(self, realm: Realm) -> None:
+        await self._ensure_navigation_is_safe("after opening Repair")
+        try:
+            current_url = await self.page.evaluate("window.location.href")
+            landed_realm = realm_from_url(current_url)
+        except Exception as error:
+            raise _EquipmentRepairNavigationSafetyError(
+                "Unable to verify the Repair URL"
+            ) from error
+        if landed_realm is not realm:
+            raise _EquipmentRepairNavigationSafetyError(
+                "Repair navigation landed in the wrong realm"
+            )
+        if not isinstance(current_url, str):
+            raise _EquipmentRepairNavigationSafetyError("Repair URL is invalid")
+        parsed_url = urlsplit(current_url)
+        expected_path = "/isekai/" if realm is Realm.ISEKAI else "/"
+        if parsed_url.path != expected_path:
+            raise _EquipmentRepairNavigationSafetyError(
+                "Repair navigation landed on an unexpected path"
+            )
+        query = parse_qs(parsed_url.query, keep_blank_values=True)
+        expected_query = {
+            "s": ["Bazaar"],
+            "ss": ["am"],
+            "screen": ["repair"],
+        }
+        if any(query.get(key) != value for key, value in expected_query.items()):
+            raise EquipmentRepairPageError(
+                "Repair navigation did not land on the Repair route"
+            )
+        filter_values = query.get("filter")
+        if filter_values is not None and filter_values != ["equipped"]:
+            raise EquipmentRepairPageError(
+                "Repair navigation did not land on the Equipped filter"
+            )
+        await self._verify_repair_selected()
+
+    async def _find_repair_tab(self) -> Any:
         try:
             repair_elements = await self.page.xpath(
                 _REPAIR_TAB_XPATH,
@@ -233,53 +425,71 @@ class EquipmentRepairClient:
             raise EquipmentRepairPageError("Unable to find Repair tab") from error
         if not repair_elements:
             raise EquipmentRepairPageError("Unable to find Repair tab")
+        return repair_elements[0]
 
+    async def _verify_repair_selected(self) -> None:
         try:
-            await self.driver.wait(
-                repair_elements[0].click,
-                ischangeurl=True,
+            selected_tabs = await self.page.xpath(
+                _REPAIR_SELECTED_PAGE_XPATH,
+                timeout=5,
             )
         except Exception as error:
-            raise EquipmentRepairPageError("Unable to open Repair tab") from error
+            raise EquipmentRepairPageError(
+                "Unable to verify the Armory Repair page"
+            ) from error
+        if not selected_tabs:
+            raise EquipmentRepairPageError(
+                "Armory Repair selected-tab marker or Equipped filter marker is missing"
+            )
 
     async def _inspect_current(
         self,
         realm: Realm,
     ) -> tuple[EquipmentRepairSnapshot, Any | None]:
+        await self._verify_repair_destination(realm)
+
         try:
-            repair_page_markers = await self.page.xpath(
-                _REPAIR_TAB_XPATH,
+            equipcount_elements = await self.page.xpath(
+                _EQUIPMENT_COUNT_XPATH,
                 timeout=5,
             )
         except Exception as error:
             raise EquipmentRepairPageError(
-                "Unable to verify the Armory Repair page"
+                "Unable to inspect equipment repair count"
             ) from error
-        if not repair_page_markers:
-            raise EquipmentRepairPageError("Armory Repair page marker is missing")
 
         try:
-            equipcount_elements = await self.page.xpath(
-                _EQUIPMENT_COUNT_XPATH,
-                timeout=5,
-            )
+            raw_state = await self.page.evaluate(_EQUIPMENT_STATE_SCRIPT)
         except Exception as error:
             raise EquipmentRepairPageError(
                 "Unable to inspect equipment repair count"
             ) from error
-        if not equipcount_elements:
+        if not isinstance(raw_state, dict):
+            raise EquipmentRepairPageError("Equipment repair count state is invalid")
+        repair_count = raw_state.get("selectableCount")
+        empty = raw_state.get("empty")
+        row_count = raw_state.get("rowCount")
+        has_equip_form = raw_state.get("hasEquipForm")
+        has_equip_list = raw_state.get("hasEquipList")
+        if (
+            (repair_count is not None and type(repair_count) is not int)
+            or type(empty) is not bool
+            or (row_count is not None and (type(row_count) is not int or row_count < 0))
+            or has_equip_form is not True
+            or has_equip_list is not True
+        ):
+            raise EquipmentRepairPageError("Equipment repair count state is invalid")
+        if equipcount_elements:
+            if repair_count is None or repair_count < 0:
+                raise EquipmentRepairPageError(
+                    "Equipment repair count state is invalid"
+                )
+            return EquipmentRepairSnapshot(realm, repair_count), equipcount_elements[0]
+        if empty and row_count == 0 and repair_count in {None, 0}:
             return EquipmentRepairSnapshot(realm, 0), None
-
-        equipcount = equipcount_elements[0]
-        text = getattr(equipcount, "text", None)
-        if not isinstance(text, str):
-            raise EquipmentRepairPageError("Equipment repair count text is missing")
-        match = _EQUIPMENT_COUNT_PATTERN.search(text)
-        if match is None:
-            raise EquipmentRepairPageError(
-                f"Unable to parse equipment repair count from: {text!r}"
-            )
-        return EquipmentRepairSnapshot(realm, int(match.group(1))), equipcount
+        raise EquipmentRepairPageError(
+            "Equipment repair count is missing without an empty equipment list"
+        )
 
     async def _select_all_and_inspect_submit(self, equipcount: Any) -> tuple[bool, Any]:
         logger.debug("Before select-all click: %r", getattr(equipcount, "text", None))