MaaDebugger 1.0.0__tar.gz

maadebugger-1.0.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 MaaXYZ
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

maadebugger-1.0.0/PKG-INFO

@@ -0,0 +1,12 @@
+Metadata-Version: 2.1
+Name: MaaDebugger
+Version: 1.0.0
+Summary: MaaDebugger
+Author: MaaXYZ
+Project-URL: Homepage, https://github.com/MaaXYZ/MaaDebugger
+Requires-Python: >=3.9
+Requires-Dist: MaaFw
+Requires-Dist: nicegui
+Description-Content-Type: text/markdown
+
+# MaaDebugger

maadebugger-1.0.0/README.md

@@ -0,0 +1 @@
+# MaaDebugger

maadebugger-1.0.0/pyproject.toml

@@ -0,0 +1,30 @@
+[project]
+name = "MaaDebugger"
+version = "1.0.0"
+description = "MaaDebugger"
+authors = [
+    { name = "MaaXYZ" },
+]
+dependencies = [
+    "MaaFw",
+    "nicegui",
+]
+readme = "README.md"
+requires-python = ">=3.9"
+
+[project.urls]
+Homepage = "https://github.com/MaaXYZ/MaaDebugger"
+
+[project.scripts]
+MaaDebugger = "MaaDebugger.main:main"
+
+[build-system]
+requires = [
+    "pdm-backend",
+]
+build-backend = "pdm.backend"
+
+[tool.pdm.build]
+includes = [
+    "src/MaaDebugger",
+]

maadebugger-1.0.0/src/MaaDebugger/__main__.py

@@ -0,0 +1,4 @@
+from .main import main
+
+if __name__ == "__main__":
+    main()

maadebugger-1.0.0/src/MaaDebugger/maafw/__init__.py

@@ -0,0 +1,138 @@
+import asyncio
+from pathlib import Path
+from typing import Callable, List, Optional
+
+from maa.controller import AdbController
+from maa.instance import Instance
+from maa.resource import Resource
+from maa.toolkit import Toolkit
+from PIL import Image
+
+from ..utils import cvmat_to_image
+
+
+class MaaFW:
+    def __init__(
+        self,
+        on_list_to_recognize: Callable = None,
+        on_miss_all: Callable = None,
+        on_recognition_result: Callable = None,
+    ):
+        Toolkit.init_option("./")
+        Instance.set_debug_message(True)
+
+        self.resource = None
+        self.controller = None
+        self.instance = None
+
+        self.screenshotter = Screenshotter(self.screencap)
+
+        self.on_list_to_recognize = on_list_to_recognize
+        self.on_miss_all = on_miss_all
+        self.on_recognition_result = on_recognition_result
+
+    @staticmethod
+    async def detect_adb() -> List["AdbDevice"]:
+        return await Toolkit.adb_devices()
+
+    async def connect_adb(self, path: Path, address: str) -> bool:
+        self.controller = AdbController(path, address)
+        connected = await self.controller.connect()
+        if not connected:
+            print(f"Failed to connect {path} {address}")
+            return False
+
+        return True
+
+    async def load_resource(self, dir: Path) -> bool:
+        if not self.resource:
+            self.resource = Resource()
+
+        return self.resource.clear() and await self.resource.load(dir)
+
+    async def run_task(self, entry: str, param: dict = {}) -> bool:
+        if not self.instance:
+            self.instance = Instance(callback=self._inst_callback)
+
+        self.instance.bind(self.resource, self.controller)
+        if not self.instance.inited:
+            print("Failed to init MaaFramework instance")
+            return False
+
+        return await self.instance.run_task(entry, param)
+
+    async def stop_task(self):
+        if not self.instance:
+            return
+
+        await self.instance.stop()
+
+    async def screencap(self, capture: bool = True) -> Optional[Image.Image]:
+        if not self.controller:
+            return None
+
+        im = await self.controller.screencap(capture)
+        if im is None:
+            return None
+
+        return cvmat_to_image(im)
+
+    async def click(self, x, y) -> None:
+        if not self.controller:
+            return None
+
+        await self.controller.click(x, y)
+
+    def _inst_callback(self, msg: str, detail: dict, arg):
+        match msg:
+            case "Task.Debug.ListToRecognize":
+                asyncio.run(self.screenshotter.refresh(False))
+                if self.on_list_to_recognize:
+                    self.on_list_to_recognize(detail["pre_hit_task"], detail["list"])
+
+            case "Task.Debug.MissAll":
+                if self.on_miss_all:
+                    self.on_miss_all(detail["pre_hit_task"], detail["list"])
+
+            case "Task.Debug.RecognitionResult":
+                reco_id = detail["recognition"]["id"]
+                name = detail["name"]
+                hit = detail["recognition"]["hit"]
+
+                if self.on_recognition_result:
+                    self.on_recognition_result(reco_id, name, hit)
+
+
+# class Screenshotter(threading.Thread):
+class Screenshotter:
+    def __init__(self, screencap_func: Callable):
+        super().__init__()
+        self.source = None
+        self.screencap_func = screencap_func
+        # self.active = False
+
+    def __del__(self):
+        self.source = None
+        # self.active = False
+
+    async def refresh(self, capture: bool = True):
+        im = await self.screencap_func(capture)
+        if not im:
+            return
+
+        self.source = im
+
+    # def run(self):
+    #     while self.active:
+    #         self.refresh()
+    #         time.sleep(0)
+
+    # def start(self):
+    #     self.active = True
+    #     super().start()
+
+    # def stop(self):
+    #     self.active = False
+
+
+maafw = MaaFW()

