ok-script 0.0.65__tar.gz → 0.0.67__tar.gz

{ok-script-0.0.65 → ok-script-0.0.67}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ok-script
-Version: 0.0.65
+Version: 0.0.67
 Summary: Automation with Computer Vision for Python
 Home-page: https://github.com/ok-oldking/ok-script
 Author: ok-oldking

{ok-script-0.0.65 → ok-script-0.0.67}/ok/OK.py

@@ -40,6 +40,7 @@ class OK:
             self.init_device_manager()
             from ok.gui.debug.Screenshot import Screenshot
             self.screenshot = Screenshot(self.exit_event)
+            self.do_init()
             if config.get("use_gui"):
                 from ok.gui.App import App
                 self.app = App(config, self.exit_event)
@@ -47,7 +48,6 @@ class OK:
             else:
                 self.device_manager.set_preferred_device()
                 self.device_manager.start()
-                self.do_init()
         except Exception as e:
             logger.error(f'__init__ error', e)
             self.quit()
@@ -56,8 +56,7 @@ class OK:
     def start(self):
         try:
             if self.config.get("use_gui"):
-                if self.do_init():
-                    self.app.show_main_window()
+                self.app.show_main_window()
                 self.app.exec()
             else:
                 self.task_executor.start()
@@ -100,13 +99,16 @@ class OK:
             inference_num_threads = self.config.get('ocr').get('inference_num_threads', -1)
             self.ocr = RapidOCR(inference_num_threads=inference_num_threads)
 
-        if self.config.get('coco_feature_folder') is not None:
-            coco_feature_folder = self.config.get('coco_feature_folder')
+        template_matching = self.config.get('template_matching')
+        if template_matching is not None:
+            coco_feature_folder = self.config.get('template_matching').get('coco_feature_folder')
             from ok.feature.FeatureSet import FeatureSet
             self.feature_set = FeatureSet(coco_feature_folder,
-                                          default_horizontal_variance=self.config.get('default_horizontal_variance', 0),
-                                          default_vertical_variance=self.config.get('default_vertical_variance', 0),
-                                          default_threshold=self.config.get('default_threshold', 0))
+                                          default_horizontal_variance=template_matching.get(
+                                              'default_horizontal_variance', 0),
+                                          default_vertical_variance=template_matching.get('default_vertical_variance',
+                                                                                          0),
+                                          default_threshold=template_matching.get('default_threshold', 0))
 
         from ok.task.TaskExecutor import TaskExecutor
         self.task_executor = TaskExecutor(self.device_manager, exit_event=self.exit_event,
@@ -116,8 +118,7 @@ class OK:
                                           feature_set=self.feature_set,
                                           ocr=self.ocr, config_folder=self.config.get("config_folder"))
 
-        if self.app:
-            ok.gui.executor = self.task_executor
+        ok.gui.executor = self.task_executor
 
         return True
 
@@ -135,8 +136,8 @@ class OK:
         if self.device_manager is None:
             from ok.capture.adb.DeviceManager import DeviceManager
             self.device_manager = DeviceManager(self.config.get("config_folder") or "config",
-                                                self.config.get('windows_capture'),
-                                                self.config.get('adb_capture'),
+                                                self.config.get('windows'),
+                                                self.config.get('adb'),
                                                 self.config.get("debug"),
                                                 self.exit_event)
             ok.gui.device_manager = self.device_manager

{ok-script-0.0.65 → ok-script-0.0.67}/ok/alas/emulator_base.py

