ok-script 0.0.91__tar.gz → 0.0.94__tar.gz

{ok-script-0.0.91 → ok-script-0.0.94}/PKG-INFO

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

{ok-script-0.0.91 → ok-script-0.0.94}/ok/OK.py

@@ -37,6 +37,9 @@ class OK:
         config['debug'] = config.get("debug", False)
         self.debug = config['debug']
         try:
+            if self.debug:
+                import win32api
+                win32api.SetConsoleCtrlHandler(self.console_handler, True)
             self.config = config
             self.init_device_manager()
             from ok.gui.debug.Screenshot import Screenshot
@@ -59,6 +62,7 @@ class OK:
             if self.config.get("use_gui"):
                 if not self.init_error:
                     self.app.show_main_window()
+                logger.debug('start app.exec()')
                 self.app.exec()
             else:
                 self.task_executor.start()
@@ -135,6 +139,26 @@ class OK:
         while not self.exit_event.is_set():
             time.sleep(1)
 
+    def console_handler(self, event):
+        import win32con
+        if event == win32con.CTRL_C_EVENT:
+            logger.info("CTRL+C event dump threads")
+            from ok.capture.windows.dump import dump_threads
+            dump_threads()
+            self.quit()
+        elif event == win32con.CTRL_CLOSE_EVENT:
+            logger.info("Close event quit")
+            self.quit()
+        elif event == win32con.CTRL_LOGOFF_EVENT:
+            logger.info("Logoff event quit")
+            self.quit()
+        elif event == win32con.CTRL_SHUTDOWN_EVENT:
+            logger.info("Shutdown event quit")
+            self.quit()
+        else:  # Perform clean-up tasks here
+            print("Performing clean-up...")
+        return True
+
     def quit(self):
         logger.debug('quit app')
         self.exit_event.set()

{ok-script-0.0.91 → ok-script-0.0.94}/ok/capture/adb/DeviceManager.py

@@ -67,7 +67,7 @@ class DeviceManager:
                         logger.debug(f'adb_connect already connected {addr}')
                         return device
             if try_connect:
-                self.adb.connect(addr, timeout=5)
+                self.adb.connect(addr, timeout=3)
                 logger.debug(f'adb_connect {addr}')
                 return self.adb_connect(addr, try_connect=False)
         except AdbTimeout as e:
@@ -116,8 +116,8 @@ class DeviceManager:
             if imei is not None:
                 preferred = self.get_preferred_device()
                 if current and preferred is not None and preferred['imei'] != imei:
-                    logger.debug(f"refresh current only skip others {preferred['imei']} != imei")
-                    break
+                    logger.debug(f"refresh current only skip others {preferred['imei']} != {imei}")
+                    continue
                 found = False
                 for device in self.device_dict.values():
                     if device.get('adb_imei') == imei:

ok-script-0.0.94/ok/capture/windows/dump.py

