ok-script 0.0.7__py3-none-any.whl

autohelper/gui/App.py

@@ -0,0 +1,120 @@
+import os
+import sys
+
+from PySide6.QtCore import QSize, QCoreApplication, QLocale, QTranslator
+from PySide6.QtGui import QIcon
+from PySide6.QtWidgets import QApplication, QStyleFactory, QMenu, QSystemTrayIcon
+
+import autohelper
+import autohelper.gui.resources
+from autohelper.gui.Communicate import communicate
+from autohelper.gui.MainWindow import MainWindow
+from autohelper.gui.i18n.path import i18n_path
+from autohelper.gui.loading.LoadingWindow import LoadingWindow
+from autohelper.gui.overlay.OverlayWindow import OverlayWindow
+from autohelper.logging.Logger import get_logger
+
+logger = get_logger(__name__)
+
+
+class App:
+    def __init__(self, icon=None, overlay=False, title="AutoUI", tasks=None,
+                 exit_event=None):
+        super().__init__()
+        self.app = QApplication(sys.argv)
+        self.app.setStyle(QStyleFactory.create("Fusion"))
+        self.tasks = tasks
+        self.title = title
+        self.overlay = overlay
+        self.loading_window = None
+        self.overlay_window = None
+        self.main_window = None
+        self.exit_event = exit_event
+        self.icon = QIcon(icon or ":/icon/icon.ico")
+        self.tray = QSystemTrayIcon(self.icon)
+
+        locale = QLocale.system().name()
+        translator = QTranslator(self.app)
+        full_path = os.path.join(i18n_path, f"{QLocale().name()}")
+        if translator.load(QLocale().name(), ":/i18n"):
+            translator.setParent(self.app)
+            self.app.installTranslator(translator)
+            QCoreApplication.installTranslator(translator)
+            logger.debug(f"translator install success {QCoreApplication.translate('MainWindow', 'Debug')}")
+        else:
+            logger.debug(f"No translation available for {locale}, falling back to English/default. {full_path}")
+
+        # Create a context menu for the tray
+        menu = QMenu()
+        exit_action = menu.addAction("Exit")
+        exit_action.triggered.connect(self.quit)
+
+        # Set the context menu and show the tray icon
+        self.tray.setContextMenu(menu)
+        self.tray.show()
+
+        communicate.init.connect(self.on_init)
+        communicate.notification.connect(self.show_notification)
+
+    def show_notification(self, title, message):
+        if title is None:
+            title = self.title
+        self.tray.showMessage(title, message)
+
+    def show_loading(self):
+        self.loading_window = LoadingWindow(self, self.exit_event)
+        size = self.size_relative_to_screen(width=0.4, height=0.4)
+        self.loading_window.resize(size)
+        self.loading_window.setMinimumSize(size)
+        self.center_window(self.loading_window)
+        self.loading_window.show()
+
+    def center_window(self, window):
+        screen = self.app.primaryScreen()
+        size = screen.size()
+        # Calculate half the screen size
+        half_screen_width = size.width() / 2
+        half_screen_height = size.height() / 2
+
+        window.move(half_screen_width / 2, half_screen_height / 2)
+
+    def on_init(self, done, message):
+        if done:
+            self.loading_window.loading_done()
+        else:
+            self.loading_window.update_progress(message)
+
+    def show_main_window(self):
+        self.loading_window.close()
+        self.main_window = MainWindow(self.tasks, self.overlay, exit_event=self.exit_event)
+        self.main_window.setWindowTitle(self.title)  # Set the window title here
+        self.main_window.setWindowIcon(self.icon)
+        if self.overlay and autohelper.gui.device_manager.hwnd is not None:
+            self.overlay_window = OverlayWindow(autohelper.gui.device_manager.hwnd)
+
+        size = self.size_relative_to_screen(width=0.5, height=0.6)
+        self.main_window.resize(size)
+        self.main_window.setMinimumSize(size)
+
+        # Optional: Move the window to the center of the screen
+
+        self.main_window.show()
+        self.main_window.raise_()
+        self.main_window.activateWindow()
+
+    def size_relative_to_screen(self, width, height):
+        screen = self.app.primaryScreen()
+        size = screen.size()
+        # Calculate half the screen size
+        half_screen_width = size.width() * width
+        half_screen_height = size.height() * height
+        # Resize the window to half the screen size
+        size = QSize(half_screen_width, half_screen_height)
+        return size
+
+    def exec(self):
+        sys.exit(self.app.exec())
+
+    def quit(self):
+        self.exit_event.set()
+        self.app.quit()

