ksaa 2025.8.2.0__py3-none-any.whl → 2025.8.17.0__py3-none-any.whl

kotonebot/backend/loop.py

@@ -1,277 +1,277 @@
-import time
-from functools import lru_cache, partial
-from typing import Callable, Any, overload, Literal, Generic, TypeVar, cast, get_args, get_origin
-
-from cv2.typing import MatLike
-
-from kotonebot.util import Interval
-from kotonebot import device, image, ocr
-from kotonebot.backend.core import Image
-from kotonebot.backend.ocr import TextComparator
-from kotonebot.client.protocol import ClickableObjectProtocol
-
-
-class LoopAction:
-    def __init__(self, loop: 'Loop', func: Callable[[], ClickableObjectProtocol | None]):
-        self.loop = loop
-        self.func = func
-        self.result: ClickableObjectProtocol | None = None
-
-    @property
-    def found(self):
-        """
-        是否找到结果。若父 Loop 未在运行中，则返回 False。
-        """
-        if not self.loop.running:
-            return False
-        return bool(self.result)
-
-    def __bool__(self):
-        return self.found
-
-    def reset(self):
-        """
-        重置 LoopAction，以复用此对象。
-        """
-        self.result = None
-
-    def do(self):
-        """
-        执行 LoopAction。
-        :return: 执行结果。
-        """
-        if not self.loop.running:
-            return
-        if self.loop.found_anything:
-            # 本轮循环已执行任意操作，因此不需要再继续检测
-            return
-        self.result = self.func()
-        if self.result:
-            self.loop.found_anything = True
-
-    def click(self, *, at: tuple[int, int] | None = None):
-        """
-        点击寻找结果。若结果为空，会跳过执行。
-
-        :return:
-        """
-        if self.result:
-            if at is not None:
-                device.click(*at)
-            else:
-                device.click(self.result)
-
-    def call(self, func: Callable[[ClickableObjectProtocol], Any]):
-        pass
-
-
-class Loop:
-    def __init__(
-            self,
-            *,
-            timeout: float = 300,
-            interval: float = 0.3,
-            auto_screenshot: bool = True
-    ):
-        self.running = True
-        self.found_anything = False
-        self.auto_screenshot = auto_screenshot
-        """
-        是否在每次循环开始时（Loop.tick() 被调用时）截图。
-        """
-        self.__last_loop: float = -1
-        self.__interval = Interval(interval)
-        self.screenshot: MatLike | None = None
-        """上次截图时的图像数据。"""
-
-    def __iter__(self):
-        self.__interval.reset()
-        return self
-
-    def __next__(self):
-        if not self.running:
-            raise StopIteration
-        self.found_anything = False
-        self.__last_loop = time.time()
-        return self.tick()
-
-    def tick(self):
-        self.__interval.wait()
-        if self.auto_screenshot:
-            self.screenshot = device.screenshot()
-        self.__last_loop = time.time()
-        self.found_anything = False
-        return self
-
-    def exit(self):
-        """
-        结束循环。
-        """
-        self.running = False
-
-    @overload
-    def when(self, condition: Image) -> LoopAction:
-        ...
-
-    @overload
-    def when(self, condition: TextComparator) -> LoopAction:
-        ...
-
-    def when(self, condition: Any):
-        """
-        判断某个条件是否成立。
-
-        :param condition:
-        :return:
-        """
-        if isinstance(condition, Image):
-            func = partial(image.find, condition)
-        elif isinstance(condition, TextComparator):
-            func = partial(ocr.find, condition)
-        else:
-            raise ValueError('Invalid condition type.')
-        la = LoopAction(self, func)
-        la.reset()
-        la.do()
-        return la
-
-    def until(self, condition: Any):
-        """
-        当满足指定条件时，结束循环。
-
-        等价于 ``loop.when(...).call(lambda _: loop.exit())``
-        """
-        return self.when(condition).call(lambda _: self.exit())
-
-    def click_if(self, condition: Any, *, at: tuple[int, int] | None = None):
-        """
-        检测指定对象是否出现，若出现，点击该对象或指定位置。
-
-        ``click_if()`` 等价于 ``loop.when(...).click(...)``。
-
-        :param condition: 检测目标。
-        :param at: 点击位置。若为 None，表示点击找到的目标。
-        """
-        return self.when(condition).click(at=at)
-
-StateType = TypeVar('StateType')
-class StatedLoop(Loop, Generic[StateType]):
-    def __init__(
-        self,
-        states: list[Any] | None = None,
-        initial_state: StateType | None = None,
-        *,
-        timeout: float = 300,
-        interval: float = 0.3,
-        auto_screenshot: bool = True
-    ):
-        self.__tmp_states = states
-        self.__tmp_initial_state = initial_state
-        self.state: StateType
-        super().__init__(timeout=timeout, interval=interval, auto_screenshot=auto_screenshot)
-
-    def __iter__(self):
-        # __retrive_state_values() 只能在非 __init__ 中调用
-        self.__retrive_state_values()
-        return super().__iter__()
-
-    def __retrive_state_values(self):
-        # HACK: __orig_class__ 是 undocumented 属性
-        if not hasattr(self, '__orig_class__'):
-            # 如果 Foo 不是以参数化泛型的方式实例化的，可能没有 __orig_class__
-            if self.state is None:
-                raise ValueError('Either specify `states` or use StatedLoop[Literal[...]] syntax.')
-        else:
-            generic_type_args = get_args(self.__orig_class__) # type: ignore
-            if len(generic_type_args) != 1:
-                raise ValueError('StatedLoop must have exactly one generic type argument.')
-            state_values = get_args(generic_type_args[0])
-            if not state_values:
-                raise ValueError('StatedLoop must have at least one state value.')
-            self.states = cast(tuple[StateType, ...], state_values)
-            self.state = self.__tmp_initial_state or self.states[0]
-            return state_values
-
-
-def StatedLoop2(states: StateType) -> StatedLoop[StateType]:
-    state_values = get_args(states)
-    return cast(StatedLoop[StateType], Loop())
-
-if __name__ == '__main__':
-    from kotonebot.kaa.tasks import R
-    from kotonebot.backend.ocr import contains
-    from kotonebot.backend.context import manual_context, init_context
-
-    # T = TypeVar('T')
-    # class Foo(Generic[T]):
-    #     def get_literal_params(self) -> list | None:
-    #         """
-    #         尝试获取泛型参数 T (如果它是 Literal 类型) 的参数列表。
-    #         """
-    #         # self.__orig_class__ 会是 Foo 的具体参数化类型，
-    #         # 例如 Foo[Literal['p0', 'p1', 'p2', 'p3', 'ap']]
-    #         if not hasattr(self, '__orig_class__'):
-    #             # 如果 Foo 不是以参数化泛型的方式实例化的，可能没有 __orig_class__
-    #             return None
-    #
-    #         # generic_type_args 是传递给 Foo 的类型参数元组
-    #         # 例如 (Literal['p0', 'p1', 'p2', 'p3', 'ap'],)
-    #         generic_type_args = get_args(self.__orig_class__)
-    #
-    #         if not generic_type_args:
-    #             # Foo 没有类型参数
-    #             return None
-    #
-    #         # T_type 是 Foo 的第一个类型参数
-    #         # 例如 Literal['p0', 'p1', 'p2', 'p3', 'ap']
-    #         t_type = generic_type_args[0]
-    #
-    #         # 检查 T_type 是否是 Literal 类型
-    #         if get_origin(t_type) is Literal:
-    #             # literal_args 是 Literal 类型的参数元组
-    #             # 例如 ('p0', 'p1', 'p2', 'p3', 'ap')
-    #             literal_args = get_args(t_type)
-    #             return list(literal_args)
-    #         else:
-    #             # T 不是 Literal 类型
-    #             return None
-    # f = Foo[Literal['p0', 'p1', 'p2', 'p3', 'ap']]()
-    # values = f.get_literal_params()
-    # 1
-
-    from typing_extensions import reveal_type
-    slp = StatedLoop[Literal['p0', 'p1', 'p2', 'p3', 'ap']]()
-    for l in slp:
-        reveal_type(l.states)
-
-    # init_context()
-    # manual_context().begin()
-    # for l in Loop():
-    #     l.when(R.Produce.ButtonUse).click()
-    #     l.when(R.Produce.ButtonRefillAP).click()
-    #     l.when(contains("123")).click()
-    #     l.click_if(contains("!23"), at=(1, 2))
-
-    # State = Literal['p0', 'p1', 'p2', 'p3', 'ap']
-    # for sl in StatedLoop[State]():
-    #     match sl.state:
-    #         case 'p0':
-    #             sl.click_if(R.Produce.ButtonProduce)
-    #             sl.click_if(contains('master'))
-    #             sl.when(R.Produce.ButtonPIdolOverview).goto('p1')
-    #             # AP 不足
-    #             sl.when(R.Produce.TextAPInsufficient).goto('ap')
-    #         case 'ap':
-    #             pass
-    #         # p1: 选择偶像
-    #         case 'p1':
-    #             sl.call(lambda _: select_idol(idol_skin_id), once=True)
-    #             sl.when(R.Produce.TextAnotherIdolAvailableDialog).call(dialog.no)
-    #             sl.click_if(R.Common.ButtonNextNoIcon)
-    #             sl.until(R.Produce.TextStepIndicator2).goto('p2')
-    #         case 'p2':
-    #             sl.when(contains("123")).click()
-    #         case 'p3':
-    #             sl.click_if(contains("!23"), at=(1, 2))
-    #         case _:
+import time
+from functools import lru_cache, partial
+from typing import Callable, Any, overload, Literal, Generic, TypeVar, cast, get_args, get_origin
+
+from cv2.typing import MatLike
+
+from kotonebot.util import Interval
+from kotonebot import device, image, ocr
+from kotonebot.backend.core import Image
+from kotonebot.backend.ocr import TextComparator
+from kotonebot.client.protocol import ClickableObjectProtocol
+
+
+class LoopAction:
+    def __init__(self, loop: 'Loop', func: Callable[[], ClickableObjectProtocol | None]):
+        self.loop = loop
+        self.func = func
+        self.result: ClickableObjectProtocol | None = None
+
+    @property
+    def found(self):
+        """
+        是否找到结果。若父 Loop 未在运行中，则返回 False。
+        """
+        if not self.loop.running:
+            return False
+        return bool(self.result)
+
+    def __bool__(self):
+        return self.found
+
+    def reset(self):
+        """
+        重置 LoopAction，以复用此对象。
+        """
+        self.result = None
+
+    def do(self):
+        """
+        执行 LoopAction。
+        :return: 执行结果。
+        """
+        if not self.loop.running:
+            return
+        if self.loop.found_anything:
+            # 本轮循环已执行任意操作，因此不需要再继续检测
+            return
+        self.result = self.func()
+        if self.result:
+            self.loop.found_anything = True
+
+    def click(self, *, at: tuple[int, int] | None = None):
+        """
+        点击寻找结果。若结果为空，会跳过执行。
+
+        :return:
+        """
+        if self.result:
+            if at is not None:
+                device.click(*at)
+            else:
+                device.click(self.result)
+
+    def call(self, func: Callable[[ClickableObjectProtocol], Any]):
+        pass
+
+
+class Loop:
+    def __init__(
+            self,
+            *,
+            timeout: float = 300,
+            interval: float = 0.3,
+            auto_screenshot: bool = True
+    ):
+        self.running = True
+        self.found_anything = False
+        self.auto_screenshot = auto_screenshot
+        """
+        是否在每次循环开始时（Loop.tick() 被调用时）截图。
+        """
+        self.__last_loop: float = -1
+        self.__interval = Interval(interval)
+        self.screenshot: MatLike | None = None
+        """上次截图时的图像数据。"""
+
+    def __iter__(self):
+        self.__interval.reset()
+        return self
+
+    def __next__(self):
+        if not self.running:
+            raise StopIteration
+        self.found_anything = False
+        self.__last_loop = time.time()
+        return self.tick()
+
+    def tick(self):
+        self.__interval.wait()
+        if self.auto_screenshot:
+            self.screenshot = device.screenshot()
+        self.__last_loop = time.time()
+        self.found_anything = False
+        return self
+
+    def exit(self):
+        """
+        结束循环。
+        """
+        self.running = False
+
+    @overload
+    def when(self, condition: Image) -> LoopAction:
+        ...
+
+    @overload
+    def when(self, condition: TextComparator) -> LoopAction:
+        ...
+
+    def when(self, condition: Any):
+        """
+        判断某个条件是否成立。
+
+        :param condition:
+        :return:
+        """
+        if isinstance(condition, Image):
+            func = partial(image.find, condition)
+        elif isinstance(condition, TextComparator):
+            func = partial(ocr.find, condition)
+        else:
+            raise ValueError('Invalid condition type.')
+        la = LoopAction(self, func)
+        la.reset()
+        la.do()
+        return la
+
+    def until(self, condition: Any):
+        """
+        当满足指定条件时，结束循环。
+
+        等价于 ``loop.when(...).call(lambda _: loop.exit())``
+        """
+        return self.when(condition).call(lambda _: self.exit())
+
+    def click_if(self, condition: Any, *, at: tuple[int, int] | None = None):
+        """
+        检测指定对象是否出现，若出现，点击该对象或指定位置。
+
+        ``click_if()`` 等价于 ``loop.when(...).click(...)``。
+
+        :param condition: 检测目标。
+        :param at: 点击位置。若为 None，表示点击找到的目标。
+        """
+        return self.when(condition).click(at=at)
+
+StateType = TypeVar('StateType')
+class StatedLoop(Loop, Generic[StateType]):
+    def __init__(
+        self,
+        states: list[Any] | None = None,
+        initial_state: StateType | None = None,
+        *,
+        timeout: float = 300,
+        interval: float = 0.3,
+        auto_screenshot: bool = True
+    ):
+        self.__tmp_states = states
+        self.__tmp_initial_state = initial_state
+        self.state: StateType
+        super().__init__(timeout=timeout, interval=interval, auto_screenshot=auto_screenshot)
+
+    def __iter__(self):
+        # __retrive_state_values() 只能在非 __init__ 中调用
+        self.__retrive_state_values()
+        return super().__iter__()
+
+    def __retrive_state_values(self):
+        # HACK: __orig_class__ 是 undocumented 属性
+        if not hasattr(self, '__orig_class__'):
+            # 如果 Foo 不是以参数化泛型的方式实例化的，可能没有 __orig_class__
+            if self.state is None:
+                raise ValueError('Either specify `states` or use StatedLoop[Literal[...]] syntax.')
+        else:
+            generic_type_args = get_args(self.__orig_class__) # type: ignore
+            if len(generic_type_args) != 1:
+                raise ValueError('StatedLoop must have exactly one generic type argument.')
+            state_values = get_args(generic_type_args[0])
+            if not state_values:
+                raise ValueError('StatedLoop must have at least one state value.')
+            self.states = cast(tuple[StateType, ...], state_values)
+            self.state = self.__tmp_initial_state or self.states[0]
+            return state_values
+
+
+def StatedLoop2(states: StateType) -> StatedLoop[StateType]:
+    state_values = get_args(states)
+    return cast(StatedLoop[StateType], Loop())
+
+if __name__ == '__main__':
+    from kotonebot.kaa.tasks import R
+    from kotonebot.backend.ocr import contains
+    from kotonebot.backend.context import manual_context, init_context
+
+    # T = TypeVar('T')
+    # class Foo(Generic[T]):
+    #     def get_literal_params(self) -> list | None:
+    #         """
+    #         尝试获取泛型参数 T (如果它是 Literal 类型) 的参数列表。
+    #         """
+    #         # self.__orig_class__ 会是 Foo 的具体参数化类型，
+    #         # 例如 Foo[Literal['p0', 'p1', 'p2', 'p3', 'ap']]
+    #         if not hasattr(self, '__orig_class__'):
+    #             # 如果 Foo 不是以参数化泛型的方式实例化的，可能没有 __orig_class__
+    #             return None
+    #
+    #         # generic_type_args 是传递给 Foo 的类型参数元组
+    #         # 例如 (Literal['p0', 'p1', 'p2', 'p3', 'ap'],)
+    #         generic_type_args = get_args(self.__orig_class__)
+    #
+    #         if not generic_type_args:
+    #             # Foo 没有类型参数
+    #             return None
+    #
+    #         # T_type 是 Foo 的第一个类型参数
+    #         # 例如 Literal['p0', 'p1', 'p2', 'p3', 'ap']
+    #         t_type = generic_type_args[0]
+    #
+    #         # 检查 T_type 是否是 Literal 类型
+    #         if get_origin(t_type) is Literal:
+    #             # literal_args 是 Literal 类型的参数元组
+    #             # 例如 ('p0', 'p1', 'p2', 'p3', 'ap')
+    #             literal_args = get_args(t_type)
+    #             return list(literal_args)
+    #         else:
+    #             # T 不是 Literal 类型
+    #             return None
+    # f = Foo[Literal['p0', 'p1', 'p2', 'p3', 'ap']]()
+    # values = f.get_literal_params()
+    # 1
+
+    from typing_extensions import reveal_type
+    slp = StatedLoop[Literal['p0', 'p1', 'p2', 'p3', 'ap']]()
+    for l in slp:
+        reveal_type(l.states)
+
+    # init_context()
+    # manual_context().begin()
+    # for l in Loop():
+    #     l.when(R.Produce.ButtonUse).click()
+    #     l.when(R.Produce.ButtonRefillAP).click()
+    #     l.when(contains("123")).click()
+    #     l.click_if(contains("!23"), at=(1, 2))
+
+    # State = Literal['p0', 'p1', 'p2', 'p3', 'ap']
+    # for sl in StatedLoop[State]():
+    #     match sl.state:
+    #         case 'p0':
+    #             sl.click_if(R.Produce.ButtonProduce)
+    #             sl.click_if(contains('master'))
+    #             sl.when(R.Produce.ButtonPIdolOverview).goto('p1')
+    #             # AP 不足
+    #             sl.when(R.Produce.TextAPInsufficient).goto('ap')
+    #         case 'ap':
+    #             pass
+    #         # p1: 选择偶像
+    #         case 'p1':
+    #             sl.call(lambda _: select_idol(idol_skin_id), once=True)
+    #             sl.when(R.Produce.TextAnotherIdolAvailableDialog).call(dialog.no)
+    #             sl.click_if(R.Common.ButtonNextNoIcon)
+    #             sl.until(R.Produce.TextStepIndicator2).goto('p2')
+    #         case 'p2':
+    #             sl.when(contains("123")).click()
+    #         case 'p3':
+    #             sl.click_if(contains("!23"), at=(1, 2))
+    #         case _:
     #             assert_never(sl.state)

