pygpt-net 2.6.37__py3-none-any.whl → 2.6.38__py3-none-any.whl

pygpt_net/ui/dialog/db.py

@@ -6,13 +6,13 @@
 # GitHub:  https://github.com/szczyglis-dev/py-gpt   #
 # MIT License                                        #
 # Created By  : Marcin Szczygliński                  #
-# Updated Date: 2025.08.24 23:00:00                  #
+# Updated Date: 2025.09.05 18:00:00                  #
 # ================================================== #
 
-from PySide6.QtCore import Qt
-from PySide6.QtGui import QAction, QIcon
+from PySide6.QtCore import Qt, QTimer, QSignalBlocker
+from PySide6.QtGui import QAction, QIcon, QIntValidator
 from PySide6.QtWidgets import QGridLayout, QScrollArea, QSplitter, QComboBox, QLineEdit, QPushButton, \
-    QHBoxLayout, QVBoxLayout, QLabel, QWidget, QSizePolicy, QCheckBox, QMenuBar
+    QHBoxLayout, QVBoxLayout, QLabel, QWidget, QSizePolicy, QCheckBox, QMenuBar, QAbstractItemView, QHeaderView, QStyledItemDelegate
 
 from pygpt_net.ui.widget.dialog.db import DatabaseDialog
 from pygpt_net.ui.widget.lists.db import DatabaseList, DatabaseTableModel
@@ -20,6 +20,18 @@ from pygpt_net.ui.widget.textarea.editor import CodeEditor
 from pygpt_net.utils import trans
 
 
+class _FastTextDelegate(QStyledItemDelegate):
+    def __init__(self, max_chars=1200, parent=None):
+        super().__init__(parent)
+        self.max_chars = max_chars
+
+    def displayText(self, value, locale):
+        s = "" if value is None else str(value)
+        if len(s) > self.max_chars:
+            return s[:self.max_chars] + "…"
+        return s
+
+
 class Database:
     def __init__(self, window=None):
         """
@@ -29,6 +41,8 @@ class Database:
         """
         self.window = window
         self.viewer = None
