ok-script 0.0.40__tar.gz → 0.0.42__tar.gz

{ok-script-0.0.40 → ok-script-0.0.42}/PKG-INFO

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

{ok-script-0.0.40 → ok-script-0.0.42}/ok/OK.py

@@ -34,7 +34,7 @@ class OK:
             self.config = config
             self.init_device_manager()
             from ok.gui.debug.Screenshot import Screenshot
-            self.screenshot = Screenshot()
+            self.screenshot = Screenshot(self.exit_event)
             if config.get("use_gui"):
                 from ok.gui.App import App
                 self.app = App(config, self.exit_event)
@@ -123,7 +123,8 @@ class OK:
     def quit(self):
         logger.debug('quit app')
         self.exit_event.set()
-        self.device_manager.stop()
+        if self.device_manager is not None:
+            self.device_manager.stop()
         if self.app:
             self.app.quit()
 

{ok-script-0.0.40 → ok-script-0.0.42}/ok/capture/BaseCaptureMethod.py

@@ -8,13 +8,6 @@ class CaptureException(Exception):
 class BaseCaptureMethod:
     name = "None"
     description = ""
-    last_captured_frame: np.ndarray
-    top_cut = 0
-    bottom_cut = 0
-    left_cut = 0
-    right_cut = 0
-    width = 0
-    height = 0
     _size = (0, 0)
 
     def __init__(self):

{ok-script-0.0.40 → ok-script-0.0.42}/ok/capture/HwndWindow.py

@@ -11,7 +11,6 @@ from win32 import win32gui
 from ok.capture.windows.window import is_foreground_window, get_window_bounds
 from ok.gui.Communicate import communicate
 from ok.logging.Logger import get_logger
-from ok.util.exit_event import ExitEvent
 
 logger = get_logger(__name__)
 
@@ -41,7 +40,7 @@ class HwndWindow:
         super().__init__()
         self.app_exit_event = exit_event
         self.exe_name = exe_name
-        self.stop_event = ExitEvent()
+        self.stop_event = threading.Event()
         self.update_title_re(title)
         self.visible = False
         self.update_frame_size(frame_width, frame_height)
@@ -102,7 +101,7 @@ class HwndWindow:
                     visible = is_foreground_window(self.hwnd)
                     x, y, border, title_height, width, height, scaling = get_window_bounds(
                         self.hwnd)
-                    if self.frame_aspect_ratio != 0:
+                    if self.frame_aspect_ratio != 0 and height != 0:
                         window_ratio = width / height
                         if window_ratio < self.frame_aspect_ratio:
                             cropped_window_height = int(width / self.frame_aspect_ratio)
@@ -125,7 +124,7 @@ class HwndWindow:
                     changed = True
                 if changed:
                     logger.debug(
-                        f"do_update_window_size changed: {self.visible} {self.x} {self.y} {self.border} {self.width} {self.height} {self.scaling}")
+                        f"do_update_window_size changed,visible:{self.visible} x:{self.x} y:{self.y} border:{self.border} width:{self.width} height:{self.height} self.title_height:{self.title_height} scaling:{self.scaling}")
                     communicate.window.emit(self.visible, self.x, self.y, self.border, self.title_height, self.width,
                                             self.height, self.scaling)
         except Exception as e:
@@ -143,37 +142,29 @@ class HwndWindow:
         return ""
 
 
