ok-script 0.0.7__py3-none-any.whl

autohelper/gui/tasks/StartButton.py

@@ -0,0 +1,47 @@
+from PySide6.QtCore import Slot, QPropertyAnimation
+from PySide6.QtGui import QColor
+from PySide6.QtWidgets import QPushButton
+
+import autohelper
+from autohelper.gui.Communicate import communicate
+from autohelper.gui.util.Alert import show_alert
+from autohelper.logging.Logger import get_logger
+
+logger = get_logger(__name__)
+
+
+class StartButton(QPushButton):
+    def __init__(self):
+        super().__init__("Start")
+        self.setCheckable(True)
+        self.clicked.connect(self.toggle_text)
+        self.animation = QPropertyAnimation(self, b"color")
+        self.update_paused(True)
+        communicate.executor_paused.connect(self.update_paused)
+
+    def update_paused(self, paused):
+        if paused:
+            self.setText(self.tr("Start All"))
+            self.setChecked(False)
+            self.animation.stop()
+        else:
+            self.setText(self.tr("Pause All"))
+            self.setChecked(True)
+            self.start_animation()
+
+    @Slot()
+    def toggle_text(self):
+        if self.isChecked():
+            logger.info("Click Start Executor")
+            if not autohelper.gui.executor.start():
+                show_alert("Error", "No Task to Run, Please Enable Task First!")
+                self.setChecked(False)
+        else:
+            logger.info("Click Pause Executor")
+            autohelper.gui.executor.pause()
+
+    def start_animation(self):
+        self.animation.setStartValue(QColor(0, 0, 0))
+        self.animation.setEndValue(QColor(255, 255, 255))
+        self.animation.setDuration(1000)
+        self.animation.start()

autohelper/gui/tasks/TaskOpButton.py

@@ -0,0 +1,33 @@
+from PySide6.QtCore import Slot
+from PySide6.QtWidgets import QPushButton
+
+from autohelper.logging.Logger import get_logger
+from autohelper.task.BaseTask import BaseTask
+
+logger = get_logger(__name__)
+
+
+class TaskOpButton(QPushButton):
+    def __init__(self, task: BaseTask):
+        super().__init__("Enable")
+        self.clicked.connect(self.toggle_text)
+        self.task = task
+
+    def update_task(self, task: BaseTask):
+        if task.enabled:
+            if task.done:
+                self.setText(self.tr("Rerun"))
+            else:
+                self.setText(self.tr("Disable"))
+        else:
+            self.setText(self.tr("Enable"))
+
+    @Slot()
+    def toggle_text(self):
+        if self.task.enabled:
+            if self.task.done:
+                self.task.enable()
+            else:
+                self.task.disable()
+        else:
+            self.task.disable()

autohelper/gui/tasks/TaskTab.py

