ok-script 0.0.52__tar.gz → 0.0.75__tar.gz

{ok-script-0.0.52 → ok-script-0.0.75}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ok-script
-Version: 0.0.52
+Version: 0.0.75
 Summary: Automation with Computer Vision for Python
 Home-page: https://github.com/ok-oldking/ok-script
 Author: ok-oldking
@@ -22,6 +22,7 @@ Requires-Dist: psutil>=5.9.8
 Requires-Dist: opencv-python>=4.9.0.80
 Requires-Dist: ok-d3dshot>=0.1.5
 Requires-Dist: py7zr>=0.21.0
+Requires-Dist: wmi>=1.5.1
 
 # ok-script
 

{ok-script-0.0.52 → ok-script-0.0.75}/ok/OK.py

@@ -9,7 +9,9 @@ import ok
 from ok.logging.Logger import get_logger, config_logger
 from ok.util.exit_event import ExitEvent
 from ok.util.path import install_path_isascii
+from ok.util.win32_process import check_mutex
 
+check_mutex()
 logger = get_logger(__name__)
 
 
@@ -28,10 +30,12 @@ class OK:
 
     def __init__(self, config: Dict[str, Any]):
         print(f"AutoHelper init, config: {config}")
+        config["config_folder"] = config.get("config_folder") or 'configs'
         config_logger(config)
         logger.info(f"AutoHelper init, config: {config}")
         ok.gui.ok = self
-        self.debug = config.get("debug", False)
+        config['debug'] = config.get("debug", False)
+        self.debug = config['debug']
         try:
             self.config = config
             self.init_device_manager()
@@ -44,7 +48,7 @@ class OK:
             else:
                 self.device_manager.set_preferred_device()
                 self.device_manager.start()
-                self.do_init()
+            self.do_init()
         except Exception as e:
             logger.error(f'__init__ error', e)
             self.quit()
@@ -53,8 +57,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()
@@ -97,13 +100,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_json = self.config.get('template_matching').get('coco_feature_json')
             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))
+            self.feature_set = FeatureSet(coco_feature_json,
+                                          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,
@@ -111,10 +117,9 @@ class OK:
                                           trigger_tasks=self.config.get('trigger_tasks', []),
                                           scenes=self.config['scenes'],
                                           feature_set=self.feature_set,
-                                          ocr=self.ocr, config_folder=self.config.get("config_folder") or "config")
+                                          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
 
@@ -125,17 +130,12 @@ class OK:
     def quit(self):
         logger.debug('quit app')
         self.exit_event.set()
-        if self.device_manager is not None:
-            self.device_manager.stop()
         if self.app:
             self.app.quit()
 
     def init_device_manager(self):
         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("debug"),
+            self.device_manager = DeviceManager(self.config,
                                                 self.exit_event)
             ok.gui.device_manager = self.device_manager

ok-script-0.0.75/ok/alas/emulator_base.py

@@ -0,0 +1,270 @@
+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