-def find_hwnd_by_title_and_exe(title, exe):
-    if not title and not exe:
-        return None
-    hwnds = find_hwnds_by_title(title)
-    if exe is not None:
-        for hwnd in hwnds:
-            exe_2 = get_exe_name_by_hwnd(hwnd)
-            if exe_2 == exe:
-                return hwnd
-    if len(hwnds) > 0:
-        return hwnds[0]
-
-
-def find_hwnds_by_title(title):
-    hwnds = []
-    if not title:
-        return hwnds
-
-    def enum_windows_proc(hwnd, lParam):
-        text = win32gui.GetWindowText(hwnd)
-        if text and win32gui.IsWindowVisible(hwnd):
-            if isinstance(title, str) and title == text:
-                hwnds.append(hwnd)
-            elif re.search(title, text):
-                hwnds.append(hwnd)
-
-    win32gui.EnumWindows(enum_windows_proc, None)
-    if len(hwnds) > 0:
-        if len(hwnds) > 1:
-            logger.warning(f"Found multiple hwnds {len(hwnds)}")
-    return hwnds
+def find_hwnd_by_title_and_exe(title, exe_name):
+    result = []
+
+    def callback(hwnd, lParam):
+        if len(result) == 0 and win32gui.IsWindowVisible(hwnd) and win32gui.IsWindowEnabled(hwnd):
+            if title:
+                text = win32gui.GetWindowText(hwnd)
+                if isinstance(title, str):
+                    if title != text:
+                        return True
+                elif not re.search(title, text):
+                    return True
+            if exe_name:
+                name = get_exe_name_by_hwnd(hwnd)
+                if name == exe_name:
+                    result.append(hwnd)
+                    return True  # Stop enumeration as we found the first match
+            else:
+                result.append(hwnd)
+        return True
+
+    win32gui.EnumWindows(callback, None)
+    return result[0] if result else None
 
 
 OpenProcess = ctypes.windll.kernel32.OpenProcess

{ok-script-0.0.40 → ok-script-0.0.42}/ok/capture/adb/DeviceManager.py

@@ -26,6 +26,7 @@ class DeviceManager:
         self.adb = self.adb = adbutils.AdbClient(host="127.0.0.1")
         logger.debug(f'connect adb')
         self.hwnd_title = hwnd_title
+        self.pc_device = None
         self.exe_name = exe_name
         self.debug = debug
         self.interaction = None
@@ -44,7 +45,13 @@ class DeviceManager:
 
     @property
     def device_dict(self):
-        return self.config.get("devices")
+        device_dict = self.config.get("devices")
+        if self.pc_device is not None:
+            full = {'pc': self.pc_device}
+            full.update(device_dict)
+            return full
+        else:
+            return device_dict
 
     def connect_all(self):
         if not self._connect_all:
@@ -61,7 +68,6 @@ class DeviceManager:
         return list(self.device_dict.values())
 
     def do_refresh(self):
-        self.connect_all()
 
         if self.hwnd_title:
             nick = ""
@@ -74,16 +80,18 @@ class DeviceManager:
                     hwnd)
             if not nick:
                 nick = self.exe_name
-            self.device_dict[self.hwnd_title] = {"address": "", "imei": self.hwnd_title, "device": "windows",
-                                                 "model": "", "nick": nick, "width": width,
-                                                 "height": height,
-                                                 "hwnd": nick, "capture": "windows",
-                                                 "connected": hwnd is not None
-                                                 }
+            self.pc_device = {"address": "", "imei": 'pc', "device": "windows",
+                              "model": "", "nick": nick, "width": width,
+                              "height": height,
+                              "hwnd": nick, "capture": "windows",
+                              "connected": hwnd is not None
+                              }
             if width != 0:
-                self.device_dict[self.hwnd_title]["resolution"] = f"{width}x{height}"
+                self.pc_device["resolution"] = f"{width}x{height}"
             communicate.adb_devices.emit(False)
 
+        self.connect_all()
+
         installed_emulators = installed_emulator()
         for device in self.adb.list():
             logger.debug(f'adb.list() {device}')

{ok-script-0.0.40 → ok-script-0.0.42}/ok/capture/windows/WindowsGraphicsCaptureMethod.py

@@ -32,7 +32,7 @@ class WindowsGraphicsCaptureMethod(BaseCaptureMethod):
     description = "fast, most compatible, capped at 60fps"
     last_frame = None
     last_frame_time = 0