@@ -0,0 +1,121 @@
+from typing import List
+
+from PySide6.QtCore import Qt, QTimer
+from PySide6.QtGui import QColor
+from PySide6.QtWidgets import QTableWidget, QTableWidgetItem, QVBoxLayout, QWidget, QHBoxLayout
+
+from autohelper.gui.Communicate import communicate
+from autohelper.gui.tasks.ConfigItemFactory import config_widget_item
+from autohelper.gui.tasks.StartButton import StartButton
+from autohelper.gui.tasks.TaskOpButton import TaskOpButton
+from autohelper.gui.tasks.TooltipTableWidget import TooltipTableWidget
+from autohelper.gui.widget.RoundCornerContainer import RoundCornerContainer
+from autohelper.gui.widget.UpdateConfigWidgetItem import value_to_string
+from autohelper.logging.Logger import get_logger
+from autohelper.task.BaseTask import BaseTask
+
+logger = get_logger(__name__)
+
+
+class TaskTab(QWidget):
+    def __init__(self, tasks: List[BaseTask]):
+        super().__init__()
+
+        self.mainLayout = QVBoxLayout(self)
+        self.setLayout(self.mainLayout)
+        self.tasks = tasks
+        # Top row setup with horizontal splitter
+        self.top_layout = QHBoxLayout()
+        self.task_table = TooltipTableWidget([0.7, 0.15, 0.15])
+        self.task_container = RoundCornerContainer(self.tr('Tasks'), self.task_table)
+        self.start_button = StartButton()
+        self.task_container.add_top_widget(self.start_button)
+
+        self.top_layout.addWidget(self.task_container)
+        self.task_labels = [self.tr('Name'), self.tr('Status'), self.tr('Operation')]
+        self.create_table()
+        self.mainLayout.addLayout(self.top_layout)
+
+        self.task_config_table = TooltipTableWidget([0.3, 0.7])
+        self.task_config_container = RoundCornerContainer(self.tr('Tasks Config'), self.task_config_table)
+        self.task_config_labels = [self.tr('Config'), self.tr('Value')]
+        self.task_config_table.setColumnCount(len(self.task_config_labels))  # Name and Value
+        self.task_config_table.setHorizontalHeaderLabels(self.task_config_labels)
+        self.update_config_table()
+        self.mainLayout.addWidget(self.task_config_container)
+
+        self.task_info_table = TooltipTableWidget([0.3, 0.7])
+        self.task_info_container = RoundCornerContainer(self.tr('Tasks Info'), self.task_info_table)
+        self.top_layout.addWidget(self.task_info_container)
+        self.task_info_labels = [self.tr('Info'), self.tr('Value')]
+        self.task_info_table.setColumnCount(len(self.task_info_labels))  # Name and Value
+        self.task_info_table.setHorizontalHeaderLabels(self.task_config_labels)
+        self.update_info_table()
+
+        communicate.tasks.connect(self.update_table)
+        communicate.task_info.connect(self.update_info_table)
+        self.timer = QTimer()
+        self.timer.timeout.connect(self.update_info_table)
+        self.timer.timeout.connect(self.update_table)
+        self.timer.start(1000)
+
+    def update_config_table(self):
+        task = self.tasks[self.task_table.selectedIndexes()[0].row()]
+        config = task.config
+        self.task_config_container.title_label.setText(f"{self.tr('Config')}: {task.name}")
+        self.task_config_table.setRowCount(len(config))
+        for row, (key, value) in enumerate(config.items()):
+            if not self.task_config_table.item(row, 0):
+                item0 = self.uneditable_item()
+                self.task_config_table.setItem(row, 0, item0)
+            self.task_config_table.item(row, 0).setText(key)
+            config_widget_item(self.task_config_table, row, 1, config, key, value)
+
+    def update_info_table(self):
+        task = self.tasks[self.task_table.selectedIndexes()[0].row()]
+        info = task.info
+        self.task_info_container.title_label.setText(f"{self.tr('Info')}: {task.name}")
+        self.task_info_table.setRowCount(len(info))
+        for row, (key, value) in enumerate(info.items()):
+            if not self.task_info_table.item(row, 0):
+                item0 = self.uneditable_item()
+                self.task_info_table.setItem(row, 0, item0)
+            self.task_info_table.item(row, 0).setText(key)
+            if not self.task_info_table.item(row, 1):
+                item1 = self.uneditable_item()
+                self.task_info_table.setItem(row, 1, item1)
+            self.task_info_table.item(row, 1).setText(value_to_string(value))
+
+    def create_table(self):
+        self.task_table.setRowCount(len(self.tasks))  # Adjust the row count to match the number of attributes
+        self.task_table.setColumnCount(len(self.task_labels))  # Name and Value
+        self.task_table.setHorizontalHeaderLabels(self.task_labels)
+        self.task_table.setSelectionBehavior(QTableWidget.SelectRows)
+        self.task_table.setSelectionMode(QTableWidget.SingleSelection)
+        self.task_table.selectRow(0)
+        self.task_table.itemSelectionChanged.connect(self.update_config_table)
+        for row, task in enumerate(self.tasks):
+            for i in range(2):
+                item = self.uneditable_item()
+                self.task_table.setItem(row, i, item)
+            op_button = TaskOpButton(task)
+            self.task_table.setCellWidget(row, 2, op_button)
+        self.update_table()
+
+    def uneditable_item(self):
+        item = QTableWidgetItem()
+        item.setFlags(item.flags() & ~Qt.ItemIsEditable)
+        return item
+
+    def update_table(self):
+        for row, task in enumerate(self.tasks):
+            self.task_table.item(row, 0).setText(task.name)
+            status = task.get_status()
+            self.task_table.item(row, 1).setText(self.tr(status))
+            if status == "Running":
+                self.task_table.item(row, 1).setBackground(QColor("green"))
+            elif status == "Disabled":
+                self.task_table.item(row, 1).setBackground(QColor("red"))
+            else:
+                self.task_table.item(row, 1).setBackground(QColor(0, 0, 0, 0))
+            self.task_table.cellWidget(row, 2).update_task(task)

autohelper/gui/tasks/TooltipTableWidget.py

