ksaa 2025.9b1__py3-none-any.whl → 2025.9b2__py3-none-any.whl

kotonebot/client/implements/windows.py

@@ -1,168 +0,0 @@
-from ctypes import windll
-from typing import Literal
-from importlib import resources
-from functools import cached_property
-from dataclasses import dataclass
-
-import cv2
-import win32ui
-import win32gui
-import numpy as np
-from ahk import AHK, MsgBoxIcon
-from cv2.typing import MatLike
-
-from ..device import Device, WindowsDevice
-from ..protocol import Commandable, Touchable, Screenshotable
-from ..registration import ImplConfig
-
-# 1. 定义配置模型
-@dataclass
-class WindowsImplConfig(ImplConfig):
-    window_title: str
-    ahk_exe_path: str
-
-class WindowsImpl(Touchable, Screenshotable):
-    def __init__(self, device: Device, window_title: str, ahk_exe_path: str):
-        self.__hwnd: int | None = None
-        self.window_title = window_title
-        self.ahk = AHK(executable_path=ahk_exe_path)
-        self.device = device
-
-        # 设置 DPI aware，否则高缩放显示器上返回的坐标会错误
-        windll.user32.SetProcessDPIAware()
-        # TODO: 这个应该移动到其他地方去
-        def _stop():
-            from kotonebot.backend.context.context import vars
-            vars.flow.request_interrupt()
-            self.ahk.msg_box('任务已停止。', title='琴音小助手', icon=MsgBoxIcon.EXCLAMATION)
-
-        def _toggle_pause():
-            from kotonebot.backend.context.context import vars
-            if vars.flow.is_paused:
-                self.ahk.msg_box('任务即将恢复。\n关闭此消息框后将会继续执行', title='琴音小助手', icon=MsgBoxIcon.EXCLAMATION)
-                vars.flow.request_resume()
-            else:
-                vars.flow.request_pause()
-                self.ahk.msg_box('任务已暂停。\n关闭此消息框后再按一次快捷键恢复执行。', title='琴音小助手', icon=MsgBoxIcon.EXCLAMATION)
-
-        self.ahk.add_hotkey('^F4', _toggle_pause) # Ctrl+F4 暂停/恢复
-        self.ahk.add_hotkey('^F3', _stop)  # Ctrl+F3 停止
-        self.ahk.start_hotkeys()
-        # 将点击坐标设置为相对 Client
-        self.ahk.set_coord_mode('Mouse', 'Client')
-
-    @property
-    def hwnd(self) -> int:
-        if self.__hwnd is None:
-            self.__hwnd = win32gui.FindWindow(None, self.window_title)
-            if self.__hwnd is None or self.__hwnd == 0:
-                raise RuntimeError(f'Failed to find window: {self.window_title}')
-        return self.__hwnd
-
-    def __client_rect(self) -> tuple[int, int, int, int]:
-        """获取 Client 区域屏幕坐标"""
-        hwnd = self.hwnd
-        client_left, client_top, client_right, client_bottom = win32gui.GetClientRect(hwnd)
-        client_left, client_top = win32gui.ClientToScreen(hwnd, (client_left, client_top))
-        client_right, client_bottom = win32gui.ClientToScreen(hwnd, (client_right, client_bottom))
-        return client_left, client_top, client_right, client_bottom
-
-    def __client_to_screen(self, hwnd: int, x: int, y: int) -> tuple[int, int]:
-        """将 Client 区域坐标转换为屏幕坐标"""
-        return win32gui.ClientToScreen(hwnd, (x, y))
-
-    def screenshot(self) -> MatLike:
-        if not self.ahk.win_is_active(self.window_title):
-            self.ahk.win_activate(self.window_title)
-        hwnd = self.hwnd
-
-        # TODO: 需要检查下面这些 WinAPI 的返回结果
-        # 获取整个窗口的坐标
-        left, top, right, bot = win32gui.GetWindowRect(hwnd)
-        w = right - left
-        h = bot - top
-
-        # 获取客户区域的坐标
-        client_left, client_top, client_right, client_bot = self.__client_rect()
-
-        # 获取整个屏幕的截图
-        hwndDC = win32gui.GetWindowDC(0)
-        mfcDC = win32ui.CreateDCFromHandle(hwndDC)
-        saveDC = mfcDC.CreateCompatibleDC()
-
-        saveBitMap = win32ui.CreateBitmap()
-        saveBitMap.CreateCompatibleBitmap(mfcDC, w, h)
-
-        saveDC.SelectObject(saveBitMap)
-
-        # 截图整个屏幕
-        result = windll.gdi32.BitBlt(saveDC.GetSafeHdc(), 0, 0, w, h, mfcDC.GetSafeHdc(), left, top, 0x00CC0020)
-
-        # 将截图转换为OpenCV格式
-        bmpinfo = saveBitMap.GetInfo()
-        bmpstr = saveBitMap.GetBitmapBits(True)
-        im = np.frombuffer(bmpstr, dtype=np.uint8)
-        im = im.reshape((bmpinfo['bmHeight'], bmpinfo['bmWidth'], 4))
-
-        # 裁剪出客户区域
-        cropped_im = im[client_top - top:client_bot - top, client_left - left:client_right - left]
-
-        # 释放资源
-        win32gui.DeleteObject(saveBitMap.GetHandle())
-        saveDC.DeleteDC()
-        mfcDC.DeleteDC()
-        win32gui.ReleaseDC(hwnd, hwndDC)
-
-        # 将 RGBA 转换为 RGB
-        cropped_im = cv2.cvtColor(cropped_im, cv2.COLOR_RGBA2RGB)
-        return cropped_im
-
-    @property
-    def screen_size(self) -> tuple[int, int]:
-        left, top, right, bot = self.__client_rect()
-        w = right - left
-        h = bot - top
-        return w, h
-
-    def detect_orientation(self) -> None | Literal['portrait'] | Literal['landscape']:
-        pos = self.ahk.win_get_position(self.window_title)
-        if pos is None:
-            return None
-        w, h = pos.width, pos.height
-        if w > h:
-            return 'landscape'
-        else:
-            return 'portrait'
-
-    def click(self, x: int, y: int) -> None:
-        # x, y = self.__client_to_screen(self.hwnd, x, y)
-        # (0, 0) 很可能会点到窗口边框上
-        if x == 0:
-            x = 2
-        if y == 0:
-            y = 2
-        if not self.ahk.win_is_active(self.window_title):
-            self.ahk.win_activate(self.window_title)
-        self.ahk.click(x, y)
-
-    def swipe(self, x1: int, y1: int, x2: int, y2: int, duration: float | None = None) -> None:
-        if not self.ahk.win_is_active(self.window_title):
-            self.ahk.win_activate(self.window_title)
-        # TODO: 这个 speed 的单位是什么？
-        self.ahk.mouse_drag(x2, y2, from_position=(x1, y1), coord_mode='Client', speed=10)
-
-if __name__ == '__main__':
-    from ..device import Device
-    device = Device()
-    # 在测试环境中直接使用默认路径
-    ahk_path = str(resources.files('kaa.res.bin') / 'AutoHotkey.exe')
-    impl = WindowsImpl(device, window_title='gakumas', ahk_exe_path=ahk_path)
-    device._screenshot = impl
-    device._touch = impl
-    device.swipe_scaled(0.5, 0.8, 0.5, 0.2)
-    # impl.swipe(0, 100, 0, 0)
-    # impl.click(100, 100)
-    # while True:
-    #     im = impl.screenshot()
-    #     cv2.imshow('test', im)
-    #     cv2.waitKey(1)