-    hwnd_window: HwndWindow = None
+    _hwnd_window: HwndWindow = None
     frame_pool = None
     item = None
     session = None
@@ -42,7 +42,7 @@ class WindowsGraphicsCaptureMethod(BaseCaptureMethod):
 
     def __init__(self, hwnd_window: HwndWindow):
         super().__init__()
-        self.hwnd_window = hwnd_window
+        self._hwnd_window = hwnd_window
         self.start_or_stop()
 
     def frame_arrived_callback(self, x, y):
@@ -108,38 +108,50 @@ class WindowsGraphicsCaptureMethod(BaseCaptureMethod):
                 return self.get_frame()
         self.last_frame = img
 
+    @property
+    def hwnd_window(self):
+        return self._hwnd_window
+
+    @hwnd_window.setter
+    def hwnd_window(self, hwnd_window):
+        self._hwnd_window = hwnd_window
+        self.start_or_stop()
+
     def connected(self):
-        return self.hwnd_window is not None and self.hwnd_window.exists
+        return self.hwnd_window is not None and self.hwnd_window.exists and self.frame_pool is not None
 
     def start_or_stop(self, capture_cursor=False):
-        if self.hwnd_window.exists and self.frame_pool is None:
-            logger.info('init windows capture')
-            self.rtdevice = IDirect3DDevice()
-            self.dxdevice = d3d11.ID3D11Device()
-            self.immediatedc = d3d11.ID3D11DeviceContext()
-            self.create_device()
-            interop = GetActivationFactory('Windows.Graphics.Capture.GraphicsCaptureItem').astype(
-                IGraphicsCaptureItemInterop)
-            item = interop.CreateForWindow(self.hwnd_window.hwnd, IGraphicsCaptureItem.GUID)
-            self.item = item
-            self.last_size = item.Size
-            delegate = TypedEventHandler(GraphicsCaptureItem, IInspectable).delegate(
-                self.close)
-            self.evtoken = item.add_Closed(delegate)
-            self.frame_pool = Direct3D11CaptureFramePool.CreateFreeThreaded(self.rtdevice,
-                                                                            DirectXPixelFormat.B8G8R8A8UIntNormalized,
-                                                                            1, item.Size)
-            self.session = self.frame_pool.CreateCaptureSession(item)
-            pool = self.frame_pool
-            pool.add_FrameArrived(
-                TypedEventHandler(Direct3D11CaptureFramePool, IInspectable).delegate(
-                    self.frame_arrived_callback))
-            self.session.IsCursorCaptureEnabled = capture_cursor
-            if WINDOWS_BUILD_NUMBER >= WGC_NO_BORDER_MIN_BUILD:
-                self.session.IsBorderRequired = False
-            self.session.StartCapture()
-        elif not self.hwnd_window.exists and self.frame_pool is not None:
-            self.close()
+        try:
+            if self.hwnd_window.exists and self.frame_pool is None:
+                logger.info('init windows capture')
+                self.rtdevice = IDirect3DDevice()
+                self.dxdevice = d3d11.ID3D11Device()
+                self.immediatedc = d3d11.ID3D11DeviceContext()
+                self.create_device()
+                interop = GetActivationFactory('Windows.Graphics.Capture.GraphicsCaptureItem').astype(
+                    IGraphicsCaptureItemInterop)
+                item = interop.CreateForWindow(self.hwnd_window.hwnd, IGraphicsCaptureItem.GUID)
+                self.item = item
+                self.last_size = item.Size
+                delegate = TypedEventHandler(GraphicsCaptureItem, IInspectable).delegate(
+                    self.close)
+                self.evtoken = item.add_Closed(delegate)
+                self.frame_pool = Direct3D11CaptureFramePool.CreateFreeThreaded(self.rtdevice,
+                                                                                DirectXPixelFormat.B8G8R8A8UIntNormalized,
+                                                                                1, item.Size)
+                self.session = self.frame_pool.CreateCaptureSession(item)
+                pool = self.frame_pool
+                pool.add_FrameArrived(
+                    TypedEventHandler(Direct3D11CaptureFramePool, IInspectable).delegate(
+                        self.frame_arrived_callback))
+                self.session.IsCursorCaptureEnabled = capture_cursor
+                if WINDOWS_BUILD_NUMBER >= WGC_NO_BORDER_MIN_BUILD:
+                    self.session.IsBorderRequired = False
+                self.session.StartCapture()
+            elif not self.hwnd_window.exists and self.frame_pool is not None:
+                self.close()
+        except Exception as e:
+            logger.error('start_or_stop failed:', exception=e)
         return self.hwnd_window.exists
 
     def create_device(self):

