ksaa 2025.9.post2__py3-none-any.whl → 2025.11__py3-none-any.whl

kaa/application/core/misc_core.py

@@ -1,11 +1,14 @@
 import os
 import sys
 
-from kotonebot.interop.win.shortcut import create_shortcut
+from kotonebot.util import is_windows, require_windows
+if is_windows():
+    from kotonebot.interop.win.shortcut import create_shortcut
 from kaa.errors import LauncherNotFoundError
 
 
 def create_desktop_shortcut(start_immediately: bool):
+    require_windows('create_desktop_shortcut')
     exe_path = os.path.abspath('./kaa.exe')
     if not os.path.exists(exe_path):
         raise LauncherNotFoundError()

kaa/application/services/config_service.py

@@ -0,0 +1,101 @@
+import logging
+from typing import Any
+
+from kaa.config.schema import BaseConfig
+from kotonebot.config.base_config import BackendConfig, UserConfig
+from kotonebot.config.manager import load_config, save_config, RootConfig
+
+logger = logging.getLogger(__name__)
+
+
+class ConfigValidationError(ValueError):
+    """Custom exception for configuration validation errors."""
+    pass
+
+
+class ConfigService:
+    """
+    Manages application configuration, including loading, saving, and validation.
+    """
+
+    def __init__(self, config_path: str = "config.json"):
+        self.config_path = config_path
+        self._root_config: RootConfig[BaseConfig] | None = None
+        self._current_user_config: UserConfig[BaseConfig] | None = None
+        self.load()
+
+    def load(self):
+        """
+        Loads the configuration from the specified config file.
+        It populates the root configuration and sets the current user config.
+        """
+        self._root_config = load_config(self.config_path, type=BaseConfig)
+        if self._root_config and self._root_config.user_configs:
+            self._current_user_config = self._root_config.user_configs[0]
+        else:
+            raise FileNotFoundError(f"No user configuration found in {self.config_path}")
+
+    def reload(self):
+        """Reloads configuration from disk."""
+        self.load()
+        logger.info("Configuration reloaded from disk.")
+
+    def get_root_config(self) -> RootConfig[BaseConfig]:
+        """Returns the entire root configuration object."""
+        if not self._root_config:
+            raise RuntimeError("Root config not loaded.")
+        return self._root_config
+
+    def get_current_user_config(self) -> UserConfig[BaseConfig]:
+        """Returns the currently active user configuration."""
+        if not self._current_user_config:
+            raise RuntimeError("User config not loaded.")
+        return self._current_user_config
+
+    def get_options(self) -> BaseConfig:
+        """Returns the 'options' part of the current user configuration."""
+        if not self._current_user_config:
+            raise RuntimeError("User config not loaded.")
+        return self._current_user_config.options
+
+    def save(self):
+        """
+        Validates and saves the current configuration state to disk.
+        """
+        if not self._root_config or not self._current_user_config:
+            raise RuntimeError("Config not loaded, cannot save.")
+
+        self._validate(self._current_user_config.backend, self._current_user_config.options)
+        save_config(self._root_config, self.config_path)
+        logger.info("Configuration saved successfully to %s", self.config_path)
+
+    def _validate(self, backend_config: BackendConfig, options: BaseConfig):
+        """
+        Performs validation checks on the configuration.
+        Raises ConfigValidationError if any check fails.
+        """
+        # Rule 1: Validate screenshot method against the backend type
+        valid_screenshot_methods = {
+            'mumu12': ['adb', 'adb_raw', 'uiautomator2', 'nemu_ipc'],
+            'mumu12v5': ['adb', 'adb_raw', 'uiautomator2', 'nemu_ipc'],
+            'leidian': ['adb', 'adb_raw', 'uiautomator2'],
+            'custom': ['adb', 'adb_raw', 'uiautomator2'],
+            'dmm': ['remote_windows', 'windows']
+        }
+        if backend_config.screenshot_impl not in valid_screenshot_methods.get(backend_config.type, []):
+            raise ConfigValidationError(
+                f"截图方法 '{backend_config.screenshot_impl}' "
+                f"不适用于当前选择的模拟器类型 '{backend_config.type}'。"
+            )
+
+        # Rule 2: Ensure a produce solution is selected if produce is enabled
+        if options.produce.enabled and not options.produce.selected_solution_id:
+            raise ConfigValidationError("启用培育时，必须选择培育方案。")
+
+        # Rule 3: Ensure item lists are not empty if purchasing is enabled
+        if options.purchase.ap_enabled and not options.purchase.ap_items:
+            raise ConfigValidationError("启用AP购买时，AP商店购买物品不能为空。")
+
+        if options.purchase.money_enabled and not options.purchase.money_items:
+            raise ConfigValidationError("启用金币购买时，金币商店购买物品不能为空。")
+

