ksaa 2025.8.23.1__py3-none-any.whl → 2025.9b2__py3-none-any.whl

kotonebot/client/host/leidian_host.py

@@ -1,202 +0,0 @@
-import os
-import subprocess
-from typing import Literal
-from functools import lru_cache
-from typing_extensions import override
-
-from kotonebot import logging
-from kotonebot.client import Device
-from kotonebot.util import Countdown, Interval
-from .protocol import HostProtocol, Instance, copy_type, AdbHostConfig
-from .adb_common import AdbRecipes, CommonAdbCreateDeviceMixin
-
-logger = logging.getLogger(__name__)
-LeidianRecipes = AdbRecipes
-
-if os.name == 'nt':
-    from ...interop.win.reg import read_reg
-else:
-    def read_reg(key, subkey, name, *, default=None, **kwargs):
-        """Stub for read_reg on non-Windows platforms."""
-        return default
-
-class LeidianInstance(CommonAdbCreateDeviceMixin, Instance[AdbHostConfig]):
-    @copy_type(Instance.__init__)
-    def __init__(self, *args, **kwargs):
-        super().__init__(*args, **kwargs)
-        self._args = args
-        self.index: int | None = None
-        self.is_running: bool = False
-
-    @override
-    def refresh(self):
-        ins = LeidianHost.query(id=self.id)
-        assert isinstance(ins, LeidianInstance), f'Expected LeidianInstance, got {type(ins)}'
-        if ins is not None:
-            self.adb_port = ins.adb_port
-            self.adb_ip = ins.adb_ip
-            self.adb_name = ins.adb_name
-            self.is_running = ins.is_running
-            logger.debug('Refreshed Leidian instance: %s', repr(ins))
-
-    @override
-    def start(self):
-        if self.running():
-            logger.warning('Instance is already running.')
-            return
-        logger.info('Starting Leidian instance %s', self)
-        LeidianHost._invoke_manager(['launch', '--index', str(self.index)])
-        self.refresh()
-
-    @override
-    def stop(self):
-        if not self.running():
-            logger.warning('Instance is not running.')
-            return
-        logger.info('Stopping Leidian instance id=%s name=%s...', self.id, self.name)
-        LeidianHost._invoke_manager(['quit', '--index', str(self.index)])
-        self.refresh()
-
-    @override
-    def wait_available(self, timeout: float = 180):
-        cd = Countdown(timeout)
-        it = Interval(5)
-        while not cd.expired() and not self.running():
-            it.wait()
-            self.refresh()
-        if not self.running():
-            raise TimeoutError(f'Leidian instance "{self.name}" is not available.')
-
-    @override
-    def running(self) -> bool:
-        return self.is_running
-
-    @override
-    def create_device(self, impl: LeidianRecipes, host_config: AdbHostConfig) -> Device:
-        """为雷电模拟器实例创建 Device。"""
-        if self.adb_port is None:
-            raise ValueError("ADB port is not set and is required.")
-
-        return super().create_device(impl, host_config)
-
-class LeidianHost(HostProtocol[LeidianRecipes]):
-    @staticmethod
-    @lru_cache(maxsize=1)
-    def _read_install_path() -> str | None:
-        """
-        从注册表中读取雷电模拟器的安装路径。
-
-        :return: 安装路径，如果未找到则返回 None。
-        """
-        if os.name != 'nt':
-            return None
-
-        try:
-            icon_path = read_reg('HKCU', r'Software\leidian\LDPlayer9', 'DisplayIcon', default=None)
-            if icon_path and isinstance(icon_path, str):
-                icon_path = icon_path.replace('"', '')
-                path = os.path.dirname(icon_path)
-                logger.debug('Leidian installation path (from DisplayIcon): %s', path)
-                return path
-            install_dir = read_reg('HKCU', r'Software\leidian\LDPlayer9', 'InstallDir', default=None)
-            if install_dir and isinstance(install_dir, str):
-                install_dir = install_dir.replace('"', '')
-                logger.debug('Leidian installation path (from InstallDir): %s', install_dir)
-                return install_dir
-        except Exception as e:
-            logger.error(f'Failed to read Leidian installation path from registry: {e}')
-
-        return None
-
-    @staticmethod
-    def _invoke_manager(args: list[str]) -> str:
-        """
-        调用 ldconsole.exe。
-        
-        参考文档：https://www.ldmnq.com/forum/30.html，以及命令行帮助。
-        另外还有个 ld.exe，封装了 adb.exe，可以直接执行 adb 命令。（https://www.ldmnq.com/forum/9178.html）
-
-        :param args: 命令行参数列表。
-        :return: 命令执行的输出。
-        """
-        install_path = LeidianHost._read_install_path()
-        if install_path is None:
-            raise RuntimeError('Leidian is not installed.')
-        manager_path = os.path.join(install_path, 'ldconsole.exe')
-        logger.debug('ldconsole execute: %s', repr(args))
-        output = subprocess.run(
-            [manager_path] + args,
-            capture_output=True,
-            text=True,
-            # encoding='utf-8', # 居然不是 utf-8 编码
-            # https://stackoverflow.com/questions/6011235/run-a-program-from-python-and-have-it-continue-to-run-after-the-script-is-kille
-            creationflags=subprocess.DETACHED_PROCESS | subprocess.CREATE_NEW_PROCESS_GROUP
-        )
-        if output.returncode != 0:
-            raise RuntimeError(f'Failed to invoke ldconsole: {output.stderr}')
-        return output.stdout
-
-    @staticmethod
-    def installed() -> bool:
-        return LeidianHost._read_install_path() is not None
-
-    @staticmethod
-    def list() -> list[Instance]:
-        output = LeidianHost._invoke_manager(['list2'])
-        instances = []
-
-        # 解析 list2 命令的输出
-        # 格式: 索引,标题,顶层窗口句柄,绑定窗口句柄,是否进入android,进程PID,VBox进程PID
-        for line in output.strip().split('\n'):
-            if not line:
-                continue
-
-            parts = line.split(',')
-            if len(parts) < 5:
-                logger.warning(f'Invalid list2 output line: {line}')
-                continue
-
-            index = parts[0]
-            name = parts[1]
-            is_android_started = parts[4] == '1'
-            # 端口号规则 https://help.ldmnq.com/docs/LD9adbserver#a67730c2e7e2e0400d40bcab37d0e0cf
-            adb_port = 5554 + (int(index) * 2)
-
-            instance = LeidianInstance(
-                id=index,
-                name=name,
-                adb_port=adb_port,
-                adb_ip='127.0.0.1',
-                adb_name=f'emulator-{adb_port}'
-            )
-            instance.index = int(index)
-            instance.is_running = is_android_started
-            logger.debug('Leidian instance: %s', repr(instance))
-            instances.append(instance)
-
-        return instances
-
-    @staticmethod
-    def query(*, id: str) -> Instance | None:
-        instances = LeidianHost.list()
-        for instance in instances:
-            if instance.id == id:
-                return instance
-        return None
-
-    @staticmethod
-    def recipes() -> 'list[LeidianRecipes]':
-        return ['adb', 'adb_raw', 'uiautomator2']
-
-if __name__ == '__main__':
-    logging.basicConfig(level=logging.DEBUG, format='[%(asctime)s] [%(levelname)s] [%(name)s] [%(funcName)s] [%(lineno)d] %(message)s')
-    print(LeidianHost._read_install_path())
-    print(LeidianHost.installed())
-    print(LeidianHost.list())
-    print(ins:=LeidianHost.query(id='0'))
-    assert isinstance(ins, LeidianInstance)
-    ins.start()
-    ins.wait_available()
-    print('status', ins.running(), ins.adb_port, ins.adb_ip)
-    # ins.stop()
-    # print('status', ins.running(), ins.adb_port, ins.adb_ip)

