ksaa 2025.11b1__py3-none-any.whl → 2025.11.post1__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,112 @@
+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.
+        If the file does not exist or is empty, it creates and saves a default configuration.
+        It populates the root configuration and sets the current user config.
+        """
+        self._root_config = load_config(self.config_path, type=BaseConfig, use_default_if_not_found=True)
+
+        if not self._root_config.user_configs:
+            logger.info("config.json not found or is empty, creating a default configuration.")
+            default_config = UserConfig[BaseConfig](
+                name="默认配置",
+                category="default",
+                description="默认配置",
+                backend=BackendConfig(),
+                options=BaseConfig()
+            )
+            self._root_config.user_configs.append(default_config)
+            save_config(self._root_config, self.config_path)
+            logger.info("New default configuration created at %s", self.config_path)
+
+        self._current_user_config = self._root_config.user_configs[0]
+
+    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