+        self._splitter_timer = None
+        self._text_viewer = None
 
     def setup(self, id: str = "db"):
         """
@@ -45,6 +59,7 @@ class Database:
         # data viewer
         text_viewer = CodeEditor(self.window)
         text_viewer.setReadOnly(False)
+        self._text_viewer = text_viewer
 
         self.window.ui.debug[id].browser = self.viewer
         self.window.ui.debug[id].viewer = text_viewer
@@ -63,6 +78,12 @@ class Database:
         splitter.addWidget(editor_widget)  # Value viewer
         splitter.setStretchFactor(0, 3)
         splitter.setStretchFactor(1, 1)
+        splitter.setOpaqueResize(False)
+
+        self._splitter_timer = QTimer(self.window)
+        self._splitter_timer.setSingleShot(True)
+        self._splitter_timer.timeout.connect(self._finish_splitter_move)
+        splitter.splitterMoved.connect(self._on_splitter_moved)
 
         self.menu_bar = QMenuBar()
         self.batch_actions_menu = self.menu_bar.addMenu("Actions")
@@ -81,6 +102,18 @@ class Database:
         self.window.ui.dialog['debug.db'].setLayout(layout)
         self.window.ui.dialog['debug.db'].setWindowTitle("Debug: Database (SQLite)")
 
+    def _on_splitter_moved(self, pos, index):
+        if self._text_viewer is not None:
+            self._text_viewer.setUpdatesEnabled(False)
+            self._splitter_timer.start(120)
+
+    def _finish_splitter_move(self):
+        if self._text_viewer is not None:
+            self._text_viewer.setUpdatesEnabled(True)
+            if hasattr(self._text_viewer, 'viewport'):
+                self._text_viewer.viewport().update()
+
+
 class DataBrowser(QWidget):
     def __init__(self, window=None):
         super().__init__()
@@ -111,7 +144,7 @@ class DataBrowser(QWidget):
 
         # buttons
         self.refresh_button = QPushButton(trans("db.refresh"))
-        self.refresh_button.clicked.connect(self.update_table_view)
+        self.refresh_button.clicked.connect(self.force_refresh)
         self.prev_button = QPushButton(trans("db.prev"))
         self.next_button = QPushButton(trans("db.next"))
         self.limit_input = QLineEdit("100")
@@ -126,7 +159,7 @@ class DataBrowser(QWidget):
         self.page_input_label = QLabel(trans("db.page") + ":")
         self.page_input_label.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
         self.page_input.editingFinished.connect(self.on_page_input_change)
-        self.page_info_label = QLabel(" / 1")  # total pages
+        self.page_info_label = QLabel(" / 1")
         self.page_info_label.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
 
         # checkboxes
@@ -155,18 +188,30 @@ class DataBrowser(QWidget):
         self.table_select.addItems(self.get_table_names())
         self.sort_order_select.addItems(['ASC', 'DESC'])
 
+        self._search_timer = QTimer(self)
+        self._search_timer.setSingleShot(True)
+        self._search_timer.timeout.connect(self.update_table_view)
+        self._last_fetch_sig = None
+        self._last_count_sig = None
+        self._cached_total_rows = 0
+        self._last_columns_sig = None
+
+        v = QIntValidator(1, 1000000000, self)
+        self.limit_input.setValidator(v)
+        self.page_input.setValidator(v)
+
         # signals
         self.table_select.currentIndexChanged.connect(self.on_table_select_changed)
         self.sort_by_select.currentIndexChanged.connect(self.update_table_view)
         self.sort_order_select.currentIndexChanged.connect(self.update_table_view)
-        self.search_input.textChanged.connect(self.update_table_view)
+        self.search_input.textChanged.connect(self.on_search_text_changed)
         self.search_column_select.currentIndexChanged.connect(self.update_table_view)
 
         self.prev_button.clicked.connect(self.prev_page)
         self.next_button.clicked.connect(self.next_page)
 
         self.table_select.setCurrentText(self.get_default_table())
-        self.on_table_select_changed()  # load data
+        self.on_table_select_changed()
 
         # setup layouts
         if not self.is_inline():
@@ -221,6 +266,27 @@ class DataBrowser(QWidget):
 
         self.setLayout(main_layout)
 
+        view = self.get_list_widget()
+        if hasattr(view, "setUniformRowHeights"):
+            view.setUniformRowHeights(True)
+        if hasattr(view, "setWordWrap"):
+            view.setWordWrap(False)
+        if hasattr(view, "setTextElideMode"):
+            view.setTextElideMode(Qt.ElideRight)
+        if hasattr(view, "setVerticalScrollMode"):
+            view.setVerticalScrollMode(QAbstractItemView.ScrollPerPixel)
+        if hasattr(view, "setHorizontalScrollMode"):
+            view.setHorizontalScrollMode(QAbstractItemView.ScrollPerPixel)
+        if hasattr(view, "setViewportUpdateMode"):
+            view.setViewportUpdateMode(QAbstractItemView.MinimalViewportUpdate)
+        if hasattr(view, "horizontalHeader"):
+            hh = view.horizontalHeader()
+            if hh is not None:
+                hh.setSectionResizeMode(QHeaderView.Interactive)
+        self._fast_delegate = _FastTextDelegate(parent=view)
+        if hasattr(view, "setItemDelegate"):
+            view.setItemDelegate(self._fast_delegate)
+
     def is_inline(self) -> bool:
         return False
 
@@ -339,6 +405,8 @@ class DataBrowser(QWidget):
             self.limit_input.setText(str(current_limit))
             return
         self.current_offset = 0
+        self._last_fetch_sig = None
+        self._last_count_sig = None
         self.update_table_view()
 
     def get_page_size(self) -> int:
@@ -358,27 +426,18 @@ class DataBrowser(QWidget):
 
         :param update: Update table view
         """
