pygpt-net 2.6.67__py3-none-any.whl → 2.7.1__py3-none-any.whl

pygpt_net/ui/widget/lists/experts.py

@@ -1,3 +1,5 @@
+# list.py
+
 #!/usr/bin/env python3
 # -*- coding: utf-8 -*-
 # ================================================== #
@@ -6,17 +8,117 @@
 # GitHub:  https://github.com/szczyglis-dev/py-gpt   #
 # MIT License                                        #
 # Created By  : Marcin Szczygliński                  #
-# Updated Date: 2024.05.01 17:00:00                  #
+# Updated Date: 2025.12.27 21:00:00                  #
 # ================================================== #
 
 from PySide6 import QtCore
-from PySide6.QtGui import QStandardItemModel
-from PySide6.QtWidgets import QWidget, QHBoxLayout, QPushButton, QVBoxLayout, QLabel
+from PySide6.QtGui import QStandardItemModel, QAction, QIcon
+from PySide6.QtWidgets import QWidget, QHBoxLayout, QPushButton, QVBoxLayout, QLabel, QAbstractItemView, QMenu
+from PySide6.QtCore import QItemSelectionModel
 
 from pygpt_net.ui.widget.lists.base import BaseList
 from pygpt_net.utils import trans
 import pygpt_net.icons_rc
 
