ksaa 2025.11b3__py3-none-any.whl → 2025.11.post1__py3-none-any.whl

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/{core → services}/feedback_service.py

@@ -114,7 +114,7 @@ class FeedbackService:
         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/ui/common.py

@@ -0,0 +1,123 @@
+from typing import List, Dict, Tuple, Callable, Any, Literal, Optional
+from dataclasses import dataclass, field
+import gradio as gr
+from kaa.config.schema import BaseConfig
+
+# Type hints
+GradioInput = gr.Textbox | gr.Number | gr.Checkbox | gr.Dropdown | gr.Radio | gr.Slider | gr.State
+ConfigKey = Literal[
+    # backend
+    'backend_type', 'adb_ip', 'adb_port',
+    'screenshot_method', 'keep_screenshots',
+    'check_emulator', 'emulator_path',
+    'adb_emulator_name', 'emulator_args',
+    '_mumu_index', '_mumu12v5_index', '_leidian_index',
+    'mumu_background_mode_v4', 'mumu_background_mode_v5', 'target_screenshot_interval',
+
+    # purchase
+    'purchase_enabled',
+    'money_enabled', 'ap_enabled',
+    'ap_items', 'money_items', 'money_refresh',
+    'weekly_enabled',
+    
+    # assignment
+    'assignment_enabled',
+    'mini_live_reassign', 'mini_live_duration',
+    'online_live_reassign', 'online_live_duration',
+    'contest_enabled',
+    'select_which_contestant', 'when_no_set',
+    
+    # produce
+    'produce_enabled', 'selected_solution_id', 'produce_count', 'produce_timeout_cd', 'interrupt_timeout', 'enable_fever_month',
+    'mission_reward_enabled',
+    
+    # club reward
+    'club_reward_enabled',
+    'selected_note',
+    
+    # upgrade support card
+    'upgrade_support_card_enabled',
+    
+    # capsule toys
+    'capsule_toys_enabled', 'friend_capsule_toys_count',
+    'sense_capsule_toys_count', 'logic_capsule_toys_count',
+    'anomaly_capsule_toys_count',
+    
+    # start game
+    'start_game_enabled', 'start_through_kuyo',
+    'game_package_name', 'kuyo_package_name',
+    'disable_gakumas_localify', 'dmm_game_path', 'dmm_bypass',
+
+    # end game
+    'exit_kaa', 'kill_game', 'kill_dmm',
+    'kill_emulator', 'shutdown', 'hibernate',
+    'restore_gakumas_localify',
+    
+    'activity_funds',
+    'presents',
+    'mission_reward',
+    'activity_funds_enabled',
+    'presents_enabled',
+    'trace_recommend_card_detection',
+    
+    # misc
+    'check_update', 'auto_install_update', 'expose_to_lan', 'update_channel', 'log_level',
+
+    # idle
+    'idle_enabled', 'idle_seconds', 'idle_minimize_on_pause',
+
+    '_selected_backend_index'
+    
+]
+ConfigSetFunction = Callable[[BaseConfig, Dict[ConfigKey, Any]], None]
+ConfigBuilderReturnValue = Tuple[ConfigSetFunction, Dict[ConfigKey, GradioInput]]
+
+
+@dataclass
+class GradioComponents:
+    """Dataclass to hold all Gradio UI components that need to be accessed across methods."""
+    
+    # Main tabs
+    tabs: Optional[gr.Tabs] = None
+    
+    # Status tab components
+    run_btn: Optional[gr.Button] = None
+    pause_btn: Optional[gr.Button] = None
+    end_action_dropdown: Optional[gr.Dropdown] = None
+    quick_checkboxes: List[gr.Checkbox] = field(default_factory=list)
+    task_runtime_text: Optional[gr.Textbox] = None
+    task_status_df: Optional[gr.Dataframe] = None
+    
+    # Update tab components
+    update_info_md: Optional[gr.Markdown] = None
+    update_status_text: Optional[gr.Markdown] = None
+    update_version_dropdown: Optional[gr.Dropdown] = None
+    update_install_btn: Optional[gr.Button] = None
+    
+    # Produce tab components
+    produce_tab_solution_dropdown: Optional[gr.Dropdown] = None
+    produce_solution_settings_group: Optional[gr.Group] = None
+    produce_solution_name: Optional[gr.Textbox] = None
+    produce_solution_description: Optional[gr.Textbox] = None
+    produce_mode: Optional[gr.Dropdown] = None
+    produce_idols: Optional[gr.Dropdown] = None
+    produce_auto_set_memory: Optional[gr.Checkbox] = None
+    produce_memory_sets_group: Optional[gr.Group] = None
+    produce_memory_sets: Optional[gr.Dropdown] = None
+    produce_auto_set_support: Optional[gr.Checkbox] = None
+    produce_support_card_sets_group: Optional[gr.Group] = None
+    produce_support_card_sets: Optional[gr.Dropdown] = None
+    produce_use_pt_boost: Optional[gr.Checkbox] = None
+    produce_use_note_boost: Optional[gr.Checkbox] = None
+    produce_follow_producer: Optional[gr.Checkbox] = None
+    produce_self_study_lesson: Optional[gr.Dropdown] = None
+    produce_prefer_lesson_ap: Optional[gr.Checkbox] = None
+    produce_actions_order: Optional[gr.Dropdown] = None
+    produce_recommend_card_detection_mode: Optional[gr.Dropdown] = None
+    produce_use_ap_drink: Optional[gr.Checkbox] = None
+    produce_skip_commu: Optional[gr.Checkbox] = None
+    produce_all_detail_components: List[Any] = field(default_factory=list)
+    
+    # Settings tab components
+    settings_solution_dropdown: Optional[gr.Dropdown] = None
+    save_settings_btn: Optional[gr.Button] = None