-        page = int(self.page_input.text()) - 1
-        limit = int(self.limit_input.text())
-        search_query = self.search_input.text()
-        search_column = self.search_column_select.currentText()
-        if search_column == "*":
-            search_column = None
-        current_table = self.get_table_name(self.table_select.currentText())
-        total_rows = self.get_viewer().count_rows(
-            current_table,
-            search_query=search_query,
-            search_column=search_column,
-            filters=self.get_filters(),
-        )
+        try:
+            page = int(self.page_input.text()) - 1
+        except ValueError:
+            page = 0
+        limit = self.get_page_size()
+        total_rows = self._get_total_rows()
 
-        # check if page is in range
         if page * limit < total_rows and page >= 0:
             if update:
                 self.current_offset = page * limit
                 self.update_table_view()
         else:
-            # reset page
             current_page = self.current_offset // limit + 1
             self.page_input.setText(str(current_page))
 
@@ -395,38 +454,33 @@ class DataBrowser(QWidget):
         """Table select change event"""
         tables = self.get_tables()
         current_table = self.get_table_name(self.table_select.currentText())
-        self.sort_by_select.clear()
-        if current_table in tables:
-            self.sort_by_select.addItems(tables[current_table]['sort_by'])
-            self.sort_by_select.setCurrentText(tables[current_table]['default_sort'])
-            self.sort_order_select.setCurrentText(tables[current_table]['default_order'])
-            self.page_input.setText("1")  # reset page
-            self.on_page_input_change()
-            self.update_table_view()  # update view
-            self.update_search_columns()  # update search columns
+        with QSignalBlocker(self.sort_by_select), QSignalBlocker(self.sort_order_select):
+            self.sort_by_select.clear()
+            if current_table in tables:
+                self.sort_by_select.addItems(tables[current_table]['sort_by'])
+                self.sort_by_select.setCurrentText(tables[current_table]['default_sort'])
+                self.sort_order_select.setCurrentText(tables[current_table]['default_order'])
+        self.page_input.setText("1")
+        self.current_offset = 0
+        self.update_search_columns()
+        self._last_fetch_sig = None
+        self._last_count_sig = None
+        self._last_columns_sig = None
+        self.update_table_view()
 
     def update_search_columns(self):
         """Update search columns"""
         tables = self.get_tables()
         current_table = self.get_table_name(self.table_select.currentText())
-        self.search_column_select.clear()
-        self.search_column_select.addItem("*", None)
-        self.search_column_select.addItems(tables[current_table]['columns'])
+        with QSignalBlocker(self.search_column_select):
+            self.search_column_select.clear()
+            self.search_column_select.addItem("*", None)
+            self.search_column_select.addItems(tables[current_table]['columns'])
 
     def update_pagination_info(self):
         """Update pagination info"""
-        limit = int(self.limit_input.text())
-        search_query = self.search_input.text()
-        search_column = self.search_column_select.currentText()
-        if search_column == "*":
-            search_column = None
-        current_table = self.get_table_name(self.table_select.currentText())
-        total_rows = self.get_viewer().count_rows(
-            current_table,
-            search_query=search_query,
-            search_column=search_column,
-            filters=self.get_filters(),
-        )
+        limit = self.get_page_size()
+        total_rows = self._get_total_rows()
         total_pages = (total_rows - 1) // limit + 1
         self.page_info_label.setText(f" / {total_pages}  ({total_rows} rows)")
 
@@ -435,21 +489,24 @@ class DataBrowser(QWidget):
         self.prev_button.setEnabled(self.current_offset > 0)
         self.next_button.setEnabled(self.current_offset + limit < total_rows)
 
-    def update_table_view(self):
+    def update_table_view(self, *args, force: bool = False):
         """Update table view"""
         tables = self.get_tables()
         current_table = self.get_table_name(self.table_select.currentText())
         sort_by = self.sort_by_select.currentText()
         sort_order = self.sort_order_select.currentText()
         search_query = self.search_input.text()
-        search_column = self.search_column_select.currentText()
-        if search_column == "*":
-            search_column = None
-        limit = int(self.limit_input.text())
+        search_column = self.search_column_select.currentData()
+        limit = self.get_page_size()
 
         if current_table not in tables or sort_by == '' or sort_order == '' or limit <= 0:
             return
 