kotonebot/client/protocol.py

@@ -1,69 +0,0 @@
-from typing import Protocol, TYPE_CHECKING, runtime_checkable, Literal
-
-from cv2.typing import MatLike
-
-from kotonebot.primitives import Rect
-if TYPE_CHECKING:
-    from .device import Device
-
-@runtime_checkable
-class ClickableObjectProtocol(Protocol):
-    """
-    可点击对象的协议
-    """
-    @property
-    def rect(self) -> Rect:
-        ...
-
-class DeviceScreenshotProtocol(Protocol):
-    def screenshot(self) -> MatLike:
-        """
-        截图
-        """
-        ...
-
-@runtime_checkable
-class Commandable(Protocol):
-    def __init__(self, device: 'Device'): ...
-    def launch_app(self, package_name: str) -> None: ...
-    def current_package(self) -> str | None: ...
-
-@runtime_checkable
-class AndroidCommandable(Protocol):
-    """定义 Android 平台的特定命令"""
-    def launch_app(self, package_name: str) -> None: ...
-    def current_package(self) -> str | None: ...
-    def adb_shell(self, cmd: str) -> str: ...
-
-@runtime_checkable
-class WindowsCommandable(Protocol):
-    """定义 Windows 平台的特定命令"""
-    def get_foreground_window(self) -> tuple[int, str]: ...
-    def exec_command(self, command: str) -> tuple[int, str, str]: ...
-
-@runtime_checkable
-class Screenshotable(Protocol):
-    def __init__(self, device: 'Device'): ...
-    @property
-    def screen_size(self) -> tuple[int, int]:
-        """
-        屏幕尺寸。格式为 `(width, height)`。
-        
-        **注意**： 此属性返回的分辨率会随设备方向变化。
-        如果 `self.orientation` 为 `landscape`，则返回的分辨率是横屏下的分辨率，
-        否则返回竖屏下的分辨率。
-
-        `self.orientation` 属性默认为竖屏。如果需要自动检测，
-        调用 `self.detect_orientation()` 方法。
-        如果已知方向，也可以直接设置 `self.orientation` 属性。
-        """
-        ...
-    
-    def detect_orientation(self) -> Literal['portrait', 'landscape'] | None: ...
-    def screenshot(self) -> MatLike: ...
-
-@runtime_checkable
-class Touchable(Protocol):
-    def __init__(self, device: 'Device'): ...
-    def click(self, x: int, y: int) -> None: ...
-    def swipe(self, x1: int, y1: int, x2: int, y2: int, duration: float|None = None) -> None: ...