{ok-script-0.0.40 → ok-script-0.0.42}/ok/config/Config.py

@@ -1,16 +1,18 @@
+from ok.gui.Communicate import communicate
 from ok.util.json import read_json_file, write_json_file
 from ok.util.path import get_path_relative_to_exe
 
 
 class Config:
-    def __init__(self, default, folder, name):
+    def __init__(self, default, folder, name, validator=None):
         super().__init__()
         self.default = default
+        self.validator = validator
         self.config_file = get_path_relative_to_exe(folder, f"{name}.json")
         self.config = read_json_file(self.config_file)
         if self.config is None:
             self.config = default
-        elif verify_config(self.config, default):
+        elif self.verify_config(self.config, default):
             self.save_file()
 
     def save_file(self):
@@ -60,26 +62,39 @@ class Config:
         return len(self.config)
 
     def __setitem__(self, key, value):
-        self.config[key] = value
-        self.save_file()
+        if self.validate(key, value):
+            self.config[key] = value
+            self.save_file()
 
     def __getitem__(self, key):
         return self.config[key]
 
-
-def verify_config(config, default_config):
-    modified = False
-
-    # Remove entries that do not exist in default_config
-    for key in list(config.keys()):
-        if key not in default_config:
-            del config[key]
-            modified = True
-
-    # Check entries in default_config
-    for key, default_value in default_config.items():
-        if key not in config or type(config[key]) != type(default_value):
-            config[key] = default_value
-            modified = True
-
-    return not modified
+    def validate(self, key, value):
+        if self.validator is not None:
+            valid, message = self.validator(key, value)
+            if not valid:
+                communicate.config_validation.emit(message)
+                return False
+        return True
+
+    def verify_config(self, config, default_config):
+        modified = False
+
+        # Remove entries that do not exist in default_config
+        for key in list(config.keys()):
+            if key not in default_config:
+                del config[key]
+                modified = True
+
+        # Check entries in default_config
+        for key, default_value in default_config.items():
+            if key not in config or type(config[key]) != type(default_value):
+                config[key] = default_value
+                modified = True
+            elif self.validator is not None:
+                valid = self.validate(key, self.config[key])
+                if not valid:
+                    config[key] = default_value
+                    modified = True
+
+        return not modified

{ok-script-0.0.40 → ok-script-0.0.42}/ok/gui/Communicate.py

@@ -17,6 +17,7 @@ class Communicate(QObject):
     screenshot = Signal(np.ndarray, str)
     update_overlay = Signal()
     adb_devices: Signal = Signal(bool)
+    config_validation: Signal = Signal(str)
     tab = Signal(str)
     capture_error = Signal()
 

{ok-script-0.0.40 → ok-script-0.0.42}/ok/gui/MainWindow.py

@@ -67,6 +67,20 @@ class MainWindow(MSFluentWindow):
 
         communicate.capture_error.connect(self.capture_error)
         communicate.notification.connect(self.show_notification)