+        sig = self._params_signature_fetch()
+        if not force and self._last_fetch_sig == sig:
+            self.update_pagination_info()
+            return
+
         data = self.get_viewer().fetch_data(
             table=current_table,
             columns=tables[current_table]['columns'],
@@ -462,11 +519,12 @@ class DataBrowser(QWidget):
             filters=self.get_filters(),
         )
         self.load_data(data, tables[current_table])
+        self._last_fetch_sig = sig
         self.update_pagination_info()
 
     def prev_page(self):
         """Previous page event"""
-        limit = int(self.limit_input.text())
+        limit = self.get_page_size()
         if self.current_offset - limit >= 0:
             self.current_offset -= limit
         else:
@@ -475,10 +533,8 @@ class DataBrowser(QWidget):
 
     def next_page(self):
         """Next page event"""
-        limit = int(self.limit_input.text())
-        current_table = self.get_table_name(self.table_select.currentText())
-        total_rows = self.get_viewer().count_rows(current_table)
-
+        limit = self.get_page_size()
+        total_rows = self._get_total_rows()
         if self.current_offset + limit < total_rows:
             self.current_offset += limit
         self.update_table_view()
@@ -498,11 +554,73 @@ class DataBrowser(QWidget):
             self.db_path_label.setText(self.window.core.db.db_path)
         if not self.is_inline():
             convert_timestamps = self.convert_timestamps_checkbox.isChecked()
+        view = self.get_list_widget()
+        if hasattr(view, 'setSortingEnabled'):
+            view.setSortingEnabled(False)
+        view.setUpdatesEnabled(False)
         model = DatabaseTableModel(
             data,
             table['columns'],
             timestamp_columns=table.get('timestamp_columns', []),
             convert_timestamps=convert_timestamps,
         )
-        self.get_list_widget().setModel(model)
-        self.get_list_widget().adjustColumns()
+        if hasattr(model, 'setParent'):
+            model.setParent(view)
+        view.setModel(model)
+        if self._last_columns_sig != tuple(table['columns']):
+            if hasattr(view, 'adjustColumns'):
+                view.adjustColumns()
+            if hasattr(view, "horizontalHeader"):
+                hh = view.horizontalHeader()
+                if hh is not None:
+                    hh.setSectionResizeMode(QHeaderView.Interactive)
+            self._last_columns_sig = tuple(table['columns'])
+        view.setUpdatesEnabled(True)
+
+    def on_search_text_changed(self, text):
+        self._search_timer.start(200)
+
+    def _params_signature_base(self):
+        table = self.get_table_name(self.table_select.currentText())
+        search_query = self.search_input.text()
+        search_column = self.search_column_select.currentData()
+        filters = self.get_filters()
+        if isinstance(filters, dict):
+            filters_key = tuple(sorted(filters.items()))
+        else:
+            filters_key = str(filters)
+        return table, search_query, search_column, filters_key
+
+    def _params_signature_fetch(self):
+        table, search_query, search_column, filters_key = self._params_signature_base()
+        tables = self.get_tables()
+        columns = tuple(tables[table]['columns']) if table in tables else tuple()
+        sort_by = self.sort_by_select.currentText()
+        sort_order = self.sort_order_select.currentText()
+        limit = self.get_page_size()
+        offset = self.current_offset
+        return table, columns, sort_by, sort_order, search_query, search_column, filters_key, limit, offset
+
+    def _params_signature_count(self):
+        return self._params_signature_base()
+
+    def _get_total_rows(self):
+        sig = self._params_signature_count()
+        if self._last_count_sig == sig:
+            return self._cached_total_rows
+        table, search_query, search_column, _ = sig
+        total_rows = self.get_viewer().count_rows(
+            table,
+            search_query=search_query,
+            search_column=search_column,
+            filters=self.get_filters(),
+        )
+        self._last_count_sig = sig
+        self._cached_total_rows = total_rows
+        return total_rows
+
+    def force_refresh(self):
+        self._last_fetch_sig = None
+        self._last_count_sig = None
+        self._last_columns_sig = None
+        self.update_table_view()

pygpt_net/ui/dialog/dictionary.py