@@ -1,270 +1,270 @@
-import os
-import re
-import typing as t
-from dataclasses import dataclass
-
-from ok.alas.utils import cached_property, iter_folder
-
-
-def abspath(path):
-    return os.path.abspath(path)
-
-
-def get_serial_pair(serial):
-    """
-    Args:
-        serial (str):
-
-    Returns:
-        str, str: `127.0.0.1:5555+{X}` and `emulator-5554+{X}`, 0 <= X <= 32
-    """
-    if serial.startswith('127.0.0.1:'):
-        try:
-            port = int(serial[10:])
-            if 5555 <= port <= 5555 + 32:
-                return f'127.0.0.1:{port}', f'emulator-{port - 1}'
-        except (ValueError, IndexError):
-            pass
-    if serial.startswith('emulator-'):
-        try:
-            port = int(serial[9:])
-            if 5554 <= port <= 5554 + 32:
-                return f'127.0.0.1:{port + 1}', f'emulator-{port}'
-        except (ValueError, IndexError):
-            pass
-
-    return None, None
-
-
-def remove_duplicated_path(paths):
-    """
-    Args:
-        paths (list[str]):
-
-    Returns:
-        list[str]:
-    """
-    paths = sorted(set(paths))
-    dic = {}
-    for path in paths:
-        dic.setdefault(path.lower(), path)
-    return list(dic.values())
-
-
-@dataclass
-class EmulatorInstanceBase:
-    # Serial for adb connection
-    serial: str
-    # Emulator instance name, used for start/stop emulator
-    name: str
-    # Path to emulator .exe
-    path: str
-
-    def __str__(self):
-        return f'{self.type}(serial="{self.serial}", name="{self.name}", path="{self.path}")'
-
-    @cached_property
-    def type(self) -> str:
-        """
-        Returns:
-            str: Emulator type, such as Emulator.NoxPlayer
-        """
-        return self.emulator.type
-
-    @cached_property
-    def emulator(self):
-        """
-        Returns:
-            Emulator:
-        """
-        return EmulatorBase(self.path)
-
-    def __eq__(self, other):
-        if isinstance(other, str) and self.type == other:
-            return True
-        if isinstance(other, list) and self.type in other:
-            return True
-        if isinstance(other, EmulatorInstanceBase):
-            return super().__eq__(other) and self.type == other.type
-        return super().__eq__(other)
-
-    def __hash__(self):
-        return hash(str(self))
-
-    def __bool__(self):
-        return True
-
-    @cached_property
-    def MuMuPlayer12_id(self):
-        """
-        Convert MuMu 12 instance name to instance id.
-        Example names:
-            MuMuPlayer-12.0-3
-            YXArkNights-12.0-1
-
-        Returns:
-            int: Instance ID, or None if this is not a MuMu 12 instance
-        """
-        res = re.search(r'MuMuPlayer(?:Global)?-12.0-(\d+)', self.name)
-        if res:
-            return int(res.group(1))
-        res = re.search(r'YXArkNights-12.0-(\d+)', self.name)
-        if res:
-            return int(res.group(1))
-
-        return None
-
-
-class EmulatorBase:
-    # Values here must match those in argument.yaml EmulatorInfo.Emulator.option
-    NoxPlayer = 'NoxPlayer'
-    NoxPlayer64 = 'NoxPlayer64'
-    NoxPlayerFamily = [NoxPlayer, NoxPlayer64]
-    BlueStacks4 = 'BlueStacks4'
-    BlueStacks5 = 'BlueStacks5'
-    BlueStacks4HyperV = 'BlueStacks4HyperV'
-    BlueStacks5HyperV = 'BlueStacks5HyperV'
-    BlueStacksFamily = [BlueStacks4, BlueStacks5]
-    LDPlayer3 = 'LDPlayer3'
-    LDPlayer4 = 'LDPlayer4'
-    LDPlayer9 = 'LDPlayer9'
-    LDPlayerFamily = [LDPlayer3, LDPlayer4, LDPlayer9]
-    MuMuPlayer = 'MuMuPlayer'
-    MuMuPlayerX = 'MuMuPlayerX'
-    MuMuPlayer12 = 'MuMuPlayer12'
-    MuMuPlayerFamily = [MuMuPlayer, MuMuPlayerX, MuMuPlayer12]
-    MEmuPlayer = 'MEmuPlayer'
-
-    @classmethod
-    def path_to_type(cls, path: str) -> str:
-        """
-        Args:
-            path: Path to .exe file
-
-        Returns:
-            str: Emulator type, such as Emulator.NoxPlayer,
-                or '' if this is not a emulator.
-        """
-        return ''
-
-    def iter_instances(self) -> t.Iterable[EmulatorInstanceBase]:
-        """
-        Yields:
-            EmulatorInstance: Emulator instances found in this emulator
-        """
-        pass
-
-    def iter_adb_binaries(self) -> t.Iterable[str]:
-        """
-        Yields:
-            str: Filepath to adb binaries found in this emulator
-        """
-        pass
-
-    def __init__(self, path):
-        # Path to .exe file
-        self.path = path
-        # Path to emulator folder
-        self.dir = os.path.dirname(path)
-        # str: Emulator type, or '' if this is not a emulator.
-        self.type = self.__class__.path_to_type(path)
-
-    def __eq__(self, other):
-        if isinstance(other, str) and self.type == other:
-            return True
-        if isinstance(other, list) and self.type in other:
-            return True
-        return super().__eq__(other)
-
-    def __str__(self):
-        return f'{self.type}(path="{self.path}")'
-
-    __repr__ = __str__
-
-    def __hash__(self):
-        return hash(self.path)
-
-    def __bool__(self):
-        return True
-
-    def abspath(self, path, folder=None):
-        if folder is None:
-            folder = self.dir
-        return abspath(os.path.join(folder, path))
-
-    @classmethod
-    def is_emulator(cls, path: str) -> bool:
-        """
-        Args:
-            path: Path to .exe file.
-
-        Returns:
-            bool: If this is a emulator.
-        """
-        return bool(cls.path_to_type(path))
-
-    def list_folder(self, folder, is_dir=False, ext=None):
-        """
-        Safely list files in a folder
-
-        Args:
-            folder:
-            is_dir:
-            ext:
-
-        Returns:
-            list[str]:
-        """
-        folder = self.abspath(folder)
-        return list(iter_folder(folder, is_dir=is_dir, ext=ext))
-
-
-class EmulatorManagerBase:
-    @staticmethod
-    def iter_running_emulator():
-        """
-        Yields:
-            str: Path to emulator executables, may contains duplicate values
-        """
-        return
-
-    @cached_property
-    def all_emulators(self) -> t.List[EmulatorBase]:
-        """
-        Get all emulators installed on current computer.
-        """
-        return []
-
-    @cached_property
-    def all_emulator_instances(self) -> t.List[EmulatorInstanceBase]:
-        """
-        Get all emulator instances installed on current computer.
-        """
-        return []
-
-    @cached_property
-    def all_emulator_serials(self) -> t.List[str]:
-        """
-        Returns:
-            list[str]: All possible serials on current computer.
-        """
-        out = []
-        for emulator in self.all_emulator_instances:
-            out.append(emulator.serial)
-            # Also add serial like `emulator-5554`
-            port_serial, emu_serial = get_serial_pair(emulator.serial)
-            if emu_serial:
-                out.append(emu_serial)
-        return out
-
-    @cached_property
-    def all_adb_binaries(self) -> t.List[str]:
-        """
-        Returns:
-            list[str]: All adb binaries of emulators on current computer.
-        """
-        out = []
-        for emulator in self.all_emulators:
-            for exe in emulator.iter_adb_binaries():
-                out.append(exe)
-        return out
+import os
+import re
+import typing as t
+from dataclasses import dataclass
+
+from ok.alas.utils import iter_folder
+
+
+def abspath(path):
+    return os.path.abspath(path)
+
+
+def get_serial_pair(serial):
+    """
+    Args:
+        serial (str):
+
+    Returns:
+        str, str: `127.0.0.1:5555+{X}` and `emulator-5554+{X}`, 0 <= X <= 32
+    """
+    if serial.startswith('127.0.0.1:'):
+        try:
+            port = int(serial[10:])
+            if 5555 <= port <= 5555 + 32:
+                return f'127.0.0.1:{port}', f'emulator-{port - 1}'
+        except (ValueError, IndexError):
+            pass
+    if serial.startswith('emulator-'):
+        try:
+            port = int(serial[9:])
+            if 5554 <= port <= 5554 + 32:
+                return f'127.0.0.1:{port + 1}', f'emulator-{port}'
+        except (ValueError, IndexError):
+            pass
+
+    return None, None
+
+
+def remove_duplicated_path(paths):
+    """
+    Args:
+        paths (list[str]):
+
+    Returns:
+        list[str]:
+    """
+    paths = sorted(set(paths))
+    dic = {}
+    for path in paths:
+        dic.setdefault(path.lower(), path)
+    return list(dic.values())
+
+
+@dataclass
+class EmulatorInstanceBase:
+    # Serial for adb connection
+    serial: str
+    # Emulator instance name, used for start/stop emulator
+    name: str
+    # Path to emulator .exe
+    path: str
+
+    def __str__(self):
+        return f'{self.type}(serial="{self.serial}", name="{self.name}", path="{self.path}")'
+
+    @property
+    def type(self) -> str:
+        """
+        Returns:
+            str: Emulator type, such as Emulator.NoxPlayer
+        """
+        return self.emulator.type
+
+    @property
+    def emulator(self):
+        """
+        Returns:
+            Emulator:
+        """
+        return EmulatorBase(self.path)
+
+    def __eq__(self, other):
+        if isinstance(other, str) and self.type == other:
+            return True
+        if isinstance(other, list) and self.type in other:
+            return True
+        if isinstance(other, EmulatorInstanceBase):
+            return super().__eq__(other) and self.type == other.type
+        return super().__eq__(other)
+
+    def __hash__(self):
+        return hash(str(self))
+
+    def __bool__(self):
+        return True
+
+    @property
+    def MuMuPlayer12_id(self):
+        """
+        Convert MuMu 12 instance name to instance id.
+        Example names:
+            MuMuPlayer-12.0-3
+            YXArkNights-12.0-1
+
+        Returns:
+            int: Instance ID, or None if this is not a MuMu 12 instance
+        """
+        res = re.search(r'MuMuPlayer(?:Global)?-12.0-(\d+)', self.name)
+        if res:
+            return int(res.group(1))
+        res = re.search(r'YXArkNights-12.0-(\d+)', self.name)
+        if res:
+            return int(res.group(1))
+
+        return None
+
+
+class EmulatorBase:
+    # Values here must match those in argument.yaml EmulatorInfo.Emulator.option
+    NoxPlayer = 'NoxPlayer'
+    NoxPlayer64 = 'NoxPlayer64'
+    NoxPlayerFamily = [NoxPlayer, NoxPlayer64]
+    BlueStacks4 = 'BlueStacks4'
+    BlueStacks5 = 'BlueStacks5'
+    BlueStacks4HyperV = 'BlueStacks4HyperV'
+    BlueStacks5HyperV = 'BlueStacks5HyperV'
+    BlueStacksFamily = [BlueStacks4, BlueStacks5]
+    LDPlayer3 = 'LDPlayer3'
+    LDPlayer4 = 'LDPlayer4'
+    LDPlayer9 = 'LDPlayer9'
+    LDPlayerFamily = [LDPlayer3, LDPlayer4, LDPlayer9]
+    MuMuPlayer = 'MuMuPlayer'
+    MuMuPlayerX = 'MuMuPlayerX'
+    MuMuPlayer12 = 'MuMuPlayer12'
+    MuMuPlayerFamily = [MuMuPlayer, MuMuPlayerX, MuMuPlayer12]
+    MEmuPlayer = 'MEmuPlayer'
+
+    @classmethod
+    def path_to_type(cls, path: str) -> str:
+        """
+        Args:
+            path: Path to .exe file
+
+        Returns:
+            str: Emulator type, such as Emulator.NoxPlayer,
+                or '' if this is not a emulator.
+        """
+        return ''
+
+    def iter_instances(self) -> t.Iterable[EmulatorInstanceBase]:
+        """
+        Yields:
+            EmulatorInstance: Emulator instances found in this emulator
+        """
+        pass
+
+    def iter_adb_binaries(self) -> t.Iterable[str]:
+        """
+        Yields:
+            str: Filepath to adb binaries found in this emulator
+        """
+        pass
+
+    def __init__(self, path):
+        # Path to .exe file
+        self.path = path
+        # Path to emulator folder
+        self.dir = os.path.dirname(path)
+        # str: Emulator type, or '' if this is not a emulator.
+        self.type = self.__class__.path_to_type(path)
+
+    def __eq__(self, other):
+        if isinstance(other, str) and self.type == other:
+            return True
+        if isinstance(other, list) and self.type in other:
+            return True
+        return super().__eq__(other)
+
+    def __str__(self):
+        return f'{self.type}(path="{self.path}")'
+
+    __repr__ = __str__
+
+    def __hash__(self):
+        return hash(self.path)
+
+    def __bool__(self):
+        return True
+
+    def abspath(self, path, folder=None):
+        if folder is None:
+            folder = self.dir
+        return abspath(os.path.join(folder, path))
+
+    @classmethod
+    def is_emulator(cls, path: str) -> bool:
+        """
+        Args:
+            path: Path to .exe file.
+
+        Returns:
+            bool: If this is a emulator.
+        """
+        return bool(cls.path_to_type(path))
+
+    def list_folder(self, folder, is_dir=False, ext=None):
+        """
+        Safely list files in a folder
+
+        Args:
+            folder:
+            is_dir:
+            ext:
+
+        Returns:
+            list[str]:
+        """
+        folder = self.abspath(folder)
+        return list(iter_folder(folder, is_dir=is_dir, ext=ext))
+
+
+class EmulatorManagerBase:
+    @staticmethod
+    def iter_running_emulator():
+        """
+        Yields:
+            str: Path to emulator executables, may contains duplicate values
+        """
+        return
+
+    @property
+    def all_emulators(self) -> t.List[EmulatorBase]:
+        """
+        Get all emulators installed on current computer.
+        """
+        return []
+
+    @property
+    def all_emulator_instances(self) -> t.List[EmulatorInstanceBase]:
+        """
+        Get all emulator instances installed on current computer.
+        """
+        return []
+
+    @property
+    def all_emulator_serials(self) -> t.List[str]:
+        """
+        Returns:
+            list[str]: All possible serials on current computer.
+        """
+        out = []
+        for emulator in self.all_emulator_instances:
+            out.append(emulator.serial)
+            # Also add serial like `emulator-5554`
+            port_serial, emu_serial = get_serial_pair(emulator.serial)
+            if emu_serial:
+                out.append(emu_serial)
+        return out
+
+    @property
+    def all_adb_binaries(self) -> t.List[str]:
+        """
+        Returns:
+            list[str]: All adb binaries of emulators on current computer.
+        """
+        out = []
+        for emulator in self.all_emulators:
+            for exe in emulator.iter_adb_binaries():
+                out.append(exe)
+        return out