kaa/application/services/feedback_service.py

@@ -0,0 +1,121 @@
+import logging
+import os
+import re
+import zipfile
+from datetime import datetime, timedelta
+from typing import Optional, Callable, Dict, Any
+
+import cv2
+from pydantic import BaseModel
+
+from kaa.errors import ReportCreationError, UploadError
+
+logger = logging.getLogger(__name__)
+
+
+class BugReportResult(BaseModel):
+    """错误报告创建结果的模型"""
+    file_path: str
+    upload_url: Optional[str] = None
+    message: str
+
+
+def _sanitize_filename(s: str) -> str:
+    """过滤掉文件名中的非法字符"""
+    return re.sub(r'[\\/:*?"<>|]', '_', s)
+
+
+class FeedbackService:
+    """处理反馈和错误报告的逻辑"""
+
+    def report(self, title: str, description: str, version: str, upload: bool, on_progress: Optional[Callable[[Dict[str, Any]], None]] = None) -> BugReportResult:
+        """
+        创建并可能上传一个错误报告。
+
+        :param title: 报告标题。
+        :param description: 报告描述。
+        :param version: 当前版本。
+        :param upload: 是否上传报告。
+        :param on_progress: 进度回调函数，用于实时回报进度。
+        :return: 一个 BugReportResult 对象。
+        :raises ReportCreationError: 如果报告创建失败。
+        :raises UploadError: 如果报告上传失败。
+        """
+        from kotonebot import device
+        from kotonebot.backend.context import ContextStackVars
+        
+        total_steps = 6 if upload else 5
+        def _progress(data: Dict[str, Any]):
+            if on_progress:
+                on_progress(data)
+
+        os.makedirs('logs', exist_ok=True)
+        os.makedirs('reports', exist_ok=True)
+
+        safe_title = _sanitize_filename(title)[:30] or "无标题"
+        timestamp = datetime.now().strftime("%y-%m-%d-%H-%M-%S")
+        path = f'./reports/bug_{timestamp}_{safe_title}.zip'
+        
+        try:
+            with zipfile.ZipFile(path, 'w', zipfile.ZIP_DEFLATED, compresslevel=9) as zipf:
+                _progress({'type': 'packing', 'item': '描述文件', 'step': 1, 'total_steps': total_steps})
+                description_content = f"标题：{title}\n类型：bug\n内容：\n{description}"
+                zipf.writestr('description.txt', description_content.encode('utf-8'))
+
+                _progress({'type': 'packing', 'item': '上次截图', 'step': 2, 'total_steps': total_steps})
+                try:
+                    stack = ContextStackVars.current()
+                    if stack and stack._screenshot is not None:
+                        img = cv2.imencode('.png', stack._screenshot)[1].tobytes()
+                        zipf.writestr('last_screenshot.png', img)
+                except Exception as e:
+                    logger.warning(f"保存上次截图失败: {e}")
+
+                _progress({'type': 'packing', 'item': '当前截图', 'step': 3, 'total_steps': total_steps})
+                try:
+                    screenshot = device.screenshot()
+                    img = cv2.imencode('.png', screenshot)[1].tobytes()
+                    zipf.writestr('current_screenshot.png', img)
+                except Exception as e:
+                    logger.warning(f"保存当前截图失败: {e}")
+
+                _progress({'type': 'packing', 'item': '配置文件', 'step': 4, 'total_steps': total_steps})
+                if os.path.exists('config.json'):
+                    zipf.write('config.json')
+
+                _progress({'type': 'packing', 'item': '日志', 'step': 5, 'total_steps': total_steps})
+                if os.path.exists('logs'):
+                    for root, _, files in os.walk('logs'):
+                        for file in files:
+                            file_path = os.path.join(root, file)
+                            arcname = os.path.join('logs', os.path.relpath(file_path, 'logs'))
+                            zipf.write(file_path, arcname)
+                
+                zipf.writestr('version.txt', version)
+        except Exception as e:
+            raise ReportCreationError(str(e)) from e
+
+        file_path = os.path.abspath(path)
+
+        if not upload:
+            message = f"报告已保存至 {file_path}"
+            _progress({'type': 'done', 'file_path': file_path, 'step': 5, 'total_steps': total_steps})
+            return BugReportResult(file_path=file_path, message=message)
+
+        # 上传报告
+        from kotonebot.ui.file_host.sensio import upload as upload_file
+        _progress({'type': 'uploading', 'item': '报告', 'step': 6, 'total_steps': total_steps})
+        try:
+            url = upload_file(file_path)
+        except Exception as e:
+            raise UploadError(str(e)) from e
+
+        expire_time = datetime.now() + timedelta(days=7)
+        final_msg = (
+            f"报告导出成功：{url}\n\n"
+            f"此链接将于 {expire_time.strftime('%Y-%m-%d %H:%M:%S')}（7 天后）过期\n\n"
+            '**复制以上文本并发送至 QQ 群、Github issue、B站私信等**'
+        )
+        _progress({'type': 'done', 'url': url, 'step': 6, 'total_steps': total_steps})
+        return BugReportResult(file_path=file_path, upload_url=url, message=final_msg)
+