autohelper/gui/Communicate.py

@@ -0,0 +1,22 @@
+import numpy as np
+from PySide6.QtCore import Signal, QObject
+
+
+class Communicate(QObject):
+    frame = Signal(np.ndarray)
+    log = Signal(int, str)
+    fps = Signal(int)
+    frame_time = Signal(int)
+    scene = Signal(str)
+    draw_box = Signal(str, object, str)
+    tasks = Signal()
+    task_info = Signal()
+    window = Signal(bool, int, int, int, int, int, int, float)
+    loading_progress = Signal(str)
+    init = Signal(bool, str)
+    notification = Signal(str, str)
+    executor_paused: Signal = Signal(bool)
+    adb_devices: Signal = Signal()
+
+
+communicate = Communicate()

autohelper/gui/MainWindow.py

@@ -0,0 +1,69 @@
+from PySide6.QtCore import QObject, Signal, Slot
+from PySide6.QtWidgets import QMessageBox, QTabWidget
+
+from autohelper.gui.debug.DebugTab import DebugTab
+from autohelper.gui.tasks.TaskTab import TaskTab
+from autohelper.logging.Logger import get_logger
+
+logger = get_logger(__name__)
+
+
+class Communicate(QObject):
+    speak = Signal(str)
+
+
+class MainWindow(QTabWidget):
+    def __init__(self, tasks, debug=False, exit_event=None):
+        super().__init__()
+        self.exit_event = exit_event
+        task_tab = TaskTab(tasks)
+        self.addTab(task_tab, self.tr("Task"))
+        if debug:
+            debug_tab = DebugTab()
+            self.addTab(debug_tab, self.tr("Debug"))
+        # ... Add other tabs similarly
+
+        # Styling the tabs and content if needed, for example:
+        self.setStyleSheet("""
+                            QTabWidget::tab-bar {
+                                alignment: center;
+                            }
+                            QTabBar::tab {
+                                background: #333;
+                                color: white;
+                                border-radius: 5px;
+                                padding: 10px;
+                            }
+                            QTabBar::tab:selected {
+                                background: #555;
+                                font-weight: bold;
+                            }
+                            QWidget {
+                                background-color: #222;
+                                color: #ddd;
+                            }
+                        """)
+        self.setWindowTitle("Close Event Example")
+        self.setTabPosition(QTabWidget.West)
+        # self.setTabBar(QTabBar())
+        self.comm = Communicate()
+        self.comm.speak.connect(self.say_hello)
+
+    @Slot(str)
+    def say_hello(self, message):
+        print(message)
+
+    def btn_clicked(self):
+        self.comm.speak.emit("Hello, PySide6 with parameters!")
+
+    def closeEvent(self, event):
+        # Create a message box that asks the user if they really want to close the window
+        reply = QMessageBox.question(self, 'Window Close', 'Are you sure you want to close the window?',
+                                     QMessageBox.Yes | QMessageBox.No, QMessageBox.No)
+
+        if reply == QMessageBox.Yes:
+            self.exit_event.set()
+            event.accept()
+            logger.info("Window closed")  # Place your code here
+        else:
+            event.ignore()

autohelper/gui/TabTitles.py

@@ -0,0 +1,56 @@
+from PySide6.QtCore import QRect, QPoint, Qt
+from PySide6.QtWidgets import QTabBar, QStylePainter, QStyleOptionTab, QStyle, QWidget
+from PySide6.QtWidgets import QTabWidget, QVBoxLayout, QLabel
+
+
+class TabBar(QTabBar):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+
+    def tabSizeHint(self, index):
+        s = QTabBar.tabSizeHint(self, index)
+        if s.width() < s.height():
+            s.transpose()
+        s.scale(s.width() * 2, s.height() * 2, Qt.KeepAspectRatio)
+        return s
+
+    # Make text visible adequately
+    def paintEvent(self, event):
+        painter = QStylePainter(self)
+        style_option = QStyleOptionTab()
+
+        for i in range(self.count()):
+            self.initStyleOption(style_option, i)
+            painter.drawControl(QStyle.CE_TabBarTabShape, style_option)
+            painter.save()
+
+            s = style_option.rect.size()
+            s.scale(s.width() * 2, s.height() * 2, Qt.KeepAspectRatio)
+            rect = QRect(QPoint(), s)
+            rect.moveCenter(style_option.rect.center())
+            style_option.rect = rect
+
+            center = self.tabRect(i).center()
+            painter.translate(center)
+            painter.rotate(90)
+            painter.translate(center * -1)
+            painter.drawControl(QStyle.CE_TabBarTabLabel, style_option)
+            painter.restore()
+
+
+class VerticalTabWidget(QTabWidget):
+    def __init__(self):
+        super().__init__()
+        self.setTabBar(TabBar(self))
+        self.setTabPosition(QTabWidget.West)
+
+    # def setTabSize(self, width, height):
+
+
+class TabContent(QWidget):
+    def __init__(self, text):
+        super().__init__()
+        layout = QVBoxLayout()
+        label = QLabel(text)
+        layout.addWidget(label)
+        self.setLayout(layout)