@@ -0,0 +1,39 @@
+from PySide6.QtCore import QEvent
+from PySide6.QtWidgets import QTableWidget, QToolTip, QHeaderView
+
+
+class TooltipTableWidget(QTableWidget):
+
+    def __init__(self, width_percentages=None):
+        super().__init__()
+        self.verticalHeader().setVisible(False)
+        self.width_percentages = width_percentages
+
+        # Set the QTableWidget to fill the width of its parent
+        self.horizontalHeader().setStretchLastSection(True)
+
+        # Set the columns to resize to fill the width of the QTableWidget
+        self.horizontalHeader().setSectionResizeMode(QHeaderView.Stretch)
+        self.setWordWrap(True)
+
+    def setItem(self, row, column, item):
+        super().setItem(row, column, item)
+
+    def resizeEvent(self, event):
+        if self.width_percentages is not None:
+            width = self.width() - self.verticalScrollBar().width()
+            for i, percentage in enumerate(self.width_percentages):
+                self.setColumnWidth(i, int(width * percentage))
+        super().resizeEvent(event)
+
+    def viewportEvent(self, event):
+        if event.type() == QEvent.ToolTip:
+            pos = event.pos()
+            item = self.itemAt(pos)
+            if item:
+                if self.visualItemRect(item).width() < self.fontMetrics().horizontalAdvance(item.text()):
+                    QToolTip.showText(event.globalPos(), item.text(), self)
+                else:
+                    QToolTip.hideText()
+                return True
+        return super().viewportEvent(event)

autohelper/gui/util/Alert.py

@@ -0,0 +1,20 @@
+from PySide6.QtWidgets import QMessageBox
+
+import autohelper
+
+
+def show_alert(title, message):
+    # Create a QMessageBox
+    msg = QMessageBox()
+
+    # Set the title and message
+    msg.setWindowTitle(title)
+    msg.setText(message)
+
+    msg.setWindowIcon(autohelper.gui.app.icon)
+
+    # Add a confirm button
+    msg.setStandardButtons(QMessageBox.Ok)
+
+    # Show the message box
+    msg.exec()

autohelper/gui/util/InitWorker.py

@@ -0,0 +1,17 @@
+from PySide6.QtCore import QThread
+
+from autohelper.gui.Communicate import communicate
+from autohelper.logging.Logger import get_logger
+
+logger = get_logger(__name__)
+
+
+class InitWorker(QThread):
+
+    def __init__(self, fun):
+        super().__init__()
+        self.fun = fun
+
+    def run(self):
+        self.fun()
+        communicate.init.emit(True, "")

autohelper/gui/widget/ListTableWidgetItem.py

@@ -0,0 +1,27 @@
+from PySide6.QtCore import Qt
+from PySide6.QtWidgets import QTableWidgetItem
+
+from autohelper.gui.widget.UpdateConfigWidgetItem import UpdateConfigWidgetItem, value_to_string
+
+
+class ListTableWidgetItem(UpdateConfigWidgetItem, QTableWidgetItem):
+
+    def __init__(self, config, key, value, parent=None):
+        UpdateConfigWidgetItem.__init__(self, config, key, value)
+        QTableWidgetItem.__init__(self)
+        self.setText(value_to_string(value))
+
+    def setData(self, role, value):
+        if role == Qt.EditRole:
+            list_value = convert_to_list(value)
+            self.set_value(list_value)
+            self.setText(value_to_string(list_value))
+        super().setData(role, value)
+
+
+def convert_to_list(s):
+    # Replace the Chinese comma with the English comma
+    s = s.replace("，", ",")
+
+    # Split the string by comma and strip the white spaces
+    return [item.strip() for item in s.split(",")]

autohelper/gui/widget/NumericTableWidgetItem.py

@@ -0,0 +1,33 @@
+from PySide6.QtCore import Qt
+from PySide6.QtGui import QIntValidator, QDoubleValidator
+from PySide6.QtWidgets import QTableWidgetItem
+
+from autohelper.gui.widget.UpdateConfigWidgetItem import UpdateConfigWidgetItem, value_to_string
+
+
+class NumericTableWidgetItem(UpdateConfigWidgetItem, QTableWidgetItem):
+
+    def __init__(self, config, key, value, parent=None):
+        UpdateConfigWidgetItem.__init__(self, config, key, value)
+        QTableWidgetItem.__init__(self)
+
+        # Determine if the original value is int or float
+        if isinstance(value, int):
+            self.validator = QIntValidator(0, 999999, self.tableWidget())
+        elif isinstance(value, float):
+            self.validator = QDoubleValidator(0, 999999, 2, self.tableWidget())
+        else:
+            raise ValueError("Value must be an int or float")
+        self.setText(value_to_string(value))
+
+    def setData(self, role, value):
+        if role == Qt.EditRole:
+            state, _, _ = self.validator.validate(str(value), 0)
+            if state != QIntValidator.Acceptable:
+                return
+            if isinstance(self.value, int):
+                value = int(value)
+            else:
+                value = float(value)
+            self.set_value(value)
+        super().setData(role, value)

