ok-script 0.0.60__tar.gz → 0.0.62__tar.gz

{ok-script-0.0.60 → ok-script-0.0.62}/PKG-INFO

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

{ok-script-0.0.60 → ok-script-0.0.62}/ok/OK.py

@@ -30,6 +30,7 @@ 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
@@ -113,7 +114,7 @@ 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-script-0.0.62/ok/firebase/FireBaseAnalytics.py

@@ -0,0 +1,120 @@
+import json
+import uuid
+
+import requests
+import wmi
+
+from ok.config.Config import Config
+from ok.logging.Logger import get_logger
+from ok.util.Handler import Handler
+
+FIREBASE_ENDPOINT = 'https://www.google-analytics.com/mp/collect'
+
+logger = get_logger(__name__)
+
+
+class FireBaseAnalytics:
+    def __init__(self, app_config, exit_event):
+        self.measurement_id = app_config.get('firebase').get('measurement_id')
+        self.api_secret = app_config.get('firebase').get('api_secret')
+        self.app_config = app_config
+        self._config = None
+        self._handler = Handler(exit_event, __name__)
+        self._handler.post(self.report_open, 10)
+        self._user_properties = None
+
+    @property
+    def user_properties(self):
+        if self._user_properties is None:
+            c = wmi.WMI()
+
+            # Get OS information
+            os_info = c.Win32_OperatingSystem()[0]
+            os_version = os_info.Version.split(".")[0]
+            os_build = int(os_info.BuildNumber)
+
+            if os_version == "10" and os_build >= 22000:  # Windows 11 starts from build 22000
+                os_version = "11"
+
+            # Get CPU information
+            cpu_info = c.Win32_Processor()[0]
+            cpu_name = cpu_info.Name.strip()
+
+            # Get total memory (in GB)
+            total_memory = float(os_info.TotalVisibleMemorySize) / 1048576  # KB to GB
+
+            # Get graphics card information
+            gpu_info = c.Win32_VideoController()
+            gpu_name = None
+            for gpu in reversed(gpu_info):
+                if "intel" not in gpu.Name.lower() and "microsoft" not in gpu.Name.lower():
+                    gpu_name = gpu.Name
+                    break
+            if not gpu_name and gpu_info:
+                gpu_name = gpu_info[0].Name
+
+            # Put the information into a dictionary
+            self._user_properties = {
+                "os": 'windows',
+                "os_version": os_version,
+                "os_build": os_build,
+                "cpu": cpu_name,
+                "memory": int(total_memory),
+                "gpu": gpu_name
+            }
+        return self._user_properties
+
+    def report_open(self):
+        logger.debug(f'send app_open {self.user_properties}')
+        self.send_event('app_open')
+
+    @property
+    def client_id(self):
+        if self._config is None:
+            self._config = Config({}, self.app_config.get("config_folder") or "config", 'statistics')
+        if not self._config.get('client_id'):
+            self._config['client_id'] = get_unique_client_id()
+        return self._config.get('client_id')
+
+    def send_event(self, event_name, params=None):
+        if params is None:
+            params = dict()
+        payload = {
+            'client_id': self.client_id,
+            'events': [
+                {
+                    'name': event_name,
+                    'params': params
+                }
+            ],
+            'user_properties': self.user_properties
+        }
+
+        headers = {
+            'Content-Type': 'application/json'
+        }
+
+        response = requests.post(
+            f'{FIREBASE_ENDPOINT}?measurement_id={self.measurement_id}&api_secret={self.api_secret}',
+            data=json.dumps(payload),
+            headers=headers
+        )
+
+        if response.status_code == 204:
+            logger.debug(f'Successfully sent event: {event_name}')
+        else:
+            logger.debug(f'Failed to send event: {response.status_code} - {response.text}')
+
+
+def get_unique_client_id():
+    return str(uuid.uuid4())
+
+
+if __name__ == '__main__':
+    # Generate a unique client ID (UUID)
+    client_id = str(uuid.uuid4())
+    analytics = FireBaseAnalytics('G-9W3F3EQ19G', api_secret='eAkNmhrERiGg8Q3Riuxerw')
+    # Send a test event
+    analytics.send_event('app_open')
+    analytics.send_event('test1')
+    analytics.send_event('test2')

{ok-script-0.0.60 → ok-script-0.0.62}/ok/gui/App.py

@@ -83,8 +83,8 @@ class App:
         self.show_message_window(title, content)
 
     def show_main_window(self):