kaa/application/services/produce_solution_service.py

@@ -0,0 +1,83 @@
+import logging
+from typing import List
+
+from kaa.config.produce import ProduceSolution, ProduceSolutionManager, ProduceData
+
+logger = logging.getLogger(__name__)
+
+
+class ProduceSolutionService:
+    """
+    Service layer for managing produce solutions.
+    This service acts as a wrapper around ProduceSolutionManager,
+    decoupling the UI/facade from the direct file system operations.
+    """
+
+    def __init__(self):
+        self._manager = ProduceSolutionManager()
+
+    def list_solutions(self) -> List[ProduceSolution]:
+        """
+        Retrieves a list of all available produce solutions.
+
+        :return: A list of ProduceSolution objects.
+        """
+        return self._manager.list()
+
+    def get_solution(self, solution_id: str) -> ProduceSolution:
+        """
+        Retrieves a single produce solution by its ID.
+
+        :param solution_id: The ID of the solution to retrieve.
+        :return: The ProduceSolution object.
+        :raises ProduceSolutionNotFoundError: If no solution with the given ID is found.
+        """
+        return self._manager.read(solution_id)
+
+    def create_solution(self, name: str = "新培育方案") -> ProduceSolution:
+        """
+        Creates a new, empty produce solution with a unique ID and saves it.
+
+        :param name: The name for the new solution.
+        :return: The newly created ProduceSolution object.
+        """
+        new_solution = self._manager.new(name)
+        self._manager.save(new_solution.id, new_solution)
+        logger.info(f"Created new produce solution '{name}' with ID {new_solution.id}")
+        return new_solution
+
+    def delete_solution(self, solution_id: str) -> None:
+        """
+        Deletes a produce solution by its ID.
+
+        :param solution_id: The ID of the solution to delete.
+        """
+        self._manager.delete(solution_id)
+        logger.info(f"Deleted produce solution with ID {solution_id}")
+
+    def save_solution(self, solution: ProduceSolution) -> None:
+        """
+        Saves a ProduceSolution object to the filesystem.
+        This can be used for both updating existing solutions and saving new ones.
+
+        :param solution: The ProduceSolution object to save.
+        """
+        self._manager.save(solution.id, solution)
+        logger.info(f"Saved produce solution '{solution.name}' with ID {solution.id}")
+
+    def update_solution_data(self, solution_id: str, name: str, description: str, data: ProduceData) -> ProduceSolution:
+        """
+        Updates an existing produce solution with new data and saves it.
+
+        :param solution_id: The ID of the solution to update.
+        :param name: The new name for the solution.
+        :param description: The new description for the solution.
+        :param data: The new ProduceData object.
+        :return: The updated ProduceSolution object.
+        """
+        solution = self.get_solution(solution_id)
+        solution.name = name
+        solution.description = description
+        solution.data = data
+        self.save_solution(solution)
+        return solution