kotonebot/client/host/mumu12_host.py

@@ -1,245 +0,0 @@
-from dataclasses import dataclass
-import os
-import json
-import subprocess
-from functools import lru_cache
-from typing import Any, Literal, overload
-from typing_extensions import override
-
-from kotonebot import logging
-from kotonebot.client import Device
-from kotonebot.client.device import AndroidDevice
-from kotonebot.client.implements.adb import AdbImpl
-from kotonebot.client.implements.nemu_ipc import NemuIpcImpl, NemuIpcImplConfig
-from kotonebot.util import Countdown, Interval
-from .protocol import HostProtocol, Instance, copy_type, AdbHostConfig
-from .adb_common import AdbRecipes, CommonAdbCreateDeviceMixin, connect_adb, is_adb_recipe
-
-if os.name == 'nt':
-    from ...interop.win.reg import read_reg
-else:
-    def read_reg(key, subkey, name, *, default=None, **kwargs):
-        """Stub for read_reg on non-Windows platforms."""
-        return default
-
-logger = logging.getLogger(__name__)
-MuMu12Recipes = AdbRecipes | Literal['nemu_ipc']
-
-@dataclass
-class MuMu12HostConfig(AdbHostConfig):
-    """nemu_ipc 能力的配置模型。"""
-    display_id: int | None = 0
-    """目标显示器 ID，默认为 0（主显示器）。若为 None 且设置了 target_package_name，则自动获取对应的 display_id。"""
-    target_package_name: str | None = None
-    """目标应用包名，用于自动获取 display_id。"""
-    app_index: int = 0
-    """多开应用索引，传给 get_display_id 方法。"""
-
-
-class Mumu12Instance(CommonAdbCreateDeviceMixin, Instance[MuMu12HostConfig]):
-    @copy_type(Instance.__init__)
-    def __init__(self, *args, **kwargs):
-        super().__init__(*args, **kwargs)
-        self._args = args
-        self.index: int | None = None
-        self.is_android_started: bool = False
-    
-    @override
-    def refresh(self):
-        ins = Mumu12Host.query(id=self.id)
-        assert isinstance(ins, Mumu12Instance), f'Expected Mumu12Instance, got {type(ins)}'
-        if ins is not None:
-            self.adb_port = ins.adb_port
-            self.adb_ip = ins.adb_ip
-            self.adb_name = ins.adb_name
-            self.is_android_started = ins.is_android_started
-            logger.debug('Refreshed MuMu12 instance: %s', repr(ins))
-    
-    @override
-    def start(self):
-        if self.running():
-            logger.warning('Instance is already running.')
-            return
-        logger.info('Starting MuMu12 instance %s', self)
-        Mumu12Host._invoke_manager(['control', '-v', self.id, 'launch'])
-        self.refresh()
-    
-    @override
-    def stop(self):
-        if not self.running():
-            logger.warning('Instance is not running.')
-            return
-        logger.info('Stopping MuMu12 instance id=%s name=%s...', self.id, self.name)
-        Mumu12Host._invoke_manager(['control', '-v', self.id, 'shutdown'])
-        self.refresh()
-    
-    @override
-    def wait_available(self, timeout: float = 180):
-        cd = Countdown(timeout)
-        it = Interval(5)
-        while not cd.expired() and not self.running():
-            it.wait()
-            self.refresh()
-        if not self.running():
-            raise TimeoutError(f'MuMu12 instance "{self.name}" is not available.')
-    
-    @override
-    def running(self) -> bool:
-        return self.is_android_started
-
-    @overload
-    def create_device(self, recipe: Literal['nemu_ipc'], host_config: MuMu12HostConfig) -> Device: ...
-    @overload
-    def create_device(self, recipe: AdbRecipes, host_config: AdbHostConfig) -> Device: ...
-
-    @override
-    def create_device(self, recipe: MuMu12Recipes, host_config: MuMu12HostConfig | AdbHostConfig) -> Device:
-        """为MuMu12模拟器实例创建 Device。"""
-        if self.adb_port is None:
-            raise ValueError("ADB port is not set and is required.")
-
-        if recipe == 'nemu_ipc' and isinstance(host_config, MuMu12HostConfig):
-            # NemuImpl
-            nemu_path = Mumu12Host._read_install_path()
-            if not nemu_path:
-                raise RuntimeError("无法找到 MuMu12 的安装路径。")
-            nemu_config = NemuIpcImplConfig(
-                nemu_folder=nemu_path,
-                instance_id=int(self.id),
-                display_id=host_config.display_id,
-                target_package_name=host_config.target_package_name,
-                app_index=host_config.app_index
-            )
-            nemu_impl = NemuIpcImpl(nemu_config)
-            # AdbImpl
-            adb_impl = AdbImpl(connect_adb(
-                self.adb_ip,
-                self.adb_port,
-                timeout=host_config.timeout,
-                device_serial=self.adb_name
-            ))
-            device = AndroidDevice()
-            device._screenshot = nemu_impl
-            device._touch = nemu_impl
-            device.commands = adb_impl
-
-            return device
-        elif isinstance(host_config, AdbHostConfig) and is_adb_recipe(recipe):
-            return super().create_device(recipe, host_config)
-        else:
-            raise ValueError(f'Unknown recipe: {recipe}')
-
-class Mumu12Host(HostProtocol[MuMu12Recipes]):
-    @staticmethod
-    @lru_cache(maxsize=1)
-    def _read_install_path() -> str | None:
-        r"""
-        从注册表中读取 MuMu Player 12 的安装路径。
-
-        返回的路径为根目录。如 `F:\Apps\Netease\MuMuPlayer-12.0`。
-
-        :return: 若找到，则返回安装路径；否则返回 None。
-        """
-        if os.name != 'nt':
-            return None
-
-        uninstall_subkeys = [
-            r'SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall\MuMuPlayer-12.0',
-            # TODO: 支持国际版 MuMu
-            # r'SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall\MuMuPlayerGlobal-12.0'
-        ]
-
-        for subkey in uninstall_subkeys:
-            icon_path = read_reg('HKLM', subkey, 'DisplayIcon', default=None)
-            if icon_path and isinstance(icon_path, str):
-                icon_path = icon_path.replace('"', '')
-                path = os.path.dirname(icon_path)
-                logger.debug('MuMu Player 12 installation path: %s', path)
-                # 返回根目录（去掉 shell 子目录）
-                if os.path.basename(path).lower() == 'shell':
-                    path = os.path.dirname(path)
-                return path
-        return None
-
-    @staticmethod
-    def _invoke_manager(args: list[str]) -> str:
-        """
-        调用 MuMuManager.exe。
-        
-        :param args: 命令行参数列表。
-        :return: 命令执行的输出。
-        """
-        install_path = Mumu12Host._read_install_path()
-        if install_path is None:
-            raise RuntimeError('MuMu Player 12 is not installed.')
-        manager_path = os.path.join(install_path, 'shell', 'MuMuManager.exe')
-        logger.debug('MuMuManager execute: %s', repr(args))
-        output = subprocess.run(
-            [manager_path] + args,
-            capture_output=True,
-            text=True,
-            encoding='utf-8',
-            # https://stackoverflow.com/questions/6011235/run-a-program-from-python-and-have-it-continue-to-run-after-the-script-is-kille
-            creationflags=subprocess.DETACHED_PROCESS | subprocess.CREATE_NEW_PROCESS_GROUP
-        )
-        if output.returncode != 0:
-            # raise RuntimeError(f'Failed to invoke MuMuManager: {output.stderr}')
-            logger.warning('Failed to invoke MuMuManager: %s', output.stderr)
-        return output.stdout
-
-    @staticmethod
-    def installed() -> bool:
-        return Mumu12Host._read_install_path() is not None
-
-    @staticmethod
-    def list() -> list[Instance]:
-        output = Mumu12Host._invoke_manager(['info', '-v', 'all'])
-        logger.debug('MuMuManager.exe output: %s', output)
-        
-        try:
-            data: dict[str, dict[str, Any]] = json.loads(output)
-            if 'name' in data.keys():
-                # 这里有个坑：
-                # 如果只有一个实例，返回的 JSON 结构是单个对象而不是数组
-                data = { '0': data }
-            instances = []
-            for index, instance_data in data.items():
-                instance = Mumu12Instance(
-                    id=index,
-                    name=instance_data['name'],
-                    adb_port=instance_data.get('adb_port'),  
-                    adb_ip=instance_data.get('adb_host_ip', '127.0.0.1'), 
-                    adb_name=None
-                )
-                instance.index = int(index)
-                instance.is_android_started = instance_data.get('is_android_started', False)
-                logger.debug('Mumu12 instance: %s', repr(instance))
-                instances.append(instance)
-            return instances
-        except json.JSONDecodeError as e:
-            raise RuntimeError(f'Failed to parse output: {e}')
-    
-    @staticmethod
-    def query(*, id: str) -> Instance | None:
-        instances = Mumu12Host.list()
-        for instance in instances:
-            if instance.id == id:
-                return instance
-        return None
-
-    @staticmethod
-    def recipes() -> 'list[MuMu12Recipes]':
-        return ['adb', 'adb_raw', 'uiautomator2', 'nemu_ipc']
-    
-if __name__ == '__main__':
-    logging.basicConfig(level=logging.DEBUG, format='[%(asctime)s] [%(levelname)s] [%(name)s] [%(funcName)s] [%(lineno)d] %(message)s')
-    print(Mumu12Host._read_install_path())
-    print(Mumu12Host.installed())
-    print(Mumu12Host.list())
-    print(ins:=Mumu12Host.query(id='2'))
-    assert isinstance(ins, Mumu12Instance)
-    ins.start()
-    ins.wait_available()
-    print('status', ins.running(), ins.adb_port, ins.adb_ip)
-    ins.stop()
-    print('status', ins.running(), ins.adb_port, ins.adb_ip)