autohelper/gui/__init__.py

@@ -0,0 +1,5 @@
+from autohelper.capture.adb.DeviceManager import DeviceManager
+
+executor = None
+app = None
+device_manager: DeviceManager | None = None

autohelper/gui/debug/AspectRatioWidget.py

@@ -0,0 +1,31 @@
+from PySide6.QtCore import QSize
+from PySide6.QtWidgets import QWidget, QVBoxLayout, QSizePolicy
+
+
+class AspectRatioWidget(QWidget):
+    def __init__(self, child_widget, aspect_ratio=16 / 9, parent=None):
+        super(AspectRatioWidget, self).__init__(parent)
+        self.aspect_ratio = aspect_ratio
+        self.child_widget = child_widget
+        self.layout = QVBoxLayout(self)
+        self.layout.addWidget(child_widget)
+        self.setSizePolicy(QSizePolicy.MinimumExpanding, QSizePolicy.MinimumExpanding)
+
+    def resizeEvent(self, event):
+        w = event.size().width()
+        h = event.size().height()
+        new_width = h * self.aspect_ratio
+        new_height = w / self.aspect_ratio
+        if new_height > h:
+            self.child_widget.setFixedSize(QSize(new_width, h))
+        else:
+            self.child_widget.setFixedSize(QSize(w, new_height))
+        super().resizeEvent(event)
+
+    def sizeHint(self):
+        # Provide a default size hint that respects the aspect ratio
+        height = 200  # Default height
+        return QSize(int(height * self.aspect_ratio), height)
+
+    def set_ratio(self, aspect_ratio):
+        self.aspect_ratio = aspect_ratio

autohelper/gui/debug/DebugTab.py

@@ -0,0 +1,37 @@
+from PySide6.QtCore import Qt
+from PySide6.QtWidgets import QWidget, QGridLayout, QSplitter
+
+from autohelper.gui.debug.FrameWidget import FrameWidget
+from autohelper.gui.debug.InfoWidget import InfoWidget
+from autohelper.gui.debug.LoggerWidget import LoggerWidget
+
+
+class DebugTab(QWidget):
+    def __init__(self):
+        super().__init__()
+
+        self.mainLayout = QGridLayout()
+        self.setLayout(self.mainLayout)
+
+        # Top row setup with horizontal splitter
+        self.topSplitter = QSplitter(Qt.Horizontal)
+        self.topSplitter.setMinimumHeight(300)
+        self.info_widget = InfoWidget()
+        self.info_widget.setFixedWidth(200)
+        self.frame_widget = FrameWidget(True)
+        self.topSplitter.addWidget(self.info_widget)
+        self.topSplitter.addWidget(self.frame_widget)
+
+        # Bottom row setup
+        self.logger = LoggerWidget()
+
+        # Main splitter to handle top and bottom rows
+        self.mainSplitter = QSplitter(Qt.Vertical)
+        self.mainSplitter.addWidget(self.topSplitter)
+        self.mainSplitter.addWidget(self.logger)
+
+        # Add the main splitter to the layout
+        self.mainLayout.addWidget(self.mainSplitter, 0, 0)
+
+        self.mainSplitter.setStretchFactor(0, 8)  # 30% for the top widget
+        self.mainSplitter.setStretchFactor(1, 2)  # 70%

autohelper/gui/debug/FrameWidget.py