autohelper/gui/widget/RoundCornerContainer.py

@@ -0,0 +1,59 @@
+from PySide6.QtGui import QPalette
+from PySide6.QtWidgets import QVBoxLayout, QLabel, QFrame, QSizePolicy, QLayout, QWidget, QHBoxLayout, QSpacerItem
+
+
+class RoundCornerContainer(QFrame):
+    def __init__(self, title, child=None, parent=None):
+        super(RoundCornerContainer, self).__init__(parent)
+
+        # Set the layout
+        self.top_layout = QHBoxLayout()
+        layout = QVBoxLayout(self)
+        self.title_label = QLabel(title)
+        self.title_label.setSizePolicy(QSizePolicy.Minimum, QSizePolicy.Minimum)
+        self.top_layout.addWidget(self.title_label)
+        self.top_layout.addItem(QSpacerItem(0, 0, QSizePolicy.Expanding, QSizePolicy.Minimum))
+        layout.addLayout(self.top_layout)
+        if child is not None and isinstance(child, QWidget):
+            child.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
+            layout.addWidget(child)
+        elif child is not None and isinstance(child, QLayout):
+            child.setSizeConstraint(QVBoxLayout.SetMaximumSize)
+            layout.addLayout(child)
+            layout.setStretchFactor(child, 1)
+        layout.setStretchFactor(self.title_label, 0)
+
+        self.setLayout(layout)
+
+        self.setFrameStyle(QFrame.Panel | QFrame.Raised)
+        self.setLineWidth(2)
+
+        color = self.get_palette_color(QPalette.Base)
+        self.setStyleSheet(f"background-color:{color};")
+
+    def add_top_widget(self, widget):
+        self.top_layout.addWidget(widget)
+
+    def get_palette_color(self, palette_color):
+        palette = self.palette()
+        return color_to_hex(palette.color(palette_color))
+
+
+def color_to_hex(color):
+    """Converts a QColor object to a hex string representation.
+
+    Args:
+        color: The QColor object to convert.
+
+    Returns:
+        A string representing the hex code of the color (e.g., "#FF0000" for red).
+    """
+    red = color.red()
+    green = color.green()
+    blue = color.blue()
+    hex_color = f"#{red:02X}{green:02X}{blue:02X}"
+    return hex_color
+
+# Usage:
+# widget = RoundCornerContainer("Title")
+# widget.show()

autohelper/gui/widget/TabWidget.py

@@ -0,0 +1,30 @@
+from PySide6.QtGui import QPalette
+from PySide6.QtWidgets import QWidget
+
+
+class TabWidget(QWidget):
+
+    def __init__(self):
+        super().__init__()
+        color = self.get_palette_color(QPalette.Base)
+        self.setStyleSheet(f"background-color:{color};")
+
+    def get_palette_color(self, palette_color):
+        palette = self.palette()
+        return color_to_hex(palette.color(palette_color))
+
+
+def color_to_hex(color):
+    """Converts a QColor object to a hex string representation.
+
+    Args:
+        color: The QColor object to convert.
+
+    Returns:
+        A string representing the hex code of the color (e.g., "#FF0000" for red).
+    """
+    red = color.red()
+    green = color.green()
+    blue = color.blue()
+    hex_color = f"#{red:02X}{green:02X}{blue:02X}"
+    return hex_color

autohelper/gui/widget/UpdateConfigWidgetItem.py

@@ -0,0 +1,16 @@
+class UpdateConfigWidgetItem:
+    def __init__(self, config, key, value):
+        self.key = key
+        self.config = config
+        self.value = value
+
+    def set_value(self, value):
+        self.config[self.key] = value
+        self.value = value
+
+
+def value_to_string(obj):
+    if isinstance(obj, list):
+        return ', '.join(map(str, obj))
+    else:
+        return str(obj)

autohelper/gui/widget/YesNonWidgetItem.py

@@ -0,0 +1,23 @@
+from PySide6.QtWidgets import QComboBox
+
+from autohelper.gui.widget.UpdateConfigWidgetItem import UpdateConfigWidgetItem
+
+
+class YesNonWidgetItem(UpdateConfigWidgetItem, QComboBox):
+
+    def __init__(self, config, key, value):
+        UpdateConfigWidgetItem.__init__(self, config, key, value)
+        QComboBox.__init__(self)
+        self.addItems(["Yes", "No"])
+        if value:
+            self.setCurrentIndex(0)
+        else:
+            self.setCurrentIndex(1)
+
+        self.currentIndexChanged.connect(self.index_changed)
+
+    def index_changed(self, index):
+        if index == 0:
+            self.set_value(True)
+        else:
+            self.set_value(False)