-        self.main_window = MainWindow(self.icon, self.title, self.version, self.overlay, self.about,
-                                      exit_event=self.exit_event)
+        self.main_window = MainWindow(self.config, self.icon, self.title, self.version, self.overlay, self.about,
+                                      self.exit_event)
         # Set the window title here
         self.main_window.setWindowIcon(self.icon)
         if self.overlay and ok.gui.device_manager.hwnd is not None:

{ok-script-0.0.60 → ok-script-0.0.62}/ok/gui/MainWindow.py

@@ -21,7 +21,7 @@ class Communicate(QObject):
 
 
 class MainWindow(MSFluentWindow):
-    def __init__(self, icon, title, version, debug=False, about=None, exit_event=None):
+    def __init__(self, config, icon, title, version, debug=False, about=None, exit_event=None):
         super().__init__()
         self.exit_event = exit_event
         self.start_tab = StartTab()
@@ -43,7 +43,7 @@ class MainWindow(MSFluentWindow):
         #     self.addSubInterface(debug_tab, FluentIcon.COMMAND_PROMPT, self.tr('Debug'))
         # ... Add other tabs similarly
         if debug:
-            debug_tab = DebugTab(exit_event)
+            debug_tab = DebugTab(config, exit_event)
             self.addSubInterface(debug_tab, FluentIcon.DEVELOPER_TOOLS, self.tr('Debug'),
                                  position=NavigationItemPosition.BOTTOM)
 

ok-script-0.0.62/ok/gui/debug/DebugTab.py

@@ -0,0 +1,92 @@
+import subprocess
+
+from PySide6.QtWidgets import QWidget, QFileDialog
+from qfluentwidgets import PushButton, FlowLayout, ComboBox
+
+import ok.gui
+from ok.capture.windows.dump import dump_threads
+from ok.config.Config import Config
+from ok.gui.widget.Tab import Tab
+from ok.logging.Logger import get_logger
+from ok.util.Handler import Handler
+
+logger = get_logger(__name__)
+
+
+class DebugTab(Tab):
+    def __init__(self, app_config, exit_event):
+        super().__init__()
+
+        self.config = Config({'target_task': None, 'target_image': None, 'target_function': None},
+                             app_config.get('config_folder'), 'debug')
+        tool_widget = QWidget()
+        layout = FlowLayout(tool_widget, False)
+
+        layout.setContentsMargins(0, 0, 0, 0)
+        layout.setVerticalSpacing(20)
+        layout.setHorizontalSpacing(10)
+        self.handler = Handler(exit_event, "DebugTab")
+
+        self.addCard(self.tr("Debug Tool"), tool_widget)
+
+        dump_button = PushButton(self.tr("Dump Threads(HotKey:Ctrl+Alt+D)"))
+        dump_button.clicked.connect(lambda: self.handler.post(dump_threads))
+        layout.addWidget(dump_button)
+
+        capture_button = PushButton(self.tr("Capture Screenshot"))
+        capture_button.clicked.connect(lambda: self.handler.post(self.capture))
+        layout.addWidget(capture_button)
+
+        open_log_folder = PushButton(self.tr("Open Logs"))
+
+        call_task_widget = QWidget()
+        call_task_layout = FlowLayout(call_task_widget, False)
+        self.addCard(self.tr("Debug Task Function"), call_task_widget)
+
+        self.select_screenshot_button = PushButton(
+            self.config.get('target_image') or self.tr("Drop or Select Screenshot"))
+        self.select_screenshot_button.clicked.connect(lambda: self.handler.post(self.select_screenshot))
+        call_task_layout.addWidget(self.select_screenshot_button)
+
+        self.tasks_combo_box = ComboBox()
+        call_task_layout.addWidget(self.tasks_combo_box)
+        tasks = ok.gui.executor.get_all_tasks()
+        class_names = [obj.__class__.__name__ for obj in tasks]
+        self.tasks_combo_box.addItems(class_names)
+        self.tasks_combo_box.currentTextChanged.connect(self.task_changed)
+        if self.config.get('target_task') in class_names:
+            self.tasks_combo_box.setText(self.config.get('target_task'))
+        else:
+            self.tasks_combo_box.setCurrentIndex(0)
+
+    def task_changed(self, text):
+        self.config['target_task'] = text
+
+    def select_screenshot(self):
+        file_name, _ = QFileDialog.getOpenFileName(None, "Open Image", "", "Image Files (*.png *.jpg *.bmp)")
+
+        if file_name:
+            logger.info(f"Selected files: {file_name}")
+            self.select_screenshot_button.setText(file_name)
+            self.config['target_image'] = file_name
+        else:
+            self.select_screenshot_button.setText(self.tr("Drop or Select Screenshot"))
+            self.config['target_image'] = None
+
+    def capture(self):
+        if ok.gui.device_manager.capture_method is not None:
+            logger.info(f'ok.gui.device_manager.capture_method {ok.gui.device_manager.capture_method}')
+            capture = str(ok.gui.device_manager.capture_method)
+            frame = ok.gui.device_manager.capture_method.do_get_frame()
+            if frame is not None:
+                file_path = ok.gui.ok.screenshot.generate_screen_shot(frame, ok.gui.ok.screenshot.ui_dict,
+                                                                      ok.gui.ok.screenshot.screenshot_folder, capture)
+
+                # Use subprocess.Popen to open the file explorer and select the file
+                subprocess.Popen(r'explorer /select,"{}"'.format(file_path))
+                logger.info(f'captured screenshot: {capture}')
+                self.alert_info(self.tr('Capture Success'))
+            else:
+                self.alert_error(self.tr('Capture returned None'))
+        else:
+            self.alert_error(self.tr('No Capture Available or Selected'))