maadebugger-1.0.0/src/MaaDebugger/main.py

@@ -0,0 +1,11 @@
+from nicegui import ui
+
+from .webpage import index_page
+from .webpage import reco_page
+
+
+def main():
+    ui.dark_mode()  # auto dark mode
+    ui.run(
+        title="Maa Debugger", storage_secret="maadbg", reload=False
+    )  # , root_path="/proxy/8080")

maadebugger-1.0.0/src/MaaDebugger/utils/__init__.py

@@ -0,0 +1,8 @@
+from numpy import ndarray
+from PIL import Image
+
+
+def cvmat_to_image(cvmat: ndarray) -> Image.Image:
+    pil = Image.fromarray(cvmat)
+    b, g, r = pil.split()
+    return Image.merge("RGB", (r, g, b))

maadebugger-1.0.0/src/MaaDebugger/webpage/components/status_indicator.py

@@ -0,0 +1,34 @@
+from enum import Enum, auto
+
+from nicegui import ui
+
+
+class Status(Enum):
+    PENDING = auto()
+    RUNNING = auto()
+    SUCCESS = auto()
+    FAILURE = auto()
+
+
+class StatusIndicator:
+    def __init__(self, target_object, target_name):
+        self._label = ui.label().bind_text_from(
+            target_object,
+            target_name,
+            backward=lambda s: StatusIndicator._text_backward(s),
+        )
+
+    def label(self):
+        return self._label
+
+    @staticmethod
+    def _text_backward(status: Status) -> str:
+        match status:
+            case Status.PENDING:
+                return "🟡"
+            case Status.RUNNING:
+                return "👀"
+            case Status.SUCCESS:
+                return "✅"
+            case Status.FAILURE:
+                return "❌"

maadebugger-1.0.0/src/MaaDebugger/webpage/index_page/__init__.py

@@ -0,0 +1,14 @@
+from nicegui import ui
+
+from .master_control import main as master_control
+from .runtime_control import main as runtime_control
+
+
+@ui.page("/")
+async def index():
+
+    await master_control()
+
+    ui.separator()
+
+    await runtime_control()

maadebugger-1.0.0/src/MaaDebugger/webpage/index_page/master_control.py