+
+class ExpertsList(BaseList):
+    def __init__(self, window=None, id=None):
+        """
+        Experts list view with virtual multi-select and context menu.
+
+        - ExtendedSelection enables Ctrl/Shift multi-select gestures.
+        - Single left click with no modifiers clears multi-selection when active.
+        - Right-click context menu:
+            * available list: Add
+            * selected list: Remove
+        """
+        super(ExpertsList, self).__init__(window, id=id)
+        self.setSelectionBehavior(QAbstractItemView.SelectRows)
+        self.setSelectionMode(QAbstractItemView.ExtendedSelection)
+
+        self.setContextMenuPolicy(QtCore.Qt.CustomContextMenu)
+        self.customContextMenuRequested.connect(self.show_context_menu)
+        self._backup_selection = None
+        self.restore_after_ctx_menu = True
+
+    def mousePressEvent(self, event):
+        """
+        Clear multi-selection on a single left click (any position or empty area),
+        then proceed with default selection behavior for the clicked row.
+        """
+        if event.button() == QtCore.Qt.LeftButton and event.modifiers() == QtCore.Qt.NoModifier:
+            sel_model = self.selectionModel()
+            if sel_model is not None and len(sel_model.selectedRows()) > 1:
+                index = self.indexAt(event.pos())
+                sel_model.clearSelection()
+                if not index.isValid():
+                    event.accept()
+                    return
+        super(ExpertsList, self).mousePressEvent(event)
+
+    def _selected_rows(self):
+        """Return list of selected row indexes."""
+        try:
+            return list(self.selectionModel().selectedRows())
+        except Exception:
+            return []
+
+    def show_context_menu(self, pos: QtCore.QPoint):
+        """Context menu for available/selected experts lists."""
+        index = self.indexAt(pos)
+        selected = self._selected_rows()
+
+        if not index.isValid() and not selected:
+            return
+
+        sel_model = self.selectionModel()
+        # Preserve multi-selection if RMB inside it; otherwise temporarily select clicked row
+        if index.isValid():
+            selected_rows = [ix.row() for ix in selected]
+            if len(selected_rows) > 1 and index.row() in selected_rows:
+                self._backup_selection = None
+            else:
+                self._backup_selection = list(sel_model.selectedIndexes())
+                sel_model.clearSelection()
+                sel_model.select(index, QItemSelectionModel.Select | QItemSelectionModel.Rows)
+        else:
+            self._backup_selection = None
+
+        menu = QMenu(self)
+        if self.id == "preset.experts.available":
+            act_add = QAction(QIcon(":/icons/add.svg"), trans('action.add'), menu)
+            act_add.triggered.connect(self._action_add)
+            act_add.setEnabled(len(self._selected_rows()) > 0)
+            menu.addAction(act_add)
+        elif self.id == "preset.experts.selected":
+            act_remove = QAction(QIcon(":/icons/close.svg"), trans('action.delete'), menu)
+            act_remove.triggered.connect(self._action_remove)
+            act_remove.setEnabled(len(self._selected_rows()) > 0)
+            menu.addAction(act_remove)
+        else:
+            return
+
+        global_pos = self.viewport().mapToGlobal(pos)
+        menu.exec_(global_pos)
+
+        if self.restore_after_ctx_menu and self._backup_selection is not None:
+            sel_model.clearSelection()
+            for i in self._backup_selection:
+                sel_model.select(i, QItemSelectionModel.Select | QItemSelectionModel.Rows)
+        self._backup_selection = None
+        self.restore_after_ctx_menu = True
+
+    def _action_add(self):
+        """Add selected experts from available list (same as '>')."""
+        self.restore_after_ctx_menu = False
+        self.window.controller.presets.editor.experts.add_expert()
+
+    def _action_remove(self):
+        """Remove selected experts from selected list (same as '<')."""
+        self.restore_after_ctx_menu = False
+        self.window.controller.presets.editor.experts.remove_expert()
+
+
 class ExpertsEditor(QWidget):
     def __init__(self, window=None):
         """
@@ -65,11 +167,11 @@ class ExpertsEditor(QWidget):
         arrows_layout.addWidget(self.window.ui.nodes["preset.experts.remove"])
 
         self.window.ui.nodes["preset.experts.available.label"] = QLabel(trans("preset.experts.available.label"))
-        self.window.ui.nodes["preset.experts.available"] = BaseList(self.window)
+        self.window.ui.nodes["preset.experts.available"] = ExpertsList(self.window, id="preset.experts.available")
         self.window.ui.nodes["preset.experts.available"].clicked.disconnect()
 
         self.window.ui.nodes["preset.experts.selected.label"] = QLabel(trans("preset.experts.selected.label"))
-        self.window.ui.nodes["preset.experts.selected"] = BaseList(self.window)
+        self.window.ui.nodes["preset.experts.selected"] = ExpertsList(self.window, id="preset.experts.selected")
         self.window.ui.nodes["preset.experts.selected"].clicked.disconnect()
 
         available_layout = QVBoxLayout()
@@ -100,7 +202,7 @@ class ExpertsEditor(QWidget):
             self.window.ui.models[id].insertRow(i)
             name = data[n].name + "  [" + data[n].filename + "]"
             index = self.window.ui.models[id].index(i, 0)
-            tooltip = data[n].model + ", " + n
+            tooltip = data[n].uuid
             self.window.ui.models[id].setData(index, tooltip, QtCore.Qt.ToolTipRole)
             self.window.ui.models[id].setData(self.window.ui.models[id].index(i, 0), name)
             i += 1
@@ -120,7 +222,7 @@ class ExpertsEditor(QWidget):
             self.window.ui.models[id].insertRow(i)
             name = data[n].name + "  [" + data[n].filename + "]"
             index = self.window.ui.models[id].index(i, 0)
-            tooltip = data[n].model + ", " + n
+            tooltip = data[n].uuid
             self.window.ui.models[id].setData(index, tooltip, QtCore.Qt.ToolTipRole)
             self.window.ui.models[id].setData(self.window.ui.models[id].index(i, 0), name)
             i += 1
@@ -134,4 +236,4 @@ class ExpertsEditor(QWidget):
         :param selected: data with selected experts
         """
         self.update_available(available)
-        self.update_selected(selected)
+        self.update_selected(selected)

pygpt_net/ui/widget/lists/model_editor.py

@@ -6,14 +6,16 @@
 # 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.12.27 20:00:00                  #
 # ================================================== #
 
 from PySide6.QtGui import QAction, QIcon
-from PySide6.QtWidgets import QMenu
+from PySide6.QtCore import Qt, QItemSelectionModel
+from PySide6.QtWidgets import QMenu, QAbstractItemView
 
 from pygpt_net.ui.widget.lists.base import BaseList
 from pygpt_net.utils import trans
+import pygpt_net.icons_rc
 
 
 class ModelEditorList(BaseList):