@@ -6,7 +6,7 @@
 # GitHub:  https://github.com/szczyglis-dev/py-gpt   #
 # MIT License                                        #
 # Created By  : Marcin Szczygliński                  #
-# Updated Date: 2024.03.12 06:00:00                  #
+# Updated Date: 2025.09.05 18:00:00                  #
 # ================================================== #
 
 from PySide6.QtWidgets import QPushButton, QHBoxLayout, QVBoxLayout, QScrollArea, QWidget, QSizePolicy
@@ -47,87 +47,85 @@ class Dictionary(BaseConfigDialog):
 
     def setup(self):
         """Setup dictionary editor dialogs"""
-        for dict_id in self.dicts:
-            parent_id = self.id + "." + dict_id
+        ui = self.window.ui
+        controller = self.window.controller
+        save_text = trans("dialog.preset.btn.save")
+        dismiss_text = trans("dialog.rename.dismiss")
+        edit_title = trans('action.edit')
+
+        for dict_id, data in self.dicts.items():
+            parent_id = f"{self.id}.{dict_id}"
             option_key = self.keys[dict_id]
             parent = self.parents[dict_id]
-            data = self.dicts[dict_id]
-            self.window.ui.config[parent_id] = {}
+            ui.config[parent_id] = {}
 
-            # widgets
             fields = {}
-
-            # option type: dict
             if data["type"] == 'dict':
-                fields = self.window.controller.config.dictionary.to_options(
+                fields = controller.config.dictionary.to_options(
                     parent_id,
                     data,
-                )  # item to options
-
-            # option type: cmd
+                )
             elif data["type"] == 'cmd':
-                fields = self.window.controller.config.cmd.to_options(
+                fields = controller.config.cmd.to_options(
                     parent_id,
                     data,
-                )  # item to options
+                )
 
             widgets = self.build_widgets(
                 parent_id,
                 fields,
                 stretch=True,
-            )  # from base config dialog
-
-            for key in widgets:
-                self.window.ui.config[parent_id][key] = widgets[key]
-
-            # apply widgets to layouts
-            options = {}
-            is_stretch = False
-            for key in widgets:
-                if fields[key]["type"] == 'int' or fields[key]["type"] == 'float':
-                    options[key] = self.add_option(widgets[key], fields[key])
-                elif fields[key]["type"] == 'text' or fields[key]["type"] == 'textarea':
-                    options[key] = self.add_row_option(widgets[key], fields[key])
-                elif fields[key]["type"] == 'bool':
-                    options[key] = self.add_raw_option(widgets[key], fields[key])
-                elif fields[key]["type"] == 'dict':
-                    options[key] = self.add_row_option(widgets[key], fields[key])
-                elif fields[key]["type"] == 'combo':
-                    options[key] = self.add_row_option(widgets[key], fields[key])
-
-                # stretch all only if textarea is present
-                if fields[key]["type"] == 'textarea':
-                    is_stretch = True
+            )
+            ui.config[parent_id] = widgets
 
-            rows = QVBoxLayout()
-            for key in options:
-                rows.addLayout(options[key])
+            add_option = self.add_option
+            add_row_option = self.add_row_option
+            add_raw_option = self.add_raw_option
 
-            if not is_stretch:
+            rows = QVBoxLayout()
+            has_textarea = False
+
+            for k, f in fields.items():
+                t = f.get("type")
+                w = widgets.get(k)
+                if t in ('int', 'float'):
+                    row = add_option(w, f)
+                elif t in ('text', 'textarea', 'dict', 'combo'):
+                    row = add_row_option(w, f)
+                elif t == 'bool':
+                    row = add_raw_option(w, f)
+                else:
+                    continue
+                rows.addLayout(row)
+                if t == 'textarea':
+                    has_textarea = True
+
+            if not has_textarea:
                 rows.addStretch()
 