@@ -0,0 +1,217 @@
+import asyncio
+from pathlib import Path
+
+from nicegui import app, binding, ui
+
+from ...maafw import maafw
+from ...webpage.components.status_indicator import Status, StatusIndicator
+
+binding.MAX_PROPAGATION_TIME = 1
+
+
+class GlobalStatus:
+    adb_connecting: Status = Status.PENDING
+    adb_detecting: Status = Status.PENDING  # not required
+    res_loading: Status = Status.PENDING
+    task_running: Status = Status.PENDING
+
+
+async def main():
+    with ui.row():
+        with ui.column():
+            with ui.row().style("align-items: center;"):
+                await connect_adb_control()
+            with ui.row().style("align-items: center;"):
+                await load_resource_control()
+            with ui.row().style("align-items: center;"):
+                await run_task_control()
+
+        with ui.column():
+            await screenshot_control()
+
+
+async def connect_adb_control():
+    StatusIndicator(GlobalStatus, "adb_connecting")
+
+    adb_path_input = (
+        ui.input(
+            "ADB Path",
+            placeholder="eg: C:/adb.exe",
+        )
+        .props("size=60")
+        .bind_value(app.storage.general, "adb_path")
+    )
+    adb_address_input = (
+        ui.input(
+            "ADB Address",
+            placeholder="eg: 127.0.0.1:5555",
+        )
+        .props("size=30")
+        .bind_value(app.storage.general, "adb_address")
+    )
+    ui.button(
+        "Connect",
+        on_click=lambda: on_click_connect(),
+    )
+
+    ui.button(
+        icon="wifi_find",
+        on_click=lambda: on_click_detect(),
+    )
+
+    devices_select = ui.select(
+        {}, on_change=lambda e: on_change_devices_select(e)
+    ).bind_visibility_from(
+        GlobalStatus,
+        "adb_detecting",
+        backward=lambda s: s == Status.SUCCESS,
+    )
+
+    StatusIndicator(GlobalStatus, "adb_detecting").label().bind_visibility_from(
+        GlobalStatus,
+        "adb_detecting",
+        backward=lambda s: s == Status.RUNNING or s == Status.FAILURE,
+    )
+
+    async def on_click_connect():
+        GlobalStatus.adb_connecting = Status.RUNNING
+
+        if not adb_path_input.value or not adb_address_input.value:
+            GlobalStatus.adb_connecting = Status.FAILURE
+            return
+
+        connected = await maafw.connect_adb(
+            Path(adb_path_input.value), adb_address_input.value
+        )
+        if not connected:
+            GlobalStatus.adb_connecting = Status.FAILURE
+            return
+
+        GlobalStatus.adb_connecting = Status.SUCCESS
+        GlobalStatus.adb_detecting = Status.PENDING
+
+        await maafw.screenshotter.refresh(True)
+
+    async def on_click_detect():
+        GlobalStatus.adb_detecting = Status.RUNNING
+
+        devices = await maafw.detect_adb()
+        options = {}
+        for d in devices:
+            v = (d.adb_path, d.address)
+            l = d.name + " " + d.address
+            options[v] = l
+
+        devices_select.options = options
+        devices_select.update()
+        if not options:
+            GlobalStatus.adb_detecting = Status.FAILURE
+            return
+
+        devices_select.value = next(iter(options))
+        GlobalStatus.adb_detecting = Status.SUCCESS
+
+    def on_change_devices_select(e):
+        adb_path_input.value = str(e.value[0])
+        adb_address_input.value = e.value[1]
+
+
+async def screenshot_control():
+    with ui.row().style("align-items: flex-end;"):
+        with ui.card().tight():
+            ui.interactive_image(
+                cross="green",
+                on_mouse=lambda e: on_click_image(int(e.image_x), int(e.image_y)),
+            ).bind_source_from(maafw.screenshotter, "source").style(
+                "height: 200px;"
+            ).bind_visibility_from(
+                GlobalStatus, "adb_connecting", backward=lambda s: s == Status.SUCCESS
+            )
+
+        ui.button(
+            icon="refresh", on_click=lambda: on_click_refresh()
+        ).bind_visibility_from(
+            GlobalStatus, "adb_connecting", backward=lambda s: s == Status.SUCCESS
+        ).bind_enabled_from(
+            GlobalStatus, "task_running", backward=lambda s: s != Status.RUNNING
+        )
+
+    async def on_click_image(x, y):
+        print(f"on_click_image: {x}, {y}")
+        await maafw.click(x, y)
+        await asyncio.sleep(0.2)
+        await on_click_refresh()
+
+    async def on_click_refresh():
+        await maafw.screenshotter.refresh(True)
+
+
+async def load_resource_control():
+    StatusIndicator(GlobalStatus, "res_loading")
+
+    dir_input = (
+        ui.input(
+            "Resource Directory",
+            placeholder="eg: C:/M9A/assets/resource/base",
+        )
+        .props("size=60")
+        .bind_value(app.storage.general, "resource_dir")
+    )
+
+    ui.button(
+        "Load",
+        on_click=lambda: on_click_load(),
+    )
+
+    async def on_click_load():
+        GlobalStatus.res_loading = Status.RUNNING
+
+        if not dir_input.value:
+            GlobalStatus.res_loading = Status.FAILURE
+            return
+
+        loaded = await maafw.load_resource(Path(dir_input.value))
+        if not loaded:
+            GlobalStatus.res_loading = Status.FAILURE
+            return
+
+        GlobalStatus.res_loading = Status.SUCCESS
+
+
+async def run_task_control():
+    StatusIndicator(GlobalStatus, "task_running")
+
+    entry_input = (
+        ui.input(
+            "Task Entry",
+            placeholder="eg: StartUp",
+        )
+        .props("size=30")
+        .bind_value(app.storage.general, "task_entry")
+    )
+
+    ui.button("Start", on_click=lambda: on_click_start())
+    ui.button("Stop", on_click=lambda: on_click_stop())
+
+    async def on_click_start():
+        GlobalStatus.task_running = Status.RUNNING
+
+        if not entry_input.value:
+            GlobalStatus.task_running = Status.FAILURE
+            return
+
+        run = await maafw.run_task(entry_input.value)
+        if not run:
+            GlobalStatus.task_running = Status.FAILURE
+            return
+
+        GlobalStatus.task_running = Status.SUCCESS
+
+    async def on_click_stop():
+        stopped = await maafw.stop_task()
+        if not stopped:
+            GlobalStatus.task_running = Status.FAILURE
+            return
+
+        GlobalStatus.task_running = Status.PENDING
+        await maafw.screenshotter.refresh(True)