{ok-script-0.0.60 → ok-script-0.0.62}/ok/task/TaskExecutor.py

@@ -317,6 +317,9 @@ class TaskExecutor:
     def wait_until_done(self):
         self.thread.join()
 
+    def get_all_tasks(self):
+        return self.onetime_tasks + self.trigger_tasks
+
 
 def list_or_obj_to_str(val):
     if val is not None:

{ok-script-0.0.60 → ok-script-0.0.62}/ok_script.egg-info/PKG-INFO

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

{ok-script-0.0.60 → ok-script-0.0.62}/ok_script.egg-info/SOURCES.txt

@@ -31,6 +31,8 @@ ok/feature/Feature.py
 ok/feature/FeatureSet.py
 ok/feature/FindFeature.py
 ok/feature/__init__.py
+ok/firebase/FireBaseAnalytics.py
+ok/firebase/__init__.py
 ok/gui/App.py
 ok/gui/Communicate.py
 ok/gui/MainWindow.py

{ok-script-0.0.60 → ok-script-0.0.62}/setup.py

@@ -5,7 +5,7 @@ with open("README.md", "r", encoding="utf-8") as fh:
 
 setuptools.setup(
     name="ok-script",
-    version="0.0.60",
+    version="0.0.62",
     author="ok-oldking",
     author_email="firedcto@gmail.com",
     description="Automation with Computer Vision for Python",

ok-script-0.0.60/ok/gui/debug/DebugTab.py

@@ -1,53 +0,0 @@
-import subprocess
-
-from PySide6.QtWidgets import QWidget
-from qfluentwidgets import PushButton, FlowLayout
-
-import ok.gui
-from ok.capture.windows.dump import dump_threads
-from ok.gui.widget.Tab import Tab
-from ok.logging.Logger import get_logger
-from ok.util.Handler import Handler
-
-logger = get_logger(__name__)
-
-
-class DebugTab(Tab):
-    def __init__(self, exit_event):
-        super().__init__()
-        widget = QWidget()
-        layout = FlowLayout(widget, False)
-
-        layout.setContentsMargins(0, 0, 0, 0)
-        layout.setVerticalSpacing(20)
-        layout.setHorizontalSpacing(10)
-        self.addWidget(widget)
-        self.handler = Handler(exit_event, "DebugTab")
-
-        dump_button = PushButton(self.tr("Dump Threads(HotKey:Ctrl+Alt+D)"))
-        dump_button.clicked.connect(lambda: self.handler.post(dump_threads))
-        layout.addWidget(dump_button)
-
-        capture_button = PushButton(self.tr("Capture Screenshot"))
-        capture_button.clicked.connect(lambda: self.handler.post(self.capture))
-        layout.addWidget(capture_button)
-
-        open_log_folder = PushButton(self.tr("Open Logs"))
-
-    def capture(self):
-        if ok.gui.device_manager.capture_method is not None:
-            logger.info(f'ok.gui.device_manager.capture_method {ok.gui.device_manager.capture_method}')
-            capture = str(ok.gui.device_manager.capture_method)
-            frame = ok.gui.device_manager.capture_method.do_get_frame()
-            if frame is not None:
-                file_path = ok.gui.ok.screenshot.generate_screen_shot(frame, ok.gui.ok.screenshot.ui_dict,
-                                                                      ok.gui.ok.screenshot.screenshot_folder, capture)
-
-                # Use subprocess.Popen to open the file explorer and select the file
-                subprocess.Popen(r'explorer /select,"{}"'.format(file_path))
-                logger.info(f'captured screenshot: {capture}')
-                self.alert_info(self.tr('Capture Success'))
-            else:
-                self.alert_error(self.tr('Capture returned None'))
-        else:
-            self.alert_error(self.tr('No Capture Available or Selected'))