kotonebot/client/registration.py

@@ -1,24 +0,0 @@
-from dataclasses import dataclass
-from typing import TypeVar, Callable, Dict, Type, Any, overload, Literal, cast, TYPE_CHECKING
-
-from ..errors import KotonebotError
-from .device import Device
-if TYPE_CHECKING:
-    from .implements.adb import AdbImplConfig
-    from .implements.remote_windows import RemoteWindowsImplConfig
-    from .implements.windows import WindowsImplConfig
-    from .implements.nemu_ipc import NemuIpcImplConfig
-
-AdbBasedImpl = Literal['adb', 'adb_raw', 'uiautomator2']
-DeviceImpl = str | AdbBasedImpl | Literal['windows', 'remote_windows', 'nemu_ipc']
-
-# --- 核心类型定义 ---
-
-class ImplRegistrationError(KotonebotError):
-    """与 impl 注册相关的错误"""
-    pass
-
-@dataclass
-class ImplConfig:
-    """所有设备实现配置模型的名义上的基类，便于类型约束。"""
-    pass

kotonebot/config/__init__.py

@@ -1 +0,0 @@
-from .base_config import UserConfig

kotonebot/config/base_config.py

@@ -1,96 +0,0 @@
-import uuid
-from typing import Generic, TypeVar, Literal
-
-from pydantic import BaseModel, ConfigDict
-
-
-T = TypeVar('T')
-BackendType = Literal['custom', 'mumu12', 'leidian', 'dmm']
-DeviceRecipes = Literal['adb', 'adb_raw', 'uiautomator2', 'windows', 'remote_windows', 'nemu_ipc']
-
-class ConfigBaseModel(BaseModel):
-    model_config = ConfigDict(use_attribute_docstrings=True)
-
-class BackendConfig(ConfigBaseModel):
-    type: BackendType = 'custom'
-    """后端类型。"""
-    instance_id: str | None = None
-    """模拟器实例 ID。"""
-    adb_ip: str = '127.0.0.1'
-    """adb 连接的 ip 地址。"""
-    adb_port: int = 5555
-    """adb 连接的端口。"""
-    adb_emulator_name: str | None = None
-    """
-    adb 连接的模拟器名，用于 自动启动模拟器 功能。
-    
-    雷电模拟器需要设置正确的模拟器名，否则 自动启动模拟器 功能将无法正常工作。
-    其他功能不受影响。
-    """
-    screenshot_impl: DeviceRecipes = 'adb'
-    """
-    截图方法。暂时推荐使用【adb】截图方式。
-
-    如果使用 remote_windows，需要在 adb_ip 中填写远程 Windows 的 IP 地址，在 adb_port 中填写远程 Windows 的端口号。
-    """
-    check_emulator: bool = False
-    """
-    检查并启动模拟器
-
-    启动脚本的时候，如果检测到模拟器未启动，则自动启动模拟器。
-    如果模拟器已经启动，则不启动。
-    """
-    emulator_path: str | None = None
-    """模拟器 exe 文件路径"""
-    emulator_args: str = ""
-    """模拟器启动时的命令行参数"""
-    windows_window_title: str = 'gakumas'
-    """Windows 截图方式的窗口标题"""
-    windows_ahk_path: str | None = None
-    """Windows 截图方式的 AutoHotkey 可执行文件路径，为 None 时使用默认路径"""
-    mumu_background_mode: bool = False
-    """MuMu12 模拟器后台保活模式"""
-    target_screenshot_interval: float | None = None
-    """最小截图间隔，单位为秒。为 None 时不限制截图速度。"""
-
-class PushConfig(ConfigBaseModel):
-    """推送配置。"""
-
-    wx_pusher_enabled: bool = False
-    """是否启用 WxPusher 推送。"""
-    wx_pusher_app_token: str | None = None
-    """WxPusher 的 app token。"""
-    wx_pusher_uid: str | None = None
-    """WxPusher 的 uid。"""
-
-    free_image_host_key: str | None = None
-    """FreeImageHost API key。用于在推送通知时显示图片。"""
-
-class UserConfig(ConfigBaseModel, Generic[T]):
-    """用户可以自由添加、删除的配置数据。"""
-
-    name: str = 'default_config'
-    """显示名称。通常由用户输入。"""
-    id: str = uuid.uuid4().hex
-    """唯一标识符。"""
-    category: str = 'default'
-    """类别。如：'global'、'china'、'asia' 等。"""
-    description: str = ''
-    """描述。通常由用户输入。"""
-    backend: BackendConfig = BackendConfig()
-    """后端配置。"""
-    keep_screenshots: bool = False
-    """
-    是否保留截图。
-    若启用，则会保存每一张截图到 `dumps` 目录下。启用该选项有助于辅助调试。
-    """
-    options: T
-    """下游脚本储存的具体数据。"""
-
-
-class RootConfig(ConfigBaseModel, Generic[T]):
-    version: int = 5
-    """配置版本。"""
-    user_configs: list[UserConfig[T]] = []
-    """用户配置。"""
-