kotonebot/kaa/main/gr.py

@@ -881,7 +881,7 @@ class KotoneBotUI:
                 new_value = choices[0]
             else:
                 new_value = impl_value
-            return gr.Dropdown(choices=choices, value=new_value)
+            return new_value
 
         with gr.Tabs(selected=self.current_config.backend.type):
             with gr.Tab("MuMu 12", id="mumu12") as tab_mumu12:
@@ -1405,12 +1405,6 @@ class KotoneBotUI:
                         info="进行一次 REGULAR 培育需要 ~30min，进行一次 PRO 培育需要 ~1h（具体视设备性能而定）。",
                         visible=False
                     )
-                    produce_count = gr.Number(
-                        minimum=1,
-                        label="培育次数",
-                        info="培育的次数。",
-                        visible=False
-                    )
 
                     # 添加偶像选择
                     idol_choices = []
@@ -1526,13 +1520,6 @@ class KotoneBotUI:
                         label="培育模式",
                         info="进行一次 REGULAR 培育需要 ~30min，进行一次 PRO 培育需要 ~1h（具体视设备性能而定）。"
                     )
-                    produce_count = gr.Number(
-                        minimum=1,
-                        value=self.current_config.options.produce.produce_count,
-                        label="培育次数",
-                        interactive=True,
-                        info="培育的次数。"
-                    )
 
                     # 添加偶像选择
                     idol_choices = []