+        communicate.config_validation.connect(self.config_validation)
+
+    def config_validation(self, message):
+        title = self.tr('Error')
+        InfoBar.error(
+            title=title,
+            content=message,
+            orient=Qt.Horizontal,
+            isClosable=True,
+            position=InfoBarPosition.TOP,
+            duration=5000,  # won't disappear automatically
+            parent=self.window()
+        )
+        self.tray.showMessage(title, message)
 
     def show_notification(self, message, title=None, error=None):
         bar = InfoBar.error if error else InfoBar.info

{ok-script-0.0.40 → ok-script-0.0.42}/ok/gui/debug/Screenshot.py

@@ -20,10 +20,9 @@ logger = get_logger(__name__)
 
 class Screenshot(QObject):
 
-    def __init__(self):
+    def __init__(self, exit_event):
         super().__init__()
         self.queue = []
-        self.exit_event = ok.gui.ok.exit_event
         self.time_to_expire = 3
         self.ui_dict = {}
         self.color_map = {
@@ -31,10 +30,13 @@ class Screenshot(QObject):
             "green": QColor(0, 255, 0),  # RGB for green
             "blue": QColor(0, 0, 255)  # RGB for blue
         }
+        self.exit_event = exit_event
         communicate.draw_box.connect(self.draw_box)
         communicate.screenshot.connect(self.screenshot)
         self.click_screenshot_folder = get_path_relative_to_exe(ok.gui.ok.config.get("click_screenshots_folder"))
         self.screenshot_folder = get_path_relative_to_exe(ok.gui.ok.config.get("screenshots_folder"))
+        logger.debug(f"init Screenshot {self.screenshot_folder} {self.click_screenshot_folder}")
+        print(f"init Screenshot {self.screenshot_folder} {self.screenshot_folder}")
         if self.click_screenshot_folder is not None or self.screenshot_folder is not None:
             self.task_queue = queue.Queue()
             self.exit_event.bind_queue(self.task_queue)
@@ -106,6 +108,7 @@ class Screenshot(QObject):
         pil_image = self.to_pil_image(frame)
         if pil_image is None:
             return
+        self.save_pil_image(name + '_original', folder, pil_image)
         # Ensure no fill
         draw = ImageDraw.Draw(pil_image)
 
@@ -127,6 +130,11 @@ class Screenshot(QObject):
                 # Put text
                 draw.text((x, y + height + 8), f"{box.name or key}_{round(box.confidence * 100)}", fill=color,
                           font=self.pil_font)
+        self.save_pil_image(name + '_boxed', folder, pil_image)
+
+    def save_pil_image(self, name, folder, pil_image):
+
+        logger.debug(f'save_pil_image {name}, {folder}')
         now = datetime.now()
 
         # Convert to string with milliseconds
@@ -142,6 +150,7 @@ class Screenshot(QObject):
             pil_image.save(os.path.join(folder, f"{time_string}.png"))
 
     def stop(self):
+        logger.debug(f'stop screenshot')
         if self.task_queue is not None:
             self.task_queue.put(None)
 

{ok-script-0.0.40 → ok-script-0.0.42}/ok/gui/tasks/ConfigItemFactory.py

@@ -6,20 +6,20 @@ from ok.gui.tasks.LabelAndSwitchButton import LabelAndSwitchButton
 from ok.gui.tasks.ModifyListItem import ModifyListItem
 
 
-def config_widget(config, config_desc, config_type, key, value):
-    the_type = config_type.get(key)
+def config_widget(task, key, value):
+    the_type = task.config_type.get(key)
     if the_type:
         if the_type['type'] == 'drop_down':
-            return LabelAndDropDown(config, config_desc, the_type['options'], key)
+            return LabelAndDropDown(task, the_type['options'], key)
     if isinstance(value, bool):
-        return LabelAndSwitchButton(config, config_desc, key)
+        return LabelAndSwitchButton(task, key)
     elif isinstance(value, list):
-        return ModifyListItem(config, config_desc, key)
+        return ModifyListItem(task, key)
     elif isinstance(value, int):