-            # footer
-            self.window.ui.nodes[parent_id + '.btn.save'] = QPushButton(trans("dialog.preset.btn.save"))
-            self.window.ui.nodes[parent_id + '.btn.save'].clicked.connect(
+            save_key = f"{parent_id}.btn.save"
+            dismiss_key = f"{parent_id}.btn.dismiss"
+
+            ui.nodes[save_key] = QPushButton(save_text)
+            ui.nodes[save_key].clicked.connect(
                 lambda checked=True, option_key=option_key, parent=parent, fields=fields:
-                self.window.controller.config.dictionary.save_editor(
+                controller.config.dictionary.save_editor(
                     option_key,
                     parent,
                     fields,
                 ))
-            self.window.ui.nodes[parent_id + '.btn.save'].setAutoDefault(True)
+            ui.nodes[save_key].setAutoDefault(True)
 
-            self.window.ui.nodes[parent_id + '.btn.dismiss'] = QPushButton(trans("dialog.rename.dismiss"))
-            self.window.ui.nodes[parent_id + '.btn.dismiss'].clicked.connect(
-                lambda checked=True, parent_id=parent_id: self.window.ui.dialogs.close('editor.' + parent_id)
+            ui.nodes[dismiss_key] = QPushButton(dismiss_text)
+            ui.nodes[dismiss_key].clicked.connect(
+                lambda checked=True, pid=parent_id: ui.dialogs.close(f'editor.{pid}')
             )
-            self.window.ui.nodes[parent_id + '.btn.dismiss'].setAutoDefault(False)
+            ui.nodes[dismiss_key].setAutoDefault(False)
 
             footer = QHBoxLayout()
-            footer.addWidget(self.window.ui.nodes[parent_id + '.btn.dismiss'])
-            footer.addWidget(self.window.ui.nodes[parent_id + '.btn.save'])
+            footer.addWidget(ui.nodes[dismiss_key])
+            footer.addWidget(ui.nodes[save_key])
 
-            # scroll area
             scroll = QScrollArea()
             scroll.setWidgetResizable(True)
             scroll.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
@@ -138,10 +136,10 @@ class Dictionary(BaseConfigDialog):
             widget.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
 
             layout = QVBoxLayout()
-            layout.addWidget(scroll)  # options
-            layout.addLayout(footer)  # footer
+            layout.addWidget(scroll)
+            layout.addLayout(footer)
 
-            # dialog
-            self.window.ui.dialog['editor.' + parent_id] = EditorDialog(self.window, parent_id)  # current idx here
-            self.window.ui.dialog['editor.' + parent_id].setLayout(layout)
-            self.window.ui.dialog['editor.' + parent_id].setWindowTitle(trans('action.edit'))
+            dialog_key = f'editor.{parent_id}'
+            ui.dialog[dialog_key] = EditorDialog(self.window, parent_id)
+            ui.dialog[dialog_key].setLayout(layout)
+            ui.dialog[dialog_key].setWindowTitle(edit_title)

pygpt_net/ui/dialog/editor.py

@@ -6,7 +6,7 @@
 # GitHub:  https://github.com/szczyglis-dev/py-gpt   #
 # MIT License                                        #
 # Created By  : Marcin Szczygliński                  #
-# Updated Date: 2024.04.09 23:00:00                  #
+# Updated Date: 2025.09.05 18:00:00                  #
 # ================================================== #
 
 from PySide6.QtWidgets import QPushButton, QHBoxLayout, QLabel, QVBoxLayout
@@ -45,7 +45,8 @@ class Editor:
             lambda: self.window.controller.settings.editor.load_editor_defaults_app()
         )
         self.window.ui.nodes['editor.btn.save'].clicked.connect(
-            lambda: self.window.core.settings.save_editor())
+            lambda: self.window.core.settings.save_editor()
+        )
 
         bottom_layout = QHBoxLayout()
         bottom_layout.addWidget(self.window.ui.nodes['editor.btn.default'])

pygpt_net/ui/dialog/image.py

@@ -6,7 +6,7 @@
 # GitHub:  https://github.com/szczyglis-dev/py-gpt   #
 # MIT License                                        #
 # Created By  : Marcin Szczygliński                  #
-# Updated Date: 2024.03.26 15:00:00                  #
+# Updated Date: 2025.09.05 18:00:00                  #
 # ================================================== #
 
 from PySide6.QtWidgets import QVBoxLayout, QHBoxLayout, QCheckBox

pygpt_net/ui/dialog/logger.py

@@ -6,7 +6,7 @@
 # GitHub:  https://github.com/szczyglis-dev/py-gpt   #
 # MIT License                                        #
 # Created By  : Marcin Szczygliński                  #
-# Updated Date: 2025.08.11 18:00:00                  #
+# Updated Date: 2025.09.05 18:00:00                  #
 # ================================================== #
 
 from PySide6.QtWidgets import QPushButton, QHBoxLayout, QVBoxLayout
@@ -44,7 +44,8 @@ class Logger:
 
         self.window.ui.nodes['logger.btn.clear'] = QPushButton(trans("dialog.logger.btn.clear"))
         self.window.ui.nodes['logger.btn.clear'].clicked.connect(
-            lambda: self.window.controller.debug.clear_logger())
+            lambda: self.window.controller.debug.clear_logger()
+        )
 
         bottom_layout = QHBoxLayout()
         bottom_layout.addWidget(self.window.ui.nodes['logger.btn.clear'])