kotonebot/config/manager.py

@@ -1,36 +0,0 @@
-import os
-from typing import Type, Generic, TypeVar
-
-from .base_config import RootConfig, UserConfig
-
-T = TypeVar('T')
-
-def load_config(
-    config_path: str,
-    *,
-    type: Type[T],
-    use_default_if_not_found: bool = True
-) -> RootConfig[T]:
-    """
-    从指定路径读取配置文件
-
-    :param config_path: 配置文件路径
-    :param use_default_if_not_found: 如果配置文件不存在，是否使用默认配置
-    """
-    if not os.path.exists(config_path):
-        if use_default_if_not_found:
-            return RootConfig[type]()
-        else:
-            raise FileNotFoundError(f"Config file not found: {config_path}")
-    
-    with open(config_path, 'r', encoding='utf-8') as f:
-        return RootConfig[type].model_validate_json(f.read())
-
-def save_config(
-    config: RootConfig[T],
-    config_path: str,
-):
-    """将配置保存到指定路径"""
-    RootConfig[T].model_validate(config)
-    with open(config_path, 'w+', encoding='utf-8') as f:
-        f.write(config.model_dump_json(indent=4))

kotonebot/debug_entry.py

@@ -1,42 +0,0 @@
-import sys
-sys.path.append('./projects')
-import runpy
-import logging
-import argparse
-
-from kotonebot.kaa.common import BaseConfig
-
-
-def run_script(script_path: str) -> None:
-    """
-    使用 runpy 运行指定的 Python 脚本
-
-    Args:
-        script_path: Python 脚本的路径
-    """
-    logging.basicConfig(level=logging.INFO, format='[%(asctime)s] [%(levelname)s] [%(name)s] [%(funcName)s] [%(lineno)d] %(message)s')
-    # 获取模块名
-    module_name = script_path.strip('.py').lstrip('projects/').replace('\\', '/').strip('/').replace('/', '.')
-
-    print(f"正在运行脚本: {script_path}")
-    # 运行脚本
-    from kotonebot.backend.context import init_context, manual_context
-    from kotonebot.kaa.main.kaa import Kaa
-    logging.getLogger('kotonebot').setLevel(logging.DEBUG)
-    config_path = './config.json'
-    kaa_instance = Kaa(config_path)
-    init_context(config_type=BaseConfig, target_device=kaa_instance._on_create_device())
-    kaa_instance._on_after_init_context()
-    manual_context().begin()
-    runpy.run_module(module_name, run_name="__main__")
-
-def main():
-    parser = argparse.ArgumentParser(description='运行指定的 Python 脚本')
-    parser.add_argument('script_path', help='要运行的 Python 脚本路径')
-
-    args = parser.parse_args()
-    run_script(args.script_path)
-
-
-if __name__ == '__main__':
-    main()