@@ -0,0 +1,125 @@
+import time
+
+import numpy as np
+from PySide6.QtCore import Qt
+from PySide6.QtGui import QPainter, QImage, QPixmap, QColor, QPen
+from PySide6.QtWidgets import QWidget
+
+from autohelper.feature.Box import Box
+from autohelper.gui.Communicate import communicate
+
+
+class FrameWidget(QWidget):
+    def __init__(self, draw_frame=False, parent=None):
+        super(FrameWidget, self).__init__(parent)
+        self.cv_image = None
+        self.color_map = {
+            "red": QColor(255, 0, 0),  # RGB for red
+            "green": QColor(0, 255, 0),  # RGB for green
+            "blue": QColor(0, 0, 255)  # RGB for blue
+        }
+        self.uiDict = {}
+        self.time_to_expire = 3
+        self.draw_frame = draw_frame
+        self.frame_width = 1
+        self._visible = True
+        communicate.frame.connect(self.set_image)
+        communicate.draw_box.connect(self.draw_box)
+
+    def remove_expired(self):
+        current_time = time.time()
+        for key in list(self.uiDict.keys()):
+            # Filter out the old UI elements and keep the remaining ones
+            if current_time - self.uiDict[key][1] > self.time_to_expire:
+                del self.uiDict[key]
+
+    def draw_box(self, key: str, boxes, color=None):
+        if boxes is None:
+            return
+        if isinstance(boxes, Box):
+            boxes = [boxes]
+        if len(boxes) == 0:
+            return
+        timestamp = time.time()
+        brush = self.color_map.get(color, self.color_map.get("red"))
+        if key:
+            self.uiDict[key] = [boxes, timestamp, brush]
+        else:
+            for box in boxes:
+                self.uiDict[box.name] = [[box], timestamp, brush]
+        self.update()
+
+    def set_image(self, cv_image):
+        """Set the OpenCV image to be displayed."""
+        self.frame_width = cv_image.shape[1]
+        if self.draw_frame:
+            self.cv_image = cv_image
+            self.update()  # Trigger a repaint
+
+    def paintEvent(self, event):
+        if not self._visible:
+            return
+        painter = QPainter(self)
+        x_offset = 0
+        y_offset = 0
+        if self.cv_image is not None:
+            frame = np.ascontiguousarray(self.cv_image)
+            # frame = self.cv_image
+            frame_height, frame_width = frame.shape[:2]
+
+            # Convert the OpenCV image (BGR) to QImage format (RGB)
+            # h, w, ch = self.cv_image.shape
+            # bytes_per_line = ch * w
+            # convert_to_Qt_format = QImage(self.cv_image.data, w, h, bytes_per_line, QImage.Format_RGB888)
+            # qt_image = convert_to_Qt_format.rgbSwapped()
+
+            qt_image = QImage(frame.data, frame.shape[1], frame.shape[0],
+                              frame.strides[0],
+                              QImage.Format_BGR888)
+            # qt_image = QImage(frame.data, frame.shape[1], frame.shape[0],
+            #                   frame.strides[0],
+            #                   QImage.Format_RGBA8888)
+
+            # Scaling the image to fit the aspect ratio of the widget
+            qt_image = qt_image.scaled(self.size(), Qt.KeepAspectRatio, Qt.SmoothTransformation)
+
+            # Calculate the position to center the image in the widget
+            x_offset = (self.width() - qt_image.width()) / 2
+            y_offset = (self.height() - qt_image.height()) / 2
+
+            frame_ratio = qt_image.width() / frame_width
+
+            painter.drawPixmap(x_offset, y_offset, QPixmap.fromImage(qt_image))
+        else:
+            frame_ratio = self.width() / self.frame_width
+            self.paint_border(painter)
+        self.paint_boxes(frame_ratio, painter, x_offset, y_offset)
+
+    def paint_boxes(self, frame_ratio, painter, x_offset, y_offset):
+        pen = QPen()  # Set the brush to red color
+        pen.setWidth(2)  # Set the width of the pen (border thickness)
+        painter.setPen(pen)  # Apply the pen to the painter
+        painter.setBrush(Qt.NoBrush)  # Ensure no fill
+        # painter.setFont(QFont('Arial', 12))
+        # Draw a square. Arguments are (x, y, width, height).
+        # Adjust these values according to the desired size and position.
+        self.remove_expired()
+        for key, value in self.uiDict.items():
+            boxes = value[0]
+            pen.setColor(value[2])
+            painter.setPen(pen)
+            for box in boxes:
+                width = box.width * frame_ratio
+                height = box.height * frame_ratio
+                x = x_offset + box.x * frame_ratio
+                y = y_offset + box.y * frame_ratio
+                painter.drawRect(x, y, width, height)
+                painter.drawText(x, y + height + 12, f"{box.name or key}_{round(box.confidence * 100)}")
+
+    def paint_border(self, painter):
+        pen = QPen(QColor(255, 0, 0, 255))  # Solid red color for the border
+        pen.setWidth(1)  # Set the border width
+        painter.setPen(pen)
+
+        # Draw the border around the widget
+        painter.drawRect(0, 0, self.width() - 1, self.height() - 1)

autohelper/gui/debug/InfoWidget.py