autohelper/interaction/ADBInteraction.py

@@ -0,0 +1,33 @@
+from autohelper.interaction.BaseInteraction import BaseInteraction
+from autohelper.logging.Logger import get_logger
+
+logger = get_logger(__name__)
+
+
+class ADBBaseInteraction(BaseInteraction):
+
+    def __init__(self, device_manager, capture):
+        super().__init__(capture)
+        self.device_manager = device_manager
+        logger.info(f"width: {self.width}, height: {self.height}")
+        if self.width == 0 or self.height == 0:
+            logger.warning(f"Could not parse screen resolution.")
+            # raise RuntimeError(f"ADBBaseInteraction: Could not parse screen resolution.")
+
+    @property
+    def width(self):
+        return self.device_manager.width
+
+    @property
+    def height(self):
+        return self.device_manager.height
+
+    def send_key(self, key, down_time=0.02):
+        super().send_key(key, down_time)
+        self.device_manager.device.shell(f"input keyevent {key}")
+
+    def click(self, x=-1, y=-1):
+        super().click(x, y)
+        x = int(x * self.width / self.capture.width)
+        y = int(y * self.height / self.capture.height)
+        self.device_manager.device.shell(f"input tap {x} {y}")

autohelper/interaction/BaseInteraction.py

@@ -0,0 +1,36 @@
+from autohelper.feature.Box import Box
+from autohelper.gui.Communicate import communicate
+from autohelper.logging.Logger import get_logger
+
+logger = get_logger(__name__)
+
+
+class BaseInteraction:
+
+    def __init__(self, capture):
+        self.capture = capture
+
+    def should_capture(self):
+        return True
+    
+    def send_key(self, key, down_time=0.02):
+        pass
+
+    def move(self, x, y):
+        pass
+
+    def click_relative(self, x, y):
+        self.click(int(self.capture.width * x), int(self.capture.height * y))
+
+    def move_relative(self, x, y):
+        self.move(int(self.capture.width * x), int(self.capture.height * y))
+
+    def click_box(self, box: Box, relative_x=0.5, relative_y=0.5):
+        logger.info(f"click_box {box}")
+        x, y = box.relative_with_variance(relative_x, relative_y)
+        self.click(x, y)
+
+    def click(self, x=-1, y=-1):
+        logger.info(f"click {x, y}")
+        communicate.draw_box.emit("click", [Box(max(0, x - 10), max(0, y - 10), 20, 20, name="click")], "green")
+        pass

autohelper/interaction/Win32Interaction.py

@@ -0,0 +1,56 @@
+import ctypes
+import time
+
+import pydirectinput
+
+from autohelper.capture.BaseCaptureMethod import BaseCaptureMethod
+from autohelper.interaction.BaseInteraction import BaseInteraction
+from autohelper.logging.Logger import get_logger
+
+logger = get_logger(__name__)
+
+
+class Win32Interaction(BaseInteraction):
+
+    def __init__(self, capture: BaseCaptureMethod):
+        super().__init__(capture)
+        self.post = ctypes.windll.user32.PostMessageW
+        if not is_admin():
+            logger.error(f"You must be an admin to use Win32Interaction")
+
+    def send_key(self, key, down_time=0.02):
+        if not self.capture.clickable():
+            return
+        pydirectinput.keyDown(key)
+        time.sleep(down_time)
+        pydirectinput.keyUp(key)
+
+    def move(self, x, y):
+        if not self.capture.clickable():
+            return
+        x, y = self.capture.get_abs_cords(x, y)
+        pydirectinput.moveTo(x, y)
+
+    def click(self, x=-1, y=-1):
+        super().click(x, y)
+        if not self.capture.clickable():
+            logger.info(f"window in background, not clickable")
+            return
+        # Convert the x, y position to lParam
+        # lParam = win32api.MAKELONG(x, y)
+        if x != -1 and y != -1:
+            x, y = self.capture.get_abs_cords(x, y)
+            logger.info(f"left_click {x, y}")
+            pydirectinput.moveTo(x, y)
+        pydirectinput.click()
+
+    def should_capture(self):
+        return self.capture.clickable()
+
+
+def is_admin():
+    try:
+        # Only Windows users with admin privileges can read the C drive directly
+        return ctypes.windll.shell32.IsUserAnAdmin()
+    except:
+        return False