@@ -0,0 +1,83 @@
+import os
+import signal
+import sys
+import threading
+import traceback
+
+from ok.util.path import get_path_relative_to_exe
+
+
+def get_thread_name(thread_id):
+    for thread in threading.enumerate():
+        if thread.ident == thread_id:
+            return thread.name
+    return ""  # Return empty string if the thread name is not found
+
+
+def dump_threads():
+    # Get the stack trace for each thread
+    thread_dumps = []
+    for thread_id, frame in sys._current_frames().items():
+        thread_name = get_thread_name(thread_id)
+        thread_dump = f"Stack for thread {thread_id} (Name: {thread_name}):\n"
+        thread_dump += "".join(traceback.format_stack(frame))
+        thread_dumps.append(thread_dump)
+
+    # Write the thread dumps to a file
+    output_file = get_path_relative_to_exe(os.path.join('logs', "thread_dumps.txt"))
+    print(f'Dumping threads to {output_file}')
+
+    with open(output_file, "w") as file:
+        # Open the file with UTF-8 encoding
+        with open('file.txt', 'w', encoding='utf-8') as f:
+            f.write("\n\n".join(thread_dumps))
+
+        # subprocess.Popen(r'explorer /select,"{}"'.format(output_file))
+
+
+def kill_dump():
+    print("Killing dump")
+    dump_threads()
+    sys.exit(0)
+
+
+def console_handler(event):
+    import win32con
+    if event == win32con.CTRL_C_EVENT:
+        print("CTRL+C event")
+        dump_threads()
+        sys.exit(0)
+    elif event == win32con.CTRL_CLOSE_EVENT:
+        print("Close event")
+    elif event == win32con.CTRL_LOGOFF_EVENT:
+        print("Logoff event")
+    elif event == win32con.CTRL_SHUTDOWN_EVENT:
+        print("Shutdown event")
+    # Perform clean-up tasks here
+    print("Performing clean-up...")
+    # sys.exit(0)  # Exit the program
+    return True
+
+
+if __name__ == '__main__':
+
+    import psutil
+    import faulthandler
+
+    # Enable the fault handler
+    faulthandler.enable()
+
+    # Iterate over all running processes
+    for proc in psutil.process_iter(['pid', 'name', 'status', 'exe']):
+        # Check if the process is unresponsive
+        # print(proc.info['exe'])
+        if proc.info['name'] == 'python.exe':
+            # Dump the traceback
+            print(f'dump {proc.pid} {proc.cmdline()} {proc.info["pid"] == os.getpid()}')
+            # faulthandler.dump_traceback(file=sys.stderr, all_threads=True)
+            # Kill the process
+            # os.kill(proc.info['pid'], signal.SIGTERM)
+
+    # faulthandler.dump_traceback(file=sys.stderr, all_threads=True)
+    # Kill the process
+    os.kill(16916, signal.SIGTERM)

ok-script-0.0.94/ok/feature/CompressCoco.py

@@ -0,0 +1,61 @@
+import json
+import os
+import sys
+
+import cv2
+from PIL import Image
+
+from ok.feature.FeatureSet import read_from_json
+
+
+def compress_coco(coco_json) -> None:
+    feature_dict, *_ = read_from_json(coco_json)
+    with open(coco_json, 'r') as file:
+        image_dict = {}
+        data = json.load(file)
+        coco_folder = os.path.dirname(coco_json)
+        image_map = {image['id']: image['file_name'] for image in data['images']}
+        category_map = {category['id']: category['name'] for category in data['categories']}
+
+        for annotation in data['annotations']:
+            image_id = annotation['image_id']
+            category_id = annotation['category_id']
+
+            feature = feature_dict.get(category_map[category_id])
+            if feature:
+                # Load and scale the image
+                image_path = str(os.path.join(coco_folder, image_map[image_id]))
+                image_features = image_dict.get(image_path, [])
+                image_features.append(feature)
+                image_dict[image_path] = image_features
+
+        # Loop through the image_dict and write all the image_feature associated with it in a new PNG
+        for image_path, features in image_dict.items():
+            background = None
+            for feature in features:
+                # Create a white background
+                if not background:
+                    original_image = cv2.imread(image_path)
+                    background = Image.new('RGBA', (original_image.shape[1], original_image.shape[0]),
+                                           (255, 255, 255, 255))
+                # Convert the OpenCV image (numpy array) to a PIL image
+                image = Image.fromarray(cv2.cvtColor(feature.mat, cv2.COLOR_BGR2RGBA))
+                background.paste(image, (feature.x, feature.y), image)
+                # Save the image with compression level 9
+            # background.save(image_path, 'PNG', optimize=True, compress_level=9)
+
+            # Add metadata
+            metadata = {
+                "ok_compressed": "1"
+            }
+
+            for key, value in metadata.items():
+                background.info[key] = value
+
+            # Save the image with metadata
+            background.save(image_path, 'PNG', optimize=True)
+
+
+if __name__ == '__main__':
+    json_file = sys.argv[1]
+    compress_coco(json_file)

{ok-script-0.0.91 → ok-script-0.0.94}/ok/feature/Feature.py