@@ -0,0 +1,40 @@
+from PySide6.QtWidgets import QWidget, QVBoxLayout, QLabel
+
+from autohelper.gui.Communicate import communicate
+
+
+class InfoWidget(QWidget):
+
+    def __init__(self):
+        super().__init__()
+        self.init_ui()
+        # Connect the custom signal to the slot that updates the values
+        communicate.fps.connect(self.update_fps)
+        communicate.scene.connect(self.update_scene)
+        communicate.frame_time.connect(self.update_frame_time)
+
+    def init_ui(self):
+        self.layout = QVBoxLayout(self)
+
+        self.scene_widget = QLabel()
+        self.layout.addWidget(self.scene_widget)
+        self.update_scene("None")
+
+        self.fps_widget = QLabel()
+        self.layout.addWidget(self.fps_widget)
+        self.update_fps(0)
+
+        self.frame_time_widget = QLabel()
+        self.layout.addWidget(self.frame_time_widget)
+        self.update_frame_time(0)
+
+        self.layout.addStretch()
+
+    def update_fps(self, fps):
+        self.fps_widget.setText(f"FPS: {fps}")
+
+    def update_frame_time(self, fps):
+        self.frame_time_widget.setText(f"FrameTime: {fps}")
+
+    def update_scene(self, scene):
+        self.scene_widget.setText(f"Scene: {scene}")

autohelper/gui/debug/LoggerWidget.py

@@ -0,0 +1,74 @@
+import logging
+
+from PySide6.QtWidgets import (QWidget, QVBoxLayout, QHBoxLayout, QComboBox, QLineEdit, QTextEdit)
+
+from autohelper.gui.Communicate import communicate
+
+level_map = {'DEBUG': logging.DEBUG, 'INFO': logging.INFO, 'WARNING': logging.WARNING, 'ERROR': logging.ERROR,
+             'CRITICAL': logging.CRITICAL}
+
+
+def get_colored_message(level, message):
+    if level >= logging.ERROR:
+        color = "red"
+    elif level == logging.WARNING:
+        color = "darkorange"  # Dark yellow can be represented as 'darkorange' for better visibility
+    else:
+        return message
+    return f'<span style="color: {color};">{message}</span>'
+
+
+class LoggerWidget(QWidget):
+    # Define log levels
+
+    def __init__(self, parent=None):
+        super(LoggerWidget, self).__init__(parent)
+        self.max_length = 1000
+        self.init_ui()
+        self.logs = []  # Store logs as tuples (level, message)
+        communicate.log.connect(self.add_log)
+
+    def init_ui(self):
+        self.layout = QVBoxLayout(self)
+
+        # Filter controls
+        controls_layout = QHBoxLayout()
+        self.level_filter = QComboBox()
+        self.level_filter.addItems(level_map.keys())
+        self.level_filter.currentTextChanged.connect(self.update_display)
+
+        self.text_filter = QLineEdit()
+        self.text_filter.setPlaceholderText("Filter logs by text...")
+        self.text_filter.textChanged.connect(self.update_display)
+
+        controls_layout.addWidget(self.level_filter)
+        controls_layout.addWidget(self.text_filter)
+
+        # Log display
+        self.log_display = QTextEdit()
+        self.log_display.setReadOnly(True)
+
+        # Add widgets to layout
+        self.layout.addLayout(controls_layout)
+        self.layout.addWidget(self.log_display)
+
+    def add_log(self, level, message):
+        self.logs.append((level, message))
+        if len(self.logs) > self.max_length:
+            # Calculate how many elements to remove
+            excess_length = len(self.logs) - self.max_length
+            # Remove the oldest elements
+            del self.logs[:excess_length]
+        self.update_display()
+
+    def update_display(self):
+        filtered_logs = self.filter_logs()
+        self.log_display.clear()
+        for level, message in filtered_logs:
+            colored_message = get_colored_message(level, message)
+            self.log_display.append(colored_message)
+
+    def filter_logs(self):
+        level = level_map[self.level_filter.currentText()]
+        text = self.text_filter.text().lower()
+        return [(lvl, msg) for lvl, msg in self.logs if (lvl >= level) and text in msg.lower()]

autohelper/gui/i18n/path.py

@@ -0,0 +1,3 @@
+import os
+
+i18n_path = os.path.dirname(__file__)

autohelper/gui/icon/icon.py

@@ -0,0 +1,6 @@
+import os
+
+script_dir = os.path.dirname(os.path.realpath(__file__))
+
+# Get the path of the file relative to the script
+icon_path = os.path.join(script_dir, 'icon.ico')