feat(sweep): support finding max sweepable index

tasks/stage/list.py

@@ -1,3 +1,5 @@
+import re
+
 import numpy as np
 
 from module.base.base import ModuleBase
@@ -31,7 +33,7 @@ class StageList:
 
         self.current_index_min = 1
         self.current_index_max = 1
-        self.current_indexes = []
+        self.current_indexes: list[tuple[str, tuple]] = []
 
     def __str__(self):
         return f'StageList({self.name})'
@@ -46,11 +48,14 @@ class StageList:
 
     @property
     def _indexes(self) -> list[int]:
-        return list(map(lambda x: int(x.ocr_text), self.current_indexes))
+        return [int(x[0]) for x in self.current_indexes]
 
     def load_stage_indexes(self, main: ModuleBase):
         self.current_indexes = list(
-            filter(lambda x: x.ocr_text.isdigit(), self.index_ocr.detect_and_ocr(main.device.image))
+            filter(
+                lambda x: re.match(r'^\d{1,2}-?\d?$', x[0]),
+                map(lambda x: (x.ocr_text, x.box), self.index_ocr.detect_and_ocr(main.device.image))
+            )
         )
         if not self.current_indexes:
             logger.warning(f'No valid index in {self.index_ocr.name}')
@@ -126,13 +131,79 @@ class StageList:
                 timeout=Timer(1.5, 5)
             )
 
+    def insight_max_sweepable_index(self, main: ModuleBase, skip_first_screenshot=True) -> int:
+        """
+        Args:
+            main:
+            skip_first_screenshot:
+
+        Returns:
+            Index of max sweepable stage
+        """
+        logger.info('Insight sweepable index')
+        max_sweepable_index = 0
+        last_max_sweepable_index = 0
+
+        while 1:
+            if skip_first_screenshot:
+                skip_first_screenshot = False
+            else:
+                main.device.screenshot()
+
+            self.load_stage_indexes(main=main)
+
+            sweepable_index = next(
+                filter(
+                    lambda x: not self.is_sweepable(main, self.search_box(x[-1][:2])),
+                    self.current_indexes
+                ), None
+            )
+
+            # all sweepable
+            if sweepable_index is None:
+                logger.info('All sweepable')
+                max_sweepable_index = self.current_index_max
+                self.swipe_page(self.swipe_direction, main)
+                if max_sweepable_index == last_max_sweepable_index:
+                    logger.info(f'Max sweepable index: {max_sweepable_index}')
+                    return max_sweepable_index
+                last_max_sweepable_index = max_sweepable_index
+            # all not sweepable
+            elif int(sweepable_index[0]) == self.current_index_min:
+                logger.info('All not sweepable')
+                if int(sweepable_index[0]) == 1:
+                    logger.warning('No sweepable index')
+                    return 0
+                self.swipe_page(self.swipe_direction, main, reverse=True)
+            else:
+                logger.info(f'Sweepable index: {int(sweepable_index[0]) - 1}')
+                return int(sweepable_index[0]) - 1
+
+            main.wait_until_stable(
+                self.stage.button,
+                timer=Timer(0, 0),
+                timeout=Timer(1.5, 5)
+            )
+
+    def is_sweepable(self, main: ModuleBase, search_box) -> bool:
+        self.sweepable.load_search(search_box)
+        return main.appear(self.sweepable, similarity=0.8)
+
+    def search_box(
+            self,
+            index_cord: tuple[int, int],
+            padding: tuple[int, int] = (-20, -15)
+    ) -> tuple[int, int, int, int]:
+        stage_item_box = area_pad((*padding, *area_size(self.stage_item)))
+        return area_offset(stage_item_box, index_cord)
+
     def select_index_enter(
             self,
             main: ModuleBase,
             index: int,
             insight: bool = True,
             sweepable: bool = True,
-            offset: tuple[int, int] = (-20, -15),
+            padding: tuple[int, int] = (-20, -15),
             skip_first_screenshot: bool = True,
             interval: int = 1.5
     ) -> bool:
@@ -154,17 +225,14 @@ class StageList:
                 self.load_stage_indexes(main=main)
 
             # find box of index
-            index_box = next(filter(lambda x: int(x.ocr_text) == index, self.current_indexes), None)
+            index_box = next(filter(lambda x: int(x[0]) == index, self.current_indexes), None)
 
             if index_box is None:
                 logger.warning(f'No index {index} in {self.index_ocr.name}')
                 continue
 
-            stage_item_box = area_pad((*offset, *area_size(self.stage_item)))
-            search_box = area_offset(stage_item_box, index_box.box[:2])
-            self.sweepable.load_search(search_box)
-
-            if sweepable and not main.appear(self.sweepable):
+            search_box = self.search_box(index_box[-1][:2], padding)
+            if sweepable and not self.is_sweepable(main, search_box):
                 logger.warning(f'Index {index} is not sweepable')
                 return False