@@ -1663,7 +1650,6 @@ class KotoneBotUI:
                         gr.Textbox(value="", visible=False),  # solution_name
                         gr.Textbox(value="", visible=False),  # solution_description
                         gr.Dropdown(visible=False),  # produce_mode
-                        gr.Number(visible=False),  # produce_count
                         gr.Dropdown(visible=False),  # produce_idols
                         gr.Markdown(visible=False),  # kotone_warning
                         gr.Checkbox(visible=False),  # auto_set_memory
@@ -1693,7 +1679,6 @@ class KotoneBotUI:
                         gr.Textbox(value=solution.name, visible=True),
                         gr.Textbox(value=solution.description or "", visible=True),
                         gr.Dropdown(value=solution.data.mode, visible=True),
-                        gr.Number(value=self.current_config.options.produce.produce_count, visible=True),
                         gr.Dropdown(value=solution.data.idol, visible=True),
                         gr.Markdown(visible=has_kotone and not is_strict_mode),
                         gr.Checkbox(value=solution.data.auto_set_memory, visible=True),
@@ -1789,7 +1774,7 @@ class KotoneBotUI:
                     else:
                         return gr.Dropdown()
 
-            def on_save_solution(solution_id, name, description, mode, count, idols, auto_memory, memory_sets,
+            def on_save_solution(solution_id, name, description, mode, idols, auto_memory, memory_sets,
                                auto_support, support_card_sets, pt_boost, note_boost, follow_producer, study_lesson, prefer_ap,
                                actions, detection_mode, ap_drink, skip_commu_val):
                 """保存培育方案"""
@@ -1831,9 +1816,6 @@ class KotoneBotUI:
                     # 保存方案
                     solution_manager.save(solution_id, solution)
 
-                    # 同时更新配置中的 produce_count
-                    self.current_config.options.produce.produce_count = int(count)
-
                     # 重新列出所有方案（确保没有重复项）
                     solutions = solution_manager.list()
                     solution_choices = [(f"{sol.name} - {sol.description or '无描述'}", sol.id) for sol in solutions]
@@ -1884,7 +1866,7 @@ class KotoneBotUI:
                 inputs=[solution_dropdown],
                 outputs=[
                     solution_name, solution_description,
-                    produce_mode, produce_count, produce_idols, kotone_warning,
+                    produce_mode, produce_idols, kotone_warning,
                     auto_set_memory, memory_sets_group, memory_sets,
                     auto_set_support, support_card_sets_group, support_card_sets,
                     use_pt_boost, use_note_boost, follow_producer,
@@ -1920,7 +1902,7 @@ class KotoneBotUI:
                 fn=on_save_solution,
                 inputs=[
                     solution_dropdown, solution_name, solution_description,
-                    produce_mode, produce_count, produce_idols,
+                    produce_mode, produce_idols,
                     auto_set_memory, memory_sets, auto_set_support, support_card_sets,
                     use_pt_boost, use_note_boost, follow_producer,
                     self_study_lesson, prefer_lesson_ap, actions_order,
@@ -2305,7 +2287,7 @@ class KotoneBotUI:
 
     def _create_settings_tab(self) -> None:
         with gr.Tab("设置"):
-            gr.Markdown("## 设置")
+            gr.Markdown("## 设置 <span style='color: red; font-size: 0.8rem; font-weight: normal;'>设置修改后需要保存（网页底部）才会生效！</span>")
 
             # 模拟器设置
             emulator_settings = self._create_emulator_settings()

kotonebot/kaa/metadata.py

@@ -1,6 +1,18 @@
 WHATS_NEW = """
 # 更新日志
 ## kaa
+### v2025.8.17.0
+脚本：
+* [修复] 尝试修复进入每日商店时报错的问题（#e9529b7）
+* [修复] 修复刷新商店商品时脚本不会等待刷新完成的问题（#180d800）
+* [修复] 修复商店刷新后第二次购买会跳过第一行的问题 #59（#a327791）
+* [修复] 修复金币商店购买一个物品总是点击两次的问题（#94a264e）
+
+界面：
+* [修复] 移除模拟器设置的最后多余的 Dropdown（#91d05b1）
+* [修复] 移除培育方案中多余的培育次数输入框（#c0549d9）
+* [新增] 新增保存设置提示（#b56eabc）
+
 ### v2025.8.2.0
 脚本：
 * [修复] 修复 DMM 版启动游戏提示找不到窗口的问题（#46e72c4）