kaa/application/services/task_service.py

@@ -0,0 +1,145 @@
+import logging
+from datetime import datetime, timedelta
+from typing import List, Tuple, Optional
+
+from kaa.main.kaa import Kaa
+from kotonebot.backend.context import task_registry, vars as context_vars
+from kotonebot.backend.bot import RunStatus
+from kotonebot.errors import ContextNotInitializedError
+
+logger = logging.getLogger(__name__)
+
+
+class TaskService:
+    """
+    Manages the lifecycle of Kaa tasks, including starting, stopping,
+    and pausing. It encapsulates the state related to task execution.
+    """
+
+    def __init__(self, kaa_instance: Kaa):
+        self._kaa = kaa_instance
+        self.run_status: RunStatus | None = None
+        self.is_running_all: bool = False
+        self.is_running_single: bool = False
+        self.is_stopping: bool = False
+        self.task_start_time: Optional[datetime] = None
+
+    def is_running(self) -> bool:
+        """Checks if any task (either all or single) is currently running."""
+        return self.is_running_all or self.is_running_single
+
+    def start_all_tasks(self) -> None:
+        """Starts all registered tasks."""
+        if self.is_running():
+            logger.warning("Cannot start all tasks, a task is already running.")
+            return
+
+        logger.info("Starting all tasks...")
+        self.is_running_all = True
+        self.is_stopping = False
+        self.task_start_time = datetime.now()
+        self.run_status = self._kaa.start_all()
+
+    def start_single_task(self, task_name: str) -> None:
+        """
+        Starts a single task by its name.
+
+        :param task_name: The name of the task to start.
+        :raises ValueError: If the task name is not found.
+        """
+        if self.is_running():
+            logger.warning(f"Cannot start task '{task_name}', a task is already running.")
+            return
+
+        task = task_registry.get(task_name)
+        if not task:
+            raise ValueError(f"Task '{task_name}' not found in task registry.")
+
+        logger.info(f"Starting single task: {task_name}")
+        self.is_running_single = True
+        self.is_stopping = False
+        self.task_start_time = datetime.now()
+        self.run_status = self._kaa.start([task])
+
+    def stop_tasks(self) -> None:
+        """Stops the currently running tasks."""
+        if not self.is_running() or self.is_stopping:
+            logger.warning("No tasks are running or tasks are already stopping.")
+            return
+
+        logger.info("Stopping tasks...")
+        self.is_stopping = True
+        try:
+            if context_vars.flow.is_paused:
+                logger.info("Tasks are paused, resuming before stopping.")
+                context_vars.flow.request_resume()
+        except ContextNotInitializedError:
+            pass # Context might not be ready if stopping very early
+
+        if self.run_status:
+            self.run_status.interrupt()
+
+    def get_task_statuses(self) -> List[Tuple[str, str]]:
+        """
+        Gets the current status of all registered tasks.
+
+        :return: A list of tuples, where each tuple contains the task name and its status.
+        """
+        if not self.run_status:
+            return [(task.name, "pending") for task in task_registry.values()]
+
+        # Reset running flags if the underlying run_status is no longer running
+        if not self.run_status.running:
+            self.is_running_all = False
+            self.is_running_single = False
+            self.is_stopping = False
+            self.task_start_time = None
+
+        status_list: List[Tuple[str, str]] = []
+        for task_status in self.run_status.tasks:
+            status_list.append((task_status.task.name, task_status.status))
+        return status_list
+
+    def toggle_pause(self) -> bool | None:
+        """
+        Toggles the pause/resume state of the running tasks.
+
+        :return: True if paused, False if resumed, None if context not initialized.
+        """
+        try:
+            if context_vars.flow.is_paused:
+                context_vars.flow.request_resume()
+                logger.info("Tasks resumed.")
+                return False
+            else:
+                context_vars.flow.request_pause()
+                logger.info("Tasks paused.")
+                return True
+        except ContextNotInitializedError:
+            logger.warning("Cannot toggle pause, context not initialized.")
+            return None
+
+    def get_pause_status(self) -> bool | None:
+        """
+        Gets the current pause status.
+
+        :return: True if paused, False if resumed, None if context not initialized.
+        """
+        try:
+            return context_vars.flow.is_paused
+        except ContextNotInitializedError:
+            return None
+
+    def get_all_task_names(self) -> List[str]:
+        """Returns a list of all registered task names."""
+        return list(task_registry.keys())
+
+    def get_task_runtime(self) -> Optional[timedelta]:
+        """
+        Gets the current task runtime.
+
+        :return: A timedelta object representing the runtime, or None if no task is running.
+        """
+        if self.task_start_time is None:
+            return None
+        return datetime.now() - self.task_start_time