kotonebot/client/host/protocol.py

@@ -1,213 +0,0 @@
-import time
-import socket
-from abc import ABC, abstractmethod
-from typing import Callable, TypeVar, Protocol, Any, Generic
-from dataclasses import dataclass
-
-from adbutils import adb, AdbTimeout, AdbError
-from adbutils._device import AdbDevice
-
-from kotonebot import logging
-from kotonebot.client import Device, DeviceImpl
-
-from kotonebot.util import Countdown, Interval
-
-logger = logging.getLogger(__name__)
-# https://github.com/python/typing/issues/769#issuecomment-903760354
-_T = TypeVar("_T")
-def copy_type(_: _T) -> Callable[[Any], _T]:
-    return lambda x: x
-
-# --- 定义专用的 HostConfig 数据类 ---
-@dataclass
-class AdbHostConfig:
-    """由外部为基于 ADB 的主机提供的配置。"""
-    timeout: float = 180
-
-@dataclass
-class WindowsHostConfig:
-    """由外部为 Windows 实现提供配置。"""
-    window_title: str
-    ahk_exe_path: str
-
-@dataclass
-class RemoteWindowsHostConfig:
-    """由外部为远程 Windows 实现提供配置。"""
-    windows_host_config: WindowsHostConfig
-    host: str
-    port: int
-
-# --- 使用泛型改造 Instance 协议 ---
-T_HostConfig = TypeVar("T_HostConfig")
-
-def tcp_ping(host: str, port: int, timeout: float = 1.0) -> bool:
-    """
-    通过 TCP ping 检查主机和端口是否可达。
-    
-    :param host: 主机名或 IP 地址
-    :param port: 端口号
-    :param timeout: 超时时间（秒）
-    :return: 如果主机和端口可达，则返回 True，否则返回 False
-    """
-    logger.debug('TCP ping %s:%d...', host, port)
-    try:
-        with socket.create_connection((host, port), timeout):
-            logger.debug('TCP ping %s:%d success.', host, port)
-            return True
-    except (socket.timeout, ConnectionRefusedError, OSError):
-        logger.debug('TCP ping %s:%d failed.', host, port)
-        return False
-
-
-class Instance(Generic[T_HostConfig], ABC):
-    """
-    代表一个可运行环境的实例（如一个模拟器）。
-    使用泛型来约束 create_device 方法的配置参数类型。
-    """
-    def __init__(self,
-        id: str,
-        name: str,
-        adb_port: int | None = None,
-        adb_ip: str = '127.0.0.1',
-        adb_name: str | None = None
-    ):
-        self.id: str = id
-        self.name: str = name
-        self.adb_port: int | None = adb_port
-        self.adb_ip: str = adb_ip
-        self.adb_name: str | None = adb_name
-
-    def require_adb_port(self) -> int:
-        if self.adb_port is None:
-            raise ValueError("ADB port is not set and is required.")
-        return self.adb_port
-
-    @abstractmethod
-    def refresh(self):
-        """
-        刷新实例信息，如 ADB 端口号等。
-        """
-        raise NotImplementedError()
-
-    @abstractmethod
-    def start(self):
-        """
-        启动模拟器实例。
-        """
-        raise NotImplementedError()
-
-    @abstractmethod
-    def stop(self):
-        """
-        停止模拟器实例。
-        """
-        raise NotImplementedError()
-
-    @abstractmethod
-    def running(self) -> bool:
-        raise NotImplementedError()
-
-    @abstractmethod
-    def create_device(self, impl: DeviceImpl, host_config: T_HostConfig) -> Device:
-        """
-        根据实现名称和类型化的主机配置创建设备。
-
-        :param impl: 设备实现的名称。
-        :param host_config: 一个类型化的数据对象，包含创建所需的所有外部配置。
-        :return: 配置好的 Device 实例。
-        """
-        raise NotImplementedError()
-
-    def wait_available(self, timeout: float = 180):
-        logger.info('Starting to wait for emulator %s(127.0.0.1:%d) to be available...', self.name, self.adb_port)
-        state = 0
-        port = self.require_adb_port() 
-        emulator_name = self.adb_name
-        cd = Countdown(timeout)
-        it = Interval(1)
-        d: AdbDevice | None = None
-        while True:
-            if cd.expired():
-                raise TimeoutError(f'Emulator "{self.name}" is not available.')
-            it.wait()
-            try:
-                match state:
-                    case 0:
-                        logger.debug('Ping emulator %s(127.0.0.1:%d)...', self.name, port)
-                        if tcp_ping('127.0.0.1', port):
-                            logger.debug('Ping emulator %s(127.0.0.1:%d) success.', self.name, port)
-                            state = 1
-                    case 1:
-                        logger.debug('Connecting to emulator %s(127.0.0.1:%d)...', self.name, port)
-                        if adb.connect(f'127.0.0.1:{port}', timeout=0.5):
-                            logger.debug('Connect to emulator %s(127.0.0.1:%d) success.', self.name, port)
-                            state = 2
-                    case 2:
-                        logger.debug('Getting device list...')
-                        if devices := adb.device_list():
-                            logger.debug('Get device list success. devices=%s', devices)
-                            # emulator_name 用于适配雷电模拟器
-                            # 雷电模拟器启动后，在上方的列表中并不会出现 127.0.0.1:5555，而是 emulator-5554
-                            d = next(
-                                (d for d in devices if d.serial == f'127.0.0.1:{port}' or d.serial == emulator_name),
-                                None
-                            )
-                            if d:
-                                logger.debug('Get target device success. d=%s', d)
-                                state = 3
-                    case 3:
-                        if not d:
-                            logger.warning('Device is None.')
-                            state = 0
-                            continue
-                        logger.debug('Waiting for device state...')
-                        if d.get_state() == 'device':
-                            logger.debug('Device state ready. state=%s', d.get_state())
-                            state = 4
-                    case 4:
-                        logger.debug('Waiting for device boot completed...')
-                        if not d:
-                            logger.warning('Device is None.')
-                            state = 0
-                            continue
-                        ret = d.shell('getprop sys.boot_completed')
-                        if isinstance(ret, str) and ret.strip() == '1':
-                            logger.debug('Device boot completed. ret=%s', ret)
-                            state = 5
-                    case 5:
-                        if not d:
-                            logger.warning('Device is None.')
-                            state = 0
-                            continue
-                        app = d.app_current()
-                        logger.debug('Waiting for launcher... (current=%s)', app)
-                        if app and 'launcher' in app.package:
-                            logger.info('Emulator %s(127.0.0.1:%d) now is available.', self.name, self.adb_port)
-                            state = 6
-                    case 6:
-                        break
-            except (AdbError, AdbTimeout):
-                state = 1
-                continue
-        time.sleep(1)
-        logger.info('Emulator %s(127.0.0.1:%d) now is available.', self.name, self.adb_port)
-
-    def __repr__(self) -> str:
-        return f'{self.__class__.__name__}(name="{self.name}", id="{self.id}", adb="{self.adb_ip}:{self.adb_port}"({self.adb_name}))'
-
-Recipe = TypeVar('Recipe', bound=str)
-class HostProtocol(Generic[Recipe], Protocol):
-    @staticmethod
-    def installed() -> bool: ...
-    
-    @staticmethod
-    def list() -> list[Instance]: ...
-    
-    @staticmethod
-    def query(*, id: str) -> Instance | None: ...
-
-    @staticmethod
-    def recipes() -> 'list[Recipe]': ...
-
-if __name__ == '__main__':
-    pass