@@ -28,9 +30,153 @@ class ModelEditorList(BaseList):
         self.window = window
         self.id = id
 
+        # Virtual multi-select helpers
+        self._suppress_item_click = False  # suppress business click after Ctrl/Shift selection
+        self._ctrl_multi_active = False    # Ctrl gesture in progress
+        self._ctrl_multi_index = None
+        self._was_shift_click = False      # Shift range gesture
+
+        # Context menu selection backup (temporary right-click selection)
+        self._backup_selection = None
+        self.restore_after_ctx_menu = True
+
+        # Row-based multi-selection behavior
+        self.setSelectionBehavior(QAbstractItemView.SelectRows)
+        self.setSelectionMode(QAbstractItemView.ExtendedSelection)
+
+        # Disable default BaseList click handler; business action is handled manually
+        self.clicked.disconnect(self.click)
+
+    # ----------------------------
+    # Selection helpers
+    # ----------------------------
+
+    def _selected_rows(self) -> list[int]:
+        """Return list of selected row numbers."""
+        try:
+            return sorted([ix.row() for ix in self.selectionModel().selectedRows()])
+        except Exception:
+            return []
+
+    def _has_multi_selection(self) -> bool:
+        """Check whether more than one row is selected."""
+        try:
+            return len(self.selectionModel().selectedRows()) > 1
+        except Exception:
+            return False
+
+    # ----------------------------
+    # Mouse events (virtual multi-select)
+    # ----------------------------
+
+    def mousePressEvent(self, event):
+        """
+        Mouse press event
+
+        :param event: mouse event
+        """
+        # Ctrl+Left: virtual toggle without business click
+        if event.button() == Qt.LeftButton and (event.modifiers() & Qt.ControlModifier):
+            idx = self.indexAt(event.pos())
+            if idx.isValid():
+                self._ctrl_multi_active = True
+                self._ctrl_multi_index = idx
+                self._suppress_item_click = True
+                event.accept()
+                return
+            self._suppress_item_click = True
+            event.accept()
+            return
+
+        # Shift+Left: let Qt perform range selection (anchor->clicked), suppress business click
+        if event.button() == Qt.LeftButton and (event.modifiers() & Qt.ShiftModifier):
+            idx = self.indexAt(event.pos())
+            self._suppress_item_click = True
+            self._was_shift_click = True
+            if idx.isValid():
+                super(ModelEditorList, self).mousePressEvent(event)
+            else:
+                event.accept()
+            return
+
+        # Plain left click
+        if event.button() == Qt.LeftButton:
+            idx = self.indexAt(event.pos())
+
+            # When multiple are selected, a single plain click clears the multi-selection.
+            if self._has_multi_selection():
+                sel_model = self.selectionModel()
+                sel_model.clearSelection()
+                if not idx.isValid():
+                    event.accept()
+                    return
+                # continue with default single selection for clicked row
+
+            super(ModelEditorList, self).mousePressEvent(event)
+            return
+
+        # Right click: prepare selection for context menu
+        if event.button() == Qt.RightButton:
+            idx = self.indexAt(event.pos())
+            sel_model = self.selectionModel()
+            selected_rows = [ix.row() for ix in sel_model.selectedRows()]
+            multi = len(selected_rows) > 1
+
+            if idx.isValid():
+                if multi and idx.row() in selected_rows:
+                    # Keep existing multi-selection; do not alter selection on right click
+                    self._backup_selection = None
+                else:
+                    # Temporarily select the clicked row; backup previous selection to restore later
+                    self._backup_selection = list(sel_model.selectedIndexes())
+                    sel_model.clearSelection()
+                    sel_model.select(idx, QItemSelectionModel.Select | QItemSelectionModel.Rows)
+            event.accept()
+            return
+
+        super(ModelEditorList, self).mousePressEvent(event)
+
+    def mouseReleaseEvent(self, event):
+        # If the click was a Shift-based range selection, bypass business click
+        if event.button() == Qt.LeftButton and self._was_shift_click:
+            self._was_shift_click = False
+            self._suppress_item_click = False
+            super(ModelEditorList, self).mouseReleaseEvent(event)
+            return
+
+        # Finish "virtual" Ctrl toggle on same row (no business click)
+        if event.button() == Qt.LeftButton and self._ctrl_multi_active:
+            try:
+                idx = self.indexAt(event.pos())
+                if idx.isValid() and self._ctrl_multi_index and idx == self._ctrl_multi_index:
+                    sel_model = self.selectionModel()
+                    sel_model.select(idx, QItemSelectionModel.Toggle | QItemSelectionModel.Rows)
+            finally:
+                self._ctrl_multi_active = False
+                self._ctrl_multi_index = None
+                self._suppress_item_click = False
+            event.accept()
+            return
+
+        # Plain left: perform business selection only for single selection
+        if event.button() == Qt.LeftButton:
+            idx = self.indexAt(event.pos())
+            if not self._has_multi_selection():
+                if idx.isValid() and not self._suppress_item_click:
+                    self.window.controller.model.editor.select(idx.row())
+            self._suppress_item_click = False
+            super(ModelEditorList, self).mouseReleaseEvent(event)
+            return
+
+        super(ModelEditorList, self).mouseReleaseEvent(event)
+
     def click(self, val):