kaa/application/services/update_service.py

@@ -0,0 +1,208 @@
+import logging
+import os
+import subprocess
+import sys
+import json
+import zipfile
+import threading
+import time
+from typing import Optional, List
+from pydantic import BaseModel, Field
+
+from kaa.errors import (
+    UpdateFetchListError, CompatibilityError, UpdateInstallError
+)
+
+logger = logging.getLogger(__name__)
+
+class VersionInfo(BaseModel):
+    """存储版本信息的 Pydantic 模型"""
+    versions: List[str] = Field(default_factory=list)
+    latest: Optional[str] = None
+    installed_version: Optional[str] = None
+    launcher_version: Optional[str] = None
+
+def _compare_versions(version1: str, version2: str) -> int:
+    """
+    比较两个版本字符串。
+
+    :param version1: 第一个版本号
+    :param version2: 第二个版本号
+    :return: -1 表示 version1 < version2, 0 表示 version1 == version2, 1 表示 version1 > version2
+    """
+    if version1 == "0.4.x":
+        version1 = "0.4.0"
+
+    def parse(v):
+        v = v.lstrip('v')
+        parts = v.split('.')
+        base = []
+        pre_release = ''
+        for part in parts:
+            if 'b' in part:
+                base.append(int(part.split('b')[0]))
+                pre_release = ('b', int(part.split('b')[1]))
+                break
+            elif 'a' in part:
+                base.append(int(part.split('a')[0]))
+                pre_release = ('a', int(part.split('a')[1]))
+                break
+            elif 'rc' in part:
+                base.append(int(part.split('rc')[0]))
+                pre_release = ('rc', int(part.split('rc')[1]))
+                break
+            else:
+                base.append(int(part))
+        
+        pre_map = {'a': -2, 'b': -1, 'rc': -0.5}
+        if pre_release:
+            return tuple(base) + (pre_map[pre_release[0]], pre_release[1])
+        return tuple(base) + (0, 0)
+
+    v1_parsed = parse(version1)
+    v2_parsed = parse(version2)
+
+    if v1_parsed < v2_parsed:
+        return -1
+    if v1_parsed > v2_parsed:
+        return 1
+    return 0
+
+class UpdateService:
+    """处理应用程序更新逻辑"""
+
+    def __init__(self, repo_name: str = "ksaa"):
+        self.repo_name = repo_name
+        self.bootstrap_pyz_path = os.path.join(os.getcwd(), "bootstrap.pyz")
+
+    def _get_launcher_version(self) -> Optional[str]:
+        """
+        从 bootstrap.pyz/meta.py 读取启动器版本。
+        
+        :return: 启动器版本字符串，如果无法确定则返回 None。
+        """
+        if not os.path.exists(self.bootstrap_pyz_path):
+            logger.warning("bootstrap.pyz not found.")
+            return None
+
+        try:
+            with zipfile.ZipFile(self.bootstrap_pyz_path, 'r') as zf:
+                if 'meta.py' not in zf.namelist():
+                    logger.warning("meta.py not found in bootstrap.pyz, assuming legacy launcher.")
+                    return "0.4.x"
+
+                meta_content = zf.read('meta.py').decode('utf-8')
+                exec_globals = {}
+                exec_locals = {}
+                exec(meta_content, exec_globals, exec_locals)
+
+                version = exec_locals.get('VERSION')
+                if version and isinstance(version, str):
+                    logger.info(f"Launcher version from meta.py: {version}")
+                    return version.lstrip('v')
+                else:
+                    logger.warning("VERSION not found in meta.py.")
+                    return None
+        except zipfile.BadZipFile:
+            logger.info("bootstrap.pyz is not a valid zip file, assuming legacy launcher.")
+            return "0.4.x"
+        except Exception as e:
+            logger.error(f"Failed to read launcher version: {e}", exc_info=True)
+            return None
+
+    def list_remote_versions(self) -> VersionInfo:
+        """
+        从 PyPI 获取可用版本。
+
+        :return: 包含版本数据的 VersionInfo 对象。
+        :raises UpdateFetchListError: 如果无法获取或解析版本列表。
+        """
+        cmd = [
+            sys.executable, "-m", "pip", "index", "versions", self.repo_name,
+            "--json", "--pre",
+            "--index-url", "https://mirrors.tuna.tsinghua.edu.cn/pypi/web/simple",
+            "--trusted-host", "mirrors.tuna.tsinghua.edu.cn"
+        ]
+        logger.info(f"Executing: {' '.join(cmd)}")
+
+        try:
+            result = subprocess.run(
+                cmd,
+                capture_output=True,
+                text=True,
+                timeout=30,
+                check=False
+            )
+
+            if result.returncode != 0:
+                raise UpdateFetchListError(result.stderr)
+
+            data = json.loads(result.stdout)
+            version_info = VersionInfo(
+                versions=data.get("versions", []),
+                latest=data.get("latest"),
+                installed_version=data.get("installed_version")
+            )
+            version_info.launcher_version = self._get_launcher_version()
+            logger.info(f"Found {len(version_info.versions)} available versions.")
+            return version_info
+
+        except (subprocess.TimeoutExpired, json.JSONDecodeError, Exception) as e:
+            raise UpdateFetchListError(str(e)) from e
+
+    def _check_compatibility(self, target_version: str) -> Optional[str]:
+        """
+        检查启动器是否与目标版本兼容。
+        
+        :raises CompatibilityError: 如果启动器不兼容。
+        :return: 如果有潜在问题，则返回警告消息，否则返回 None。
+        """
+        launcher_version = self._get_launcher_version()
+        if not launcher_version:
+            return "无法获取启动器版本，可以继续安装但可能存在兼容性问题"
+
+        logger.info(f"Launcher version: {launcher_version}, Target version: {target_version}")
+
+        if _compare_versions(launcher_version, "0.5.0") < 0:
+            if _compare_versions(target_version, "2025.9b1") >= 0:
+                raise CompatibilityError(launcher_version, target_version)
+            else:
+                return "启动器版本较低，建议升级到 v0.5.0 以上"
+        return None
+
+    def install_version(self, version: str):
+        """
+        安装应用程序的特定版本。
+
+        :param version: 要安装的版本。
+        :raises CompatibilityError: 如果启动器不兼容。
+        :raises UpdateInstallError: 如果安装过程启动失败。
+        """
+        if not version:
+            raise ValueError("A version must be selected to install.")
+
+        warning = self._check_compatibility(version)
+        if warning:
+            logger.warning(warning)
+
+        def _install_and_exit():
+            try:
+                time.sleep(1)
+                cmd = [sys.executable, self.bootstrap_pyz_path, f"--install-version={version}"]
+                logger.info(f"Starting installation via launcher: {' '.join(cmd)}")
+
+                subprocess.Popen(
+                    cmd,
+                    cwd=os.getcwd(),
+                    creationflags=subprocess.CREATE_NEW_CONSOLE if os.name == 'nt' else 0
+                )
+                logger.info("Installation process started. Exiting current application.")
+                os._exit(0)
+            except Exception as e:
+                logger.critical(f"Failed to launch installation process: {e}", exc_info=True)
+                
+        try:
+            install_thread = threading.Thread(target=_install_and_exit, daemon=True)
+            install_thread.start()
+        except Exception as e:
+            raise UpdateInstallError(str(e)) from e