kotonebot/errors.py

@@ -1,72 +0,0 @@
-from typing import Callable
-
-
-class KotonebotError(Exception):
-    pass
-
-class KotonebotWarning(Warning):
-    pass
-
-class UserFriendlyError(KotonebotError):
-    def __init__(
-        self,
-        message: str,
-        actions: list[tuple[int, str, Callable[[], None]]] = [],
-        *args, **kwargs
-    ) -> None:
-        super().__init__(*args, **kwargs)
-        self.message = message
-        self.actions = actions or []
-
-    @property
-    def action_buttons(self) -> list[tuple[int, str]]:
-        """
-        以 (id: int, btn_text: str) 的形式返回所有按钮定义。
-        """
-        return [(id, text) for id, text, _ in self.actions]
-    
-    def invoke(self, action_id: int):
-        """
-        执行指定 ID 的 action。
-        """
-        for id, _, func in self.actions:
-            if id == action_id:
-                func()
-                break
-        else:
-            raise ValueError(f'Action with id {action_id} not found.')
-
-class UnrecoverableError(KotonebotError):
-    pass
-
-class GameUpdateNeededError(UnrecoverableError):
-    def __init__(self):
-        super().__init__(
-            'Game update required. '
-            'Please go to Play Store and update the game manually.'
-        )
-
-class ResourceFileMissingError(KotonebotError):
-    def __init__(self, file_path: str, description: str):
-        self.file_path = file_path
-        self.description = description
-        super().__init__(f'Resource file ({description}) "{file_path}" is missing.')
-
-class TaskNotFoundError(KotonebotError):
-    def __init__(self, task_id: str):
-        self.task_id = task_id
-        super().__init__(f'Task "{task_id}" not found.')
-
-class UnscalableResolutionError(KotonebotError):
-    def __init__(self, target_resolution: tuple[int, int], screen_size: tuple[int, int]):
-        self.target_resolution = target_resolution
-        self.screen_size = screen_size
-        super().__init__(f'Cannot scale to target resolution {target_resolution}. '
-                         f'Screen size: {screen_size}')
-
-class ContextNotInitializedError(KotonebotError):
-    def __init__(self, msg: str = 'Context not initialized'):
-        super().__init__(msg)
-
-class StopCurrentTask(KotonebotError):
-    pass