-        idx = val.row()
-        self.window.controller.model.editor.select(idx)
+        # Not used; single-selection business click is handled in mouseReleaseEvent
+        pass
+
+    # ----------------------------
+    # Context menu
+    # ----------------------------
 
     def contextMenuEvent(self, event):
         """
@@ -40,25 +186,82 @@ class ModelEditorList(BaseList):
         """
         actions = {}
         actions['delete'] = QAction(QIcon(":/icons/delete.svg"), trans('action.delete'), self)
-        actions['delete'].triggered.connect(
-            lambda: self.action_delete(event))
+        actions['duplicate'] = QAction(QIcon(":/icons/copy.svg"), trans('action.duplicate'), self)
 
         menu = QMenu(self)
+        menu.addAction(actions['duplicate'])
         menu.addAction(actions['delete'])
 
-        item = self.indexAt(event.pos())
-        idx = item.row()
-        if idx >= 0:
-            menu.exec_(event.globalPos())
+        index = self.indexAt(event.pos())
+        idx = index.row() if index.isValid() else -1
+
+        # Selection state for multi / single
+        selected_rows = self._selected_rows()
+        multi = len(selected_rows) > 1
+
+        # Allow menu on empty area only when multi-selection is active
+        if not index.isValid() and not multi:
+            if self._backup_selection is not None and self.restore_after_ctx_menu:
+                sel_model = self.selectionModel()
+                sel_model.clearSelection()
+                for i in self._backup_selection:
+                    sel_model.select(i, QItemSelectionModel.Select | QItemSelectionModel.Rows)
+                self._backup_selection = None
+            return
 
-    def action_delete(self, event):
+        # Route actions: pass list on multi, int on single
+        if multi:
+            actions['duplicate'].triggered.connect(lambda: self.action_duplicate(list(selected_rows)))
+            actions['delete'].triggered.connect(lambda: self.action_delete(list(selected_rows)))
+        else:
+            actions['duplicate'].triggered.connect(lambda: self.action_duplicate(idx))
+            actions['delete'].triggered.connect(lambda: self.action_delete(idx))
+
+        menu.exec_(event.globalPos())
+
+        # Restore selection after context menu if it was temporarily changed
+        if self.restore_after_ctx_menu and self._backup_selection is not None:
+            sel_model = self.selectionModel()
+            sel_model.clearSelection()
+            for i in self._backup_selection:
+                sel_model.select(i, QItemSelectionModel.Select | QItemSelectionModel.Rows)
+            self._backup_selection = None
+        self.restore_after_ctx_menu = True
+
+    # ----------------------------
+    # Context actions (single or multi)
+    # If 'item' is a list/tuple -> pass list of row ints to external code.
+    # If 'item' is an int -> pass single row int to external code.
+    # ----------------------------
+
+    def action_delete(self, item):
         """
         Delete action handler
 
-        :param event: mouse event
+        :param item: int row or list of rows
         """