-        return LabelAndSpinBox(config, config_desc, key)
+        return LabelAndSpinBox(task, key)
     elif isinstance(value, float):
-        return LabelAndDoubleSpinBox(config, config_desc, key)
+        return LabelAndDoubleSpinBox(task, key)
     elif isinstance(value, str):
-        return LabelAndLineEdit(config, config_desc, key)
+        return LabelAndLineEdit(task, key)
     else:
         raise ValueError(f"invalid type {type(value)}, value {value}")

ok-script-0.0.42/ok/gui/tasks/ConfigLabelAndWidget.py

@@ -0,0 +1,16 @@
+from ok.gui.tasks.LabelAndWidget import LabelAndWidget
+
+
+class ConfigLabelAndWidget(LabelAndWidget):
+
+    def __init__(self, task, key: str):
+        desc = None
+        self.key = key
+        self.task = task
+        self.config = task.config
+        if task.config_description is not None:
+            desc = task.config_description.get(key)
+        super().__init__(key, desc)
+
+    def update_config(self, value):
+        self.config[self.key] = value

{ok-script-0.0.40 → ok-script-0.0.42}/ok/gui/tasks/LabelAndDoubleSpinBox.py

@@ -5,10 +5,9 @@ from ok.gui.tasks.ConfigLabelAndWidget import ConfigLabelAndWidget
 
 class LabelAndDoubleSpinBox(ConfigLabelAndWidget):
 
-    def __init__(self, config, config_desc, key: str):
-        super().__init__(config_desc, key)
+    def __init__(self, task, key: str):
+        super().__init__(task, key)
         self.key = key
-        self.config = config
         self.spin_box = DoubleSpinBox()
         self.update_value()
         self.spin_box.valueChanged.connect(self.value_changed)
@@ -18,4 +17,4 @@ class LabelAndDoubleSpinBox(ConfigLabelAndWidget):
         self.spin_box.setValue(self.config.get(self.key))
 
     def value_changed(self, value):
-        self.config[self.key] = value
+        self.update_config(value)

{ok-script-0.0.40 → ok-script-0.0.42}/ok/gui/tasks/LabelAndDropDown.py

@@ -5,10 +5,9 @@ from ok.gui.tasks.ConfigLabelAndWidget import ConfigLabelAndWidget
 
 class LabelAndDropDown(ConfigLabelAndWidget):
 
-    def __init__(self, config, config_desc, options, key: str):
-        super().__init__(config_desc, key)
+    def __init__(self, task, options, key: str):
+        super().__init__(task, key)
         self.key = key
-        self.config = config
         self.combo_box = ComboBox()
         self.combo_box.addItems(options)
         self.combo_box.setCurrentIndex(find_string_index(options, self.config.get(self.key)))
@@ -17,7 +16,7 @@ class LabelAndDropDown(ConfigLabelAndWidget):
         self.add_widget(self.combo_box)
 
     def text_changed(self, text):
-        self.config[self.key] = text
+        self.update_config(text)
 
 
 def find_string_index(my_list, target_string):

{ok-script-0.0.40 → ok-script-0.0.42}/ok/gui/tasks/LabelAndLineEdit.py

@@ -5,10 +5,9 @@ from ok.gui.tasks.ConfigLabelAndWidget import ConfigLabelAndWidget
 
 class LabelAndLineEdit(ConfigLabelAndWidget):
 
-    def __init__(self, config, config_desc, key: str):
-        super().__init__(config_desc, key)
+    def __init__(self, task, key: str):
+        super().__init__(task, key)
         self.key = key
-        self.config = config
         self.line_edit = LineEdit()
         self.update_value()
         self.line_edit.textChanged.connect(self.value_changed)
@@ -18,4 +17,4 @@ class LabelAndLineEdit(ConfigLabelAndWidget):
         self.line_edit.setText(self.config.get(self.key))
 
     def value_changed(self, value):
-        self.config[self.key] = value
+        self.update_config(value)