pygpt_net/ui/dialog/models.py

@@ -6,7 +6,7 @@
 # GitHub:  https://github.com/szczyglis-dev/py-gpt   #
 # MIT License                                        #
 # Created By  : Marcin Szczygliński                  #
-# Updated Date: 2025.08.24 23:00:00                  #
+# Updated Date: 2025.09.05 18:00:00                  #
 # ================================================== #
 
 import copy
@@ -16,7 +16,6 @@ from PySide6.QtGui import QStandardItemModel, QIcon
 from PySide6.QtWidgets import QPushButton, QHBoxLayout, QLabel, QVBoxLayout, QScrollArea, QWidget, QTabWidget, QFrame, \
     QSplitter, QSizePolicy
 
-from pygpt_net.item.model import ModelItem
 from pygpt_net.ui.widget.dialog.model import ModelDialog
 from pygpt_net.ui.widget.element.group import CollapsedGroup
 from pygpt_net.ui.widget.element.labels import UrlLabel, DescLabel
@@ -56,13 +55,17 @@ class Models:
             QPushButton(trans("dialog.models.editor.btn.save"))
 
         self.window.ui.nodes['models.editor.btn.new'].clicked.connect(
-            lambda: self.window.controller.model.editor.new())
+            lambda: self.window.controller.model.editor.new()
+        )
         self.window.ui.nodes['models.editor.btn.defaults.user'].clicked.connect(
-            lambda: self.window.controller.model.editor.load_defaults_user())
+            lambda: self.window.controller.model.editor.load_defaults_user()
+        )
         self.window.ui.nodes['models.editor.btn.defaults.app'].clicked.connect(
-            lambda: self.window.controller.model.editor.load_defaults_app())
+            lambda: self.window.controller.model.editor.load_defaults_app()
+        )
         self.window.ui.nodes['models.editor.btn.save'].clicked.connect(
-            lambda: self.window.controller.model.editor.save())
+            lambda: self.window.controller.model.editor.save()
+        )
 
         # set enter key to save button
         self.window.ui.nodes['models.editor.btn.new'].setAutoDefault(False)
@@ -111,17 +114,16 @@ class Models:
         # append advanced options at the end
         if len(advanced_keys) > 0:
             group_id = 'models.editor.advanced'
-            self.window.ui.groups[group_id] = CollapsedGroup(self.window, group_id, None, False, None)
-            self.window.ui.groups[group_id].box.setText(trans('settings.advanced.collapse'))
+            group = CollapsedGroup(self.window, group_id, None, False, None)
+            group.box.setText(trans('settings.advanced.collapse'))
             for key in widgets:
                 if key not in advanced_keys:  # ignore non-advanced options
                     continue
-
-                option = self.add_option(widgets[key], options[key])  # build option
-                self.window.ui.groups[group_id].add_layout(option)  # add option to group
+                group.add_layout(self.add_option(widgets[key], options[key]))  # add option to group
 
             # add advanced options group to scroll
-            content.addWidget(self.window.ui.groups[group_id])
+            content.addWidget(group)
+            self.window.ui.groups[group_id] = group
 
         content.addStretch()