maadebugger-1.0.0/src/MaaDebugger/webpage/index_page/runtime_control.py

@@ -0,0 +1,95 @@
+from collections import defaultdict
+from dataclasses import dataclass
+
+from nicegui import ui
+
+from ...maafw import maafw
+from ...webpage.components.status_indicator import Status, StatusIndicator
+from ...webpage.reco_page import RecoData
+
+
+async def main():
+    Controls.recognition_row.register()
+
+
+class RecognitionRow:
+
+    def __init__(self) -> None:
+        self.row_len = 0
+        self.data = defaultdict(dict)
+
+    def register(self):
+        self.row = ui.row()
+
+        maafw.on_list_to_recognize = self.on_list_to_recognize
+        maafw.on_miss_all = self.on_miss_all
+        maafw.on_recognition_result = self.on_recognition_result
+
+    def on_list_to_recognize(self, pre_hit, list_to_reco):
+        self.row_len = self.row_len + 1
+
+        self.cur_list = list_to_reco
+        self.next_reco_index = 0
+
+        with self.row:
+            self._add_list(pre_hit, list_to_reco)
+
+    def _add_list(self, pre_hit, list_to_reco):
+        with ui.list().props("bordered separator"):
+            ui.item_label(pre_hit).props("header").classes("text-bold")
+            ui.separator()
+
+            for index in range(len(list_to_reco)):
+                name = list_to_reco[index]
+                self._add_item(index, name)
+
+    @dataclass
+    class ItemData:
+        col: int
+        row: int
+        name: str
+        reco_id: int = 0
+        status: Status = Status.PENDING
+
+    def _add_item(self, index, name):
+        data = RecognitionRow.ItemData(self.row_len, index, name)
+        self.data[self.row_len][index] = data
+
+        with ui.item(on_click=lambda data=data: self.on_click_item(data)):
+            with ui.item_section().props("side"):
+                StatusIndicator(data, "status")
+
+            with ui.item_section():
+                ui.item_label(name)
+
+            with ui.item_section().props("side"):
+                ui.item_label().bind_text_from(data, "reco_id").bind_visibility_from(
+                    data, "reco_id", backward=lambda i: i != 0
+                ).props("caption")
+
+    def on_click_item(self, data: ItemData):
+        print(f"on_click_item ({data.col}, {data.row}): {data.name} ({data.reco_id})")
+
+        ui.navigate.to(f"reco/{data.reco_id}", new_tab=True)
+
+    def on_recognition_result(self, reco_id: int, name: str, hit: bool):
+        target = None
+        for item in self.data[self.row_len].values():
+            if item.status == Status.PENDING and item.name == name:
+                target = item
+                break
+
+        if not target:
+            return
+
+        target.reco_id = reco_id
+        target.status = hit and Status.SUCCESS or Status.FAILURE
+
+        RecoData.data[reco_id] = name, hit
+
+    def on_miss_all(self, pre_hit, list_to_reco):
+        pass
+
+
+class Controls:
+    recognition_row = RecognitionRow()

maadebugger-1.0.0/src/MaaDebugger/webpage/reco_page/__init__.py

@@ -0,0 +1,38 @@
+from typing import Dict, Tuple
+
+from maa.instance import Instance
+from nicegui import ui
+
+from ...utils import cvmat_to_image
+
+
+class RecoData:
+    data: Dict[int, Tuple[str, bool]] = {}
+
+
+@ui.page("/reco/{reco_id}")
+def reco_page(reco_id: int):
+    if reco_id == 0 or not reco_id in RecoData.data:
+        ui.markdown("## Not Found")
+        return
+
+    name, hit = RecoData.data[reco_id]
+    status = hit and "✅" or "❌"
+    title = f"{status} {name} ({reco_id})"
+
+    ui.page_title(title)
+    ui.markdown(f"## {title}")
+
+    ui.separator()
+
+    details = Instance.query_recognition_detail(reco_id)
+    if not details:
+        ui.markdown("## Not Found")
+        return
+
+    ui.markdown(f"#### Hit: {str(details.hit_box)}")
+
+    for draw in details.draws:
+        ui.image(cvmat_to_image(draw)).props("fit=scale-down")
+
+    ui.json_editor({"content": {"json": details.detail}, "readOnly": True})