{ok-script-0.0.40 → ok-script-0.0.42}/ok/gui/tasks/LabelAndSpinBox.py

@@ -5,10 +5,9 @@ from ok.gui.tasks.ConfigLabelAndWidget import ConfigLabelAndWidget
 
 class LabelAndSpinBox(ConfigLabelAndWidget):
 
-    def __init__(self, config, config_desc, key: str):
-        super().__init__(config_desc, key)
+    def __init__(self, task, key: str):
+        super().__init__(task, key)
         self.key = key
-        self.config = config
         self.spin_box = SpinBox()
         self.spin_box.setFixedWidth(130)
         self.update_value()
@@ -19,4 +18,4 @@ class LabelAndSpinBox(ConfigLabelAndWidget):
         self.spin_box.setValue(self.config.get(self.key))
 
     def value_changed(self, value):
-        self.config[self.key] = value
+        self.update_config(value)

{ok-script-0.0.40 → ok-script-0.0.42}/ok/gui/tasks/LabelAndSwitchButton.py

@@ -5,10 +5,9 @@ from ok.gui.tasks.ConfigLabelAndWidget import ConfigLabelAndWidget
 
 class LabelAndSwitchButton(ConfigLabelAndWidget):
 
-    def __init__(self, config, config_desc, key: str):
-        super().__init__(config_desc, key)
+    def __init__(self, task, key: str):
+        super().__init__(task, key)
         self.key = key
-        self.config = config
         self.switch_button = SwitchButton()
         self.switch_button.setOnText(self.tr('Yes'))
         self.switch_button.setOffText(self.tr('No'))
@@ -20,4 +19,4 @@ class LabelAndSwitchButton(ConfigLabelAndWidget):
         self.switch_button.setChecked(self.config.get(self.key))
 
     def check_changed(self, checked):
-        self.config[self.key] = checked
+        self.update_config(checked)

{ok-script-0.0.40 → ok-script-0.0.42}/ok/gui/tasks/ModifyListItem.py

@@ -8,10 +8,8 @@ from ok.gui.widget.UpdateConfigWidgetItem import value_to_string
 
 class ModifyListItem(ConfigLabelAndWidget):
 
-    def __init__(self, config, config_desc, key: str):
-        super().__init__(config_desc, key)
-        self.key = key
-        self.config = config
+    def __init__(self, task, key: str):
+        super().__init__(task, key)
         self.switch_button = PushButton(self.tr('Modify'))
         self.switch_button.clicked.connect(self.clicked)
         self.list_text = QLabel("")
@@ -20,7 +18,15 @@ class ModifyListItem(ConfigLabelAndWidget):
         self.add_widget(self.switch_button)
 
     def update_value(self):
-        self.list_text.setText(value_to_string(self.config.get(self.key)))
+        items = self.config.get(self.key)
+        total_length = sum(len(item) for item in items)
+
+        if total_length > 30:
+            display_text = "\n".join(items)
+        else:
+            display_text = value_to_string(items)
+
+        self.list_text.setText(display_text)
 
     def clicked(self):
         dialog = ModifyListDialog(self.config.get(self.key), self.window())
@@ -28,5 +34,5 @@ class ModifyListItem(ConfigLabelAndWidget):
         dialog.exec()
 
     def list_modified(self, the_list):
-        self.config[self.key] = the_list
+        self.update_config(the_list)
         self.update_value()

{ok-script-0.0.40 → ok-script-0.0.42}/ok/gui/tasks/TaskCard.py

@@ -61,7 +61,7 @@ class TaskCard(ExpandSettingCard):
             self.task.disable()
 
     def __addConfig(self, key: str, value):
-        widget = config_widget(self.task.config, self.task.config_description, self.task.config_type, key, value)
+        widget = config_widget(self.task, key, value)
         self.config_widgets.append(widget)
         self.viewLayout.addWidget(widget)
         self._adjustViewSize()