@@ -14,10 +14,16 @@ class Feature:
             height (int): The height of the bounding box.
         """
         self.mat = mat
-        self.x = x
-        self.y = y
-        self.width = width
-        self.height = height
+        self.x = round(x)
+        self.y = round(y)
+
+    @property
+    def width(self):
+        return self.mat.shape[1]
+
+    @property
+    def height(self):
+        return self.mat.shape[0]
 
     def __str__(self) -> str:
         return f'self.x: {self.x}, self.y: {self.y}, width: {self.width}, height: {self.height}'

{ok-script-0.0.91 → ok-script-0.0.94}/ok/feature/FeatureSet.py

@@ -7,6 +7,7 @@ from typing import List
 
 import cv2
 import numpy as np
+from PIL import Image
 
 from ok.feature.Box import Box, sort_boxes
 from ok.feature.Feature import Feature
@@ -33,7 +34,6 @@ class FeatureSet:
             height (int): Scale images to this height.
         """
         self.coco_json = resource_path(coco_json)
-        self.coco_folder = os.path.dirname(self.coco_json)
         self.debug = debug
 
         logger.debug(f'Loading features from {self.coco_json}')
@@ -67,59 +67,12 @@ class FeatureSet:
             width (int): Target width for scaling images.
             height (int): Target height for scaling images.
         """
-        if self.debug:
-            folder_size = sum(os.path.getsize(os.path.join(dirpath, filename))
-                              for dirpath, dirnames, filenames in os.walk(self.coco_folder)
-                              for filename in filenames)
-            # Convert size to MB
-            folder_size_mb = folder_size / (1024 * 1024)
-            if folder_size_mb > 5:
-                from ok.feature.CompressCoco import compress_coco
-                logger.info(f'template folder greater than 5MB try to compress the COCO dataset')
-                compress_coco(self.coco_json)
-        self.feature_dict.clear()
-        self.box_dict.clear()
-        with open(self.coco_json, 'r') as file:
-            data = json.load(file)
-
-        # Create a map from image ID to file name
-        image_map = {image['id']: image['file_name'] for image in data['images']}
-
-        # Create a map from category ID to category name
-        category_map = {category['id']: category['name'] for category in data['categories']}
-
-        for annotation in data['annotations']:
-            image_id = annotation['image_id']
-            category_id = annotation['category_id']
-            bbox = annotation['bbox']
-
-            # Load and scale the image
-            image_path = str(os.path.join(self.coco_folder, image_map[image_id]))
-            image = cv2.imread(image_path)
-            _, original_width = image.shape[:2]
-            if image is None:
-                logger.error(f'Could not read image {image_path}')
-                continue
-            x, y, w, h = bbox
-            if self.width != image.shape[1] or self.height != image.shape[0]:
-                scale_x, scale_y = self.width / image.shape[1], self.height / image.shape[0]
-                logger.debug(f'scaling images {scale_x}, {scale_y}')
-                image = cv2.resize(image, (self.width, self.height))
-                # Calculate the scaled bounding box
-                x, y, w, h = x * scale_x, y * scale_y, w * scale_x, h * scale_y
-
-            # Crop the image to the bounding box
-            image = image[round(y):round(y + h), round(x):round(x + w), :3]
-
-            # Store in featureDict using the category name
-            category_name = category_map[category_id]
-            logger.debug(
-                f"loaded {category_name} resized width {self.width} / original_width:{original_width},scale_x:{self.width / original_width}")
-            if category_name in self.feature_dict:
-                raise ValueError(f"Multiple boxes found for category {category_name}")
-            if not category_name.startswith('box_'):
-                self.feature_dict[category_name] = Feature(image, x, y, w, h)
-            self.box_dict[category_name] = Box(x, y, w, h, name=category_name)
+        self.feature_dict, self.box_dict, compressed = read_from_json(self.coco_json, self.width, self.height)
+        if self.debug and not compressed:
+            from ok.feature.CompressCoco import compress_coco
+            logger.info(f'coco not compressed try to compress the COCO dataset')
+            compress_coco(self.coco_json)
+            self.feature_dict, self.box_dict, compressed = read_from_json(self.coco_json, self.width, self.height)
 
     def get_box_by_name(self, mat, category_name: str) -> Box:
         self.check_size(mat)
@@ -235,6 +188,66 @@ class FeatureSet:
         return result
 
 
+def read_from_json(coco_json, width=-1, height=-1):
+    feature_dict = {}
+    box_dict = {}
+    ok_compressed = None
+    with open(coco_json, 'r') as file:
+        data = json.load(file)
+    coco_folder = os.path.dirname(coco_json)
+
+    # Create a map from image ID to file name
+    image_map = {image['id']: image['file_name'] for image in data['images']}
+
+    # Create a map from category ID to category name
+    category_map = {category['id']: category['name'] for category in data['categories']}
+
+    for image_id, file_name in image_map.items():
+        # Load and scale the image
+        image_path = str(os.path.join(coco_folder, file_name))
+        if ok_compressed is None:
+            image = Image.open(image_path)
+            ok_compressed = 'ok_compressed' in image.info.items()
+        whole_image = cv2.imread(image_path)
+        if whole_image is None:
+            logger.error(f'Could not read image {image_path}')
+            continue
+        _, original_width = whole_image.shape[:2]
+
+        if width != -1 and height != -1 and (width != whole_image.shape[1] or height != whole_image.shape[0]):
+            scale_x, scale_y = width / whole_image.shape[1], height / whole_image.shape[0]
+            logger.debug(f'scaling images {scale_x}, {scale_y} to {width}x{height}')
+            whole_image = cv2.resize(whole_image, (width, height))
+        else:
+            scale_x, scale_y = 1, 1
+
+        for annotation in data['annotations']:
+            if image_id != annotation['image_id']:
+                continue
+
+            category_id = annotation['category_id']
+            bbox = annotation['bbox']
+            x, y, w, h = bbox
+
+            # Calculate the scaled bounding box
+            x, y, w, h = x * scale_x, y * scale_y, w * scale_x, h * scale_y
+
+            # Crop the image to the bounding box
+            image = whole_image[round(y):round(y + h), round(x):round(x + w), :3]
+
+            # Store in featureDict using the category name
+            category_name = category_map[category_id]
+            logger.debug(
+                f"loaded {category_name} resized width {width} / original_width:{original_width},scale_x:{width / original_width}")
+            if category_name in feature_dict:
+                raise ValueError(f"Multiple boxes found for category {category_name}")
+            if not category_name.startswith('box_'):
+                feature_dict[category_name] = Feature(image, x, y, w, h)
+            box_dict[category_name] = Box(x, y, w, h, name=category_name)
+
+    return feature_dict, box_dict, ok_compressed
+
+
 def filter_and_sort_matches(result, threshold, width, height):
     # Filter matches based on the threshold
     loc = np.where(result >= threshold)
@@ -242,13 +255,15 @@ def filter_and_sort_matches(result, threshold, width, height):
     # Zip the locations into a list of tuples and sort by threshold in descending order
     matches = sorted(zip(*loc[::-1]), key=lambda p: result[p[::-1]], reverse=True)
 
+    # Sort matches based on their location
+    matches.sort(key=lambda pt: (pt[0], pt[1]))
+
     # Filter out overlapping matches
     unique_matches = []
     for pt in matches:
-        if all(not (pt[0] >= m[0] - width and pt[0] <= m[0] + width and
-                    pt[1] >= m[1] - height and pt[1] <= m[1] + height)
-               for m in unique_matches):
+        # Only compare with the last match in unique_matches
+        if not unique_matches or not (unique_matches[-1][0] <= pt[0] <= unique_matches[-1][0] + width and
+                                      unique_matches[-1][1] <= pt[1] <= unique_matches[-1][1] + height):
             unique_matches.append(pt)
 
-    # print(f"result {len(result)} loc {len(loc)} matches {len(matches)} unique_matches {unique_matches}")
     return unique_matches

{ok-script-0.0.91 → ok-script-0.0.94}/ok/gui/App.py

@@ -13,7 +13,6 @@ from ok.gui.Communicate import communicate
 from ok.gui.MainWindow import MainWindow
 from ok.gui.MessageWindow import MessageWindow
 from ok.gui.StartController import StartController
-from ok.gui.debug.LogWindow import LogWindow
 from ok.gui.i18n.path import i18n_path
 from ok.gui.overlay.OverlayWindow import OverlayWindow
 from ok.logging.Logger import get_logger
@@ -95,26 +94,28 @@ class App:
         self.show_message_window(title, content)
 
     def show_main_window(self):
+
+        if self.overlay and ok.gui.device_manager.hwnd is not None:
+            self.overlay_window = OverlayWindow(ok.gui.device_manager.hwnd)
+
+        if self.config.get('debug'):
+            from ok.gui.debug.LogWindow import LogWindow
+            self.log_window = LogWindow(self.config)
+            self.log_window.show()
+            logger.debug('showing log_window')
+
         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:
-            self.overlay_window = OverlayWindow(ok.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()
-        if self.config.get('debug'):
-            self.log_window = LogWindow(self.config)
-            self.log_window.show()
-            logger.debug('showing log_window')
 
     def size_relative_to_screen(self, width, height):
         screen = self.app.primaryScreen()

{ok-script-0.0.91 → ok-script-0.0.94}/ok/gui/MainWindow.py

@@ -1,9 +1,8 @@
 import os
-import sys
 
 from PySide6.QtCore import QObject, Signal, Qt
 from PySide6.QtWidgets import QMenu, QSystemTrayIcon
-from qfluentwidgets import FluentIcon, NavigationItemPosition, MSFluentWindow, InfoBar, InfoBarPosition, MessageBox
+from qfluentwidgets import FluentIcon, NavigationItemPosition, MSFluentWindow, InfoBar, InfoBarPosition
 
 import ok.gui
 from ok.gui.Communicate import communicate
@@ -158,22 +157,11 @@ class MainWindow(MSFluentWindow):
         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
-        if sys.platform == 'win32' and 'shutdown' in os.environ.get('SESSIONNAME', '').lower():
-            logger.info("system shutting down")
-            ok.gui.ok.quit()
-            event.accept()
-            return
-
         if ok.gui.ok.exit_event.is_set():
+            logger.info("Window closed exit_event.is_set")
             event.accept()
             return
-        title = self.tr('Exit')
-        content = self.tr("Are you sure you want to exit the app?")
-        w = MessageBox(title, content, self.window())
-        if w.exec():
-            logger.info("Window closed")
+        else:
+            logger.info("Window closed exit_event.is not set")
             ok.gui.ok.quit()
             event.accept()
-        else:
-            event.ignore()

{ok-script-0.0.91 → ok-script-0.0.94}/ok/gui/StartController.py

@@ -39,7 +39,7 @@ class StartController(QObject):
                     error = self.check_device_error()
                     if error is None:
                         break
-                    logger.debug(f'waiting for game to start error {error}')
+                    logger.error(f'waiting for game to start error {error}')
                     remaining_time = wait_until - time.time()
                     if remaining_time <= 0:
                         communicate.starting_emulator.emit(True, self.tr('Start game timeout!'), 0)

{ok-script-0.0.91 → ok-script-0.0.94}/ok/gui/debug/DebugTab.py

@@ -1,7 +1,7 @@
 import subprocess
 from ctypes import windll, wintypes
 
-from PySide6.QtCore import Qt, Signal
+from PySide6.QtCore import Qt, Signal, QCoreApplication
 from PySide6.QtWidgets import QWidget, QFileDialog, QCompleter, QVBoxLayout, QHBoxLayout
 from _ctypes import byref
 from qfluentwidgets import PushButton, FlowLayout, ComboBox, SearchLineEdit, TextEdit
@@ -46,7 +46,7 @@ class DebugTab(Tab):
         # self.dump_shortcut.activated.connect(dump_threads)
 
         capture_button = PushButton(self.tr("Capture Screenshot"))
-        capture_button.clicked.connect(lambda: self.handler.post(self.capture))
+        capture_button.clicked.connect(lambda: self.handler.post(capture))
         layout.addWidget(capture_button)
 
         ocr_button = PushButton("OCR")
@@ -202,20 +202,22 @@ class DebugTab(Tab):
             self.select_screenshot_button.setText(self.tr("Drop or Select Screenshot"))
             self.config['target_images'] = 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}')
-                alert_info(self.tr('Capture Success'), True)
-            else:
-                alert_error(self.tr('Capture returned None'))
+def capture():
+    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}')
+        current_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,
+                                                                  current_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: {current_capture}')
+            alert_info(QCoreApplication.translate('DebugTab', 'Capture Success'), True)
         else:
-            alert_error(self.tr('No Capture Available or Selected'))
+            alert_error(QCoreApplication.translate('DebugTab', 'Capture returned None'))
+    else:
+        alert_error(QCoreApplication.translate('DebugTab', 'No Capture Available or Selected'))

{ok-script-0.0.91 → ok-script-0.0.94}/ok/gui/debug/LogWindow.py

@@ -1,7 +1,8 @@
-from PySide6.QtCore import Qt, QAbstractListModel, QModelIndex, QPoint, Signal
+from PySide6.QtCore import Qt, QAbstractListModel, QPoint, QModelIndex
 from PySide6.QtGui import QColor
-from PySide6.QtWidgets import QVBoxLayout, QListView, QLineEdit, QHBoxLayout, QComboBox, QAbstractItemView, QWidget, \
-    QPushButton, QLabel, QStyledItemDelegate
+from PySide6.QtWidgets import QWidget, \
+    QStyledItemDelegate, QListView, QVBoxLayout, QHBoxLayout, QAbstractItemView, QComboBox, QLineEdit, QLabel, \
+    QPushButton
 
 from ok.config.Config import Config
 from ok.gui.Communicate import communicate
@@ -39,19 +40,19 @@ class ColorDelegate(QStyledItemDelegate):
 
 
 class LogModel(QAbstractListModel):
-    def __init__(self, log_list):
+    def __init__(self):
         super(LogModel, self).__init__()
-        self.log_list = log_list
         self.logs = []
-        self.filtered_logs = self.logs[:]
+        self.filtered_logs = []
         self.current_level = "ALL"
         self.current_keyword = ""
 
     def data(self, index, role):
-        if role == Qt.DisplayRole:
-            return self.filtered_logs[index.row()].text
-        elif role == Qt.ForegroundRole:
-            return self.filtered_logs[index.row()].format
+        if 0 <= index.row() < len(self.filtered_logs):
+            if role == Qt.DisplayRole:
+                return self.filtered_logs[index.row()].text
+            elif role == Qt.ForegroundRole:
+                return self.filtered_logs[index.row()].format
 
     def rowCount(self, index):
         return len(self.filtered_logs)
@@ -62,15 +63,15 @@ class LogModel(QAbstractListModel):
         colored_text = ColoredText(message, color_format, level)
         self.logs.append(colored_text)
         if len(self.logs) >= 500:
-            self.beginRemoveRows(QModelIndex(), 0, 0)
+            # self.beginRemoveRows(QModelIndex(), 0, 0)
             self.logs.pop(0)
-            self.endRemoveRows()
-
+            # self.endRemoveRows()
         self.beginInsertRows(QModelIndex(), self.rowCount(QModelIndex()), self.rowCount(QModelIndex()))
         self.do_filter_logs()
         self.endInsertRows()
-        self.layoutChanged.emit()
-        self.log_list.scrollToBottom()
+
+        # self.layoutChanged.emit()
+        # self.log_list.scrollToBottom()
 
     def do_filter_logs(self):
 
@@ -92,9 +93,10 @@ class LogModel(QAbstractListModel):
     def filter_logs(self, level, keyword):
         self.current_level = level
         self.current_keyword = keyword
+        self.beginRemoveRows(QModelIndex(), 0, self.rowCount(QModelIndex()) - 1)
+        self.filtered_logs.clear()
+        self.endRemoveRows()
         self.do_filter_logs()
-        self.layoutChanged.emit()
-        self.log_list.scrollToBottom()
 
     def get_color_format(self, level):
         # Define color codes for different levels
@@ -118,8 +120,6 @@ class LogWindow(QWidget):
                              app_config.get('config_folder'), 'log_window')
         self.setGeometry(self.config['x'], self.config['y'], self.config['width'], self.config['height'])
 
-        self.refresh_signal = Signal()
-
         self.old_pos = None
 
         # Layouts
@@ -158,16 +158,15 @@ class LogWindow(QWidget):
 
         self.setLayout(self.layout)
 
-        self.log_model = LogModel(self.log_list)
+        self.log_model = LogModel()
         self.log_list.setModel(self.log_model)
-        communicate.log.connect(self.add_log)
 
-        self.logs = []
-        self.filter_logs()
+        communicate.log.connect(self.add_log)
 
     def add_log(self, level_no, message):
-        self.logs.append(message)
+        # print('add_log', level_no, message)
         self.log_model.add_log(log_levels.get(level_no, 'DEBUG'), message)
+        self.log_list.scrollToBottom()
 
     def filter_logs(self):
         level = self.level_filter.currentText()