-        item = self.indexAt(event.pos())
-        idx = item.row()
+        if isinstance(item, (list, tuple)):
+            if item:
+                self.restore_after_ctx_menu = False
+                self.window.controller.model.editor.delete_by_idx(list(item))
+            return
+        idx = int(item)
         if idx >= 0:
+            self.restore_after_ctx_menu = False
             self.window.controller.model.editor.delete_by_idx(idx)
 
+    def action_duplicate(self, item):
+        """
+        Duplicate action handler
+
+        :param item: int row or list of rows
+        """
+        if isinstance(item, (list, tuple)):
+            if item:
+                self.restore_after_ctx_menu = False
+                self.window.controller.model.editor.duplicate_by_idx(list(item))
+            return
+        idx = int(item)
+        if idx >= 0:
+            self.restore_after_ctx_menu = False
+            self.window.controller.model.editor.duplicate_by_idx(idx)

pygpt_net/ui/widget/lists/model_importer.py

@@ -1,3 +1,5 @@
+# models_list.py
+
 #!/usr/bin/env python3
 # -*- coding: utf-8 -*-
 # ================================================== #
@@ -6,16 +8,129 @@
 # 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.12.27 21:00:00                  #
 # ================================================== #
 
 from PySide6 import QtCore
-from PySide6.QtGui import QStandardItemModel
-from PySide6.QtWidgets import QWidget, QHBoxLayout, QPushButton, QVBoxLayout, QLabel, QCheckBox
+from PySide6.QtGui import QStandardItemModel, QAction, QIcon
+from PySide6.QtWidgets import QWidget, QHBoxLayout, QPushButton, QVBoxLayout, QLabel, QCheckBox, QAbstractItemView, QMenu
 
 from pygpt_net.ui.widget.lists.base import BaseList
 from pygpt_net.utils import trans
 
+
+class ImporterList(BaseList):
+    def __init__(self, window=None, id=None):
+        """
+        Importer list view with virtual multi-select and context menu.
+
+        - ExtendedSelection enables Ctrl/Shift multi-select gestures.
+        - Single left click with no modifiers clears multi-selection when active.
+        - Right-click context menu:
+            * available list: Import
+            * current list: Remove
+        """
+        super(ImporterList, self).__init__(window, id=id)
+        self.setSelectionBehavior(QAbstractItemView.SelectRows)
+        self.setSelectionMode(QAbstractItemView.ExtendedSelection)
+
+        # RMB context menu
+        self.setContextMenuPolicy(QtCore.Qt.CustomContextMenu)
+        self.customContextMenuRequested.connect(self.show_context_menu)
+        self._backup_selection = None
+        self.restore_after_ctx_menu = True
+
+    def mousePressEvent(self, event):
+        """
+        Clear multi-selection on a single left click (any position or empty area),
+        then proceed with default selection behavior for the clicked row.
+        """
+        if event.button() == QtCore.Qt.LeftButton and event.modifiers() == QtCore.Qt.NoModifier:
+            sel_model = self.selectionModel()
+            if sel_model is not None and len(sel_model.selectedRows()) > 1:
+                index = self.indexAt(event.pos())
+                sel_model.clearSelection()
+                if not index.isValid():
+                    event.accept()
+                    return
+        super(ImporterList, self).mousePressEvent(event)
+
+    def _selected_rows(self):
+        """Return list of selected row indexes."""
+        try:
+            return list(self.selectionModel().selectedRows())
+        except Exception:
+            return []
+
+    def show_context_menu(self, pos: QtCore.QPoint):
+        """Context menu for available/current lists."""
+        index = self.indexAt(pos)
+        selected = self._selected_rows()
+        multi = len(selected) > 1
+
+        # Allow menu on empty area only when selection exists
+        if not index.isValid() and not selected:
+            return
+
+        sel_model = self.selectionModel()
+
+        # If right-clicked inside current multi-selection -> keep it
+        # Else select the row under cursor temporarily
+        if index.isValid():
+            if multi:
+                if index not in selected:
+                    self._backup_selection = list(sel_model.selectedIndexes())
+                    sel_model.clearSelection()
+                    sel_model.select(index, sel_model.Select | sel_model.Rows)
+                else:
+                    self._backup_selection = None
+            else:
+                if not selected or index not in selected:
+                    self._backup_selection = list(sel_model.selectedIndexes())
+                    sel_model.clearSelection()
+                    sel_model.select(index, sel_model.Select | sel_model.Rows)
+                else:
+                    self._backup_selection = None
+        else:
+            # empty area with some selection -> keep selection
+            self._backup_selection = None
+
+        menu = QMenu(self)
+        if self.id == "models.importer.available":
+            act_import = QAction(QIcon(":/icons/add.svg"), trans("action.import"), menu)
+            act_import.triggered.connect(self._action_import)
+            act_import.setEnabled(len(self._selected_rows()) > 0)
+            menu.addAction(act_import)
+        elif self.id == "models.importer.current":
+            act_remove = QAction(QIcon(":/icons/close.svg"), trans("action.delete"), menu)
+            act_remove.triggered.connect(self._action_remove)
+            act_remove.setEnabled(len(self._selected_rows()) > 0)
+            menu.addAction(act_remove)
+        else:
+            return  # unknown list; no menu
+
+        global_pos = self.viewport().mapToGlobal(pos)
+        menu.exec_(global_pos)
+
+        # Restore original selection if it was temporarily changed and no action executed
+        if self.restore_after_ctx_menu and self._backup_selection is not None:
+            sel_model.clearSelection()
+            for i in self._backup_selection:
+                sel_model.select(i, sel_model.Select | sel_model.Rows)
+        self._backup_selection = None
+        self.restore_after_ctx_menu = True
+
+    def _action_import(self):
+        """Import selected models from available list (same as '>')."""
+        self.restore_after_ctx_menu = False
+        self.window.controller.model.importer.add()
+
+    def _action_remove(self):
+        """Remove selected models from current list (same as '<')."""
+        self.restore_after_ctx_menu = False
+        self.window.controller.model.importer.remove()
+
+
 class ModelImporter(QWidget):
     def __init__(self, window=None):
         """
@@ -66,11 +181,13 @@ class ModelImporter(QWidget):
         arrows_layout.addWidget(self.window.ui.nodes["models.importer.remove"])
 
         self.window.ui.nodes["models.importer.available.label"] = QLabel(trans("models.importer.available.label"))
-        self.window.ui.nodes["models.importer.available"] = BaseList(self.window)
+        # importer-specific list with virtual multi-select + context menu
+        self.window.ui.nodes["models.importer.available"] = ImporterList(self.window, id="models.importer.available")
         self.window.ui.nodes["models.importer.available"].clicked.disconnect()
 
         self.window.ui.nodes["models.importer.current.label"] = QLabel(trans("models.importer.current.label"))
-        self.window.ui.nodes["models.importer.current"] = BaseList(self.window)
+        # importer-specific list with virtual multi-select + context menu
+        self.window.ui.nodes["models.importer.current"] = ImporterList(self.window, id="models.importer.current")
         self.window.ui.nodes["models.importer.current"].clicked.disconnect()
 
         self.window.ui.nodes["models.importer.available.all"] = QCheckBox(trans("models.importer.all"), self.window)
@@ -110,6 +227,7 @@ class ModelImporter(QWidget):
                 name += f" ({data[n].name})"
             index = self.window.ui.models[id].index(i, 0)
             tooltip = data[n].id
+            # store model ID in tooltip role for stable retrieval from view
             self.window.ui.models[id].setData(index, tooltip, QtCore.Qt.ToolTipRole)
             self.window.ui.models[id].setData(self.window.ui.models[id].index(i, 0), name)
             i += 1
@@ -134,6 +252,7 @@ class ModelImporter(QWidget):
                 name = "* " + name  # mark imported models
             index = self.window.ui.models[id].index(i, 0)
             tooltip = data[n].id
+            # store model ID in tooltip role for stable retrieval from view
             self.window.ui.models[id].setData(index, tooltip, QtCore.Qt.ToolTipRole)
             self.window.ui.models[id].setData(self.window.ui.models[id].index(i, 0), name)
             i += 1
@@ -147,4 +266,4 @@ class ModelImporter(QWidget):
         :param current: data with current models
         """
         self.update_available(available)
-        self.update_current(current)
+        self.update_current(current)