pygpt-net 2.6.66__py3-none-any.whl → 2.7.0__py3-none-any.whl

pygpt_net/ui/widget/lists/assistant.py

@@ -6,12 +6,12 @@
 # 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.QtCore import QItemSelectionModel, QPoint
 from PySide6.QtGui import QAction, QIcon, Qt
-from PySide6.QtWidgets import QMenu
+from PySide6.QtWidgets import QMenu, QAbstractItemView
 
 from pygpt_net.ui.widget.lists.base import BaseList
 from pygpt_net.utils import trans
@@ -20,7 +20,7 @@ from pygpt_net.utils import trans
 class AssistantList(BaseList):
     def __init__(self, window=None, id=None):
         """
-        Presets select menu
+        Assistants select menu
 
         :param window: main window
         :param id: input id
@@ -34,7 +34,61 @@ class AssistantList(BaseList):
         self.restore_after_ctx_menu = True
         self._backup_selection = None
 
+        # Enable row-based multi-select with Ctrl/Shift gestures
+        self.setSelectionBehavior(QAbstractItemView.SelectRows)
+        self.setSelectionMode(QAbstractItemView.ExtendedSelection)
+
+        # Virtual multi-select helpers to suppress business click after Ctrl/Shift
+        self._suppress_item_click = False
+        self._ctrl_multi_active = False
+        self._ctrl_multi_index = None
+        self._was_shift_click = False
+
+    # ----------------------------
+    # Helpers
+    # ----------------------------
+
+    def _selected_indexes(self):
+        """Return list of selected row indexes (column 0)."""
+        try:
+            return list(self.selectionModel().selectedRows())
+        except Exception:
+            return []
+
+    def _selected_rows(self) -> list[int]:
+        """Return list of selected row numbers."""
+        try:
+            return [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
+
+    # ----------------------------
+    # Clicks
+    # ----------------------------
+
     def click(self, val):
+        """
+        Row click handler.
+
+        Suppresses business click when triggered by virtual Ctrl/Shift multi-select
+        and when multiple rows are selected.
+        """
+        # Skip business click right after Ctrl/Shift selection
+        if self._suppress_item_click:
+            self._suppress_item_click = False
+            return
+
+        # Ignore business click if multiple are selected
+        if self._has_multi_selection():
+            return
+
         self.window.controller.assistant.select(val.row())
 
     def dblclick(self, val):
@@ -43,7 +97,13 @@ class AssistantList(BaseList):
 
         :param val: double click event
         """
-        self.window.controller.assistant.editor.edit(val.row())
+        row = val.row()
+        if row >= 0:
+            self.window.controller.assistant.editor.edit(row)
+
+    # ----------------------------
+    # Context menu
+    # ----------------------------
 
     def show_context_menu(self, pos: QPoint):
         """
@@ -52,24 +112,41 @@ class AssistantList(BaseList):
         :param pos: QPoint
         """
         global_pos = self.viewport().mapToGlobal(pos)
-        item = self.indexAt(pos)
+        index = self.indexAt(pos)
+        idx = index.row() if index.isValid() else -1
+
+        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:
+            return
 
         actions = {}
         actions['edit'] = QAction(QIcon(":/icons/edit.svg"), trans('assistant.action.edit'), self)
+        actions['delete'] = QAction(QIcon(":/icons/delete.svg"), trans('assistant.action.delete'), self)
+
+        # Edit only for single selection
+        actions['edit'].setEnabled(idx >= 0 and not multi)
         actions['edit'].triggered.connect(
-            lambda checked=False, item=item: self.action_edit(item))
+            lambda checked=False, item=index: self.action_edit(item)
+        )
 
-        actions['delete'] = QAction(QIcon(":/icons/delete.svg"), trans('assistant.action.delete'), self)
-        actions['delete'].triggered.connect(
-            lambda checked=False, item=item: self.action_delete(item))
+        # Delete for single or multi; pass list when multi
+        if multi:
+            actions['delete'].triggered.connect(
+                lambda checked=False, rows=list(selected_rows): self.action_delete(rows)
+            )
+        else:
+            actions['delete'].triggered.connect(
+                lambda checked=False, item=index: self.action_delete(item)
+            )
 
         menu = QMenu(self)
         menu.addAction(actions['edit'])
         menu.addAction(actions['delete'])
 
-        idx = item.row()
-        if idx >= 0:
-            #self.window.controller.assistant.select(item.row())
+        if idx >= 0 or multi:
             menu.exec_(global_pos)
 
         # store previous scroll position
@@ -79,9 +156,9 @@ class AssistantList(BaseList):
         if self.restore_after_ctx_menu:
             if self._backup_selection is not None:
                 self.selectionModel().clearSelection()
-                for idx in self._backup_selection:
+                for i in self._backup_selection:
                     self.selectionModel().select(
-                        idx, QItemSelectionModel.Select | QItemSelectionModel.Rows
+                        i, QItemSelectionModel.Select | QItemSelectionModel.Rows
                     )
                 self._backup_selection = None
 
@@ -89,11 +166,15 @@ class AssistantList(BaseList):
         self.restore_after_ctx_menu = True
         self.restore_scroll_position()
 
+    # ----------------------------
+    # Context actions
+    # ----------------------------
+
     def action_edit(self, item):
         """
         Edit action handler
 
-        :param item: list item
+        :param item: QModelIndex
         """
         idx = item.row()
         if idx >= 0:
@@ -104,35 +185,115 @@ class AssistantList(BaseList):
         """
         Delete action handler
 
-        :param item: list item
+        :param item: QModelIndex for single, or list[int] for multi
         """
+        if isinstance(item, (list, tuple)):
+            self.restore_after_ctx_menu = False  # do not restore selection after context menu
+            self.window.controller.assistant.delete(list(item))
+            return
+
         idx = item.row()
         if idx >= 0:
             self.restore_after_ctx_menu = False  # do not restore selection after context menu
             self.window.controller.assistant.delete(idx)
 
+    # ----------------------------
+    # Mouse events (virtual multi-select)
+    # ----------------------------
+
     def mousePressEvent(self, event):
+        # Ctrl+Left: virtual toggle without business click
+        if event.button() == Qt.LeftButton and (event.modifiers() & Qt.ControlModifier):
+            idx = self.indexAt(event.pos())
+            self._suppress_item_click = True
+            if idx.isValid():
+                self._ctrl_multi_active = True
+                self._ctrl_multi_index = idx
+                event.accept()
+                return
+            # Ctrl on empty area -> just suppress business click
+            event.accept()
+            return
+
+        # Shift+Left: let Qt perform range selection, 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().mousePressEvent(event)  # default range selection behavior
+            else:
+                event.accept()
+            return
+
         if event.button() == Qt.LeftButton:
             index = self.indexAt(event.pos())
-            if not index.isValid():
+
+            # When multiple are selected, a single click clears the multi-selection
+            if self._has_multi_selection():
+                self.selectionModel().clearSelection()
+                if not index.isValid():
+                    event.accept()
+                    return
+                # continue with default single selection for clicked row
+
+            # Proceed with default handling
+            if index.isValid():
+                super().mousePressEvent(event)
                 return
-            super().mousePressEvent(event)
+            else:
+                # Click on empty area -> clear any single selection
+                self.selectionModel().clearSelection()
+                event.accept()
+                return
+
         elif event.button() == Qt.RightButton:
             index = self.indexAt(event.pos())
+            sel_model = self.selectionModel()
+            selected_rows = [ix.row() for ix in sel_model.selectedRows()]
+            multi = len(selected_rows) > 1
+
             if index.isValid():
-                self._backup_selection = list(self.selectionModel().selectedIndexes())
-                self.selectionModel().clearSelection()
-                self.selectionModel().select(
-                    index, QItemSelectionModel.Select | QItemSelectionModel.Rows
-                )
+                if multi and index.row() in selected_rows:
+                    # Keep existing multi-selection; do not alter selection on right click
+                    self._backup_selection = None
+                else:
+                    # Select the clicked row temporarily for single or when clicking outside current multi
+                    self._backup_selection = list(sel_model.selectedIndexes())
+                    sel_model.clearSelection()
+                    sel_model.select(index, QItemSelectionModel.Select | QItemSelectionModel.Rows)
             event.accept()
+            return
+
         else:
             super().mousePressEvent(event)
 
+    def mouseReleaseEvent(self, event):
+        # Finish Shift-range selection: skip business click path
+        if event.button() == Qt.LeftButton and self._was_shift_click:
+            self._was_shift_click = False
+            super().mouseReleaseEvent(event)
+            return
+
+        # Finish "virtual" Ctrl toggle on same row
+        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
+            event.accept()
+            return
+
+        super().mouseReleaseEvent(event)
+
     def selectionCommand(self, index, event=None):
         """
         Selection command
         :param index: Index
         :param event: Event
         """
-        return super().selectionCommand(index, event)
+        return super().selectionCommand(index, event)

pygpt_net/ui/widget/lists/assistant_store.py

@@ -6,11 +6,12 @@
 # GitHub:  https://github.com/szczyglis-dev/py-gpt   #
 # MIT License                                        #
 # Created By  : Marcin Szczygliński                  #
-# Updated Date: 2024.04.29 16:00:00                  #
+# Updated Date: 2025.12.27 00: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
@@ -29,9 +30,153 @@ class AssistantVectorStoreEditorList(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(AssistantVectorStoreEditorList, 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(AssistantVectorStoreEditorList, 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(AssistantVectorStoreEditorList, 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(AssistantVectorStoreEditorList, 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.assistant.store.select(idx.row())
+            self._suppress_item_click = False
+            super(AssistantVectorStoreEditorList, self).mouseReleaseEvent(event)
+            return
+
+        super(AssistantVectorStoreEditorList, self).mouseReleaseEvent(event)
+
     def click(self, val):
-        idx = val.row()
-        self.window.controller.assistant.store.select(idx)
+        # Not used; single-selection business click is handled in mouseReleaseEvent
+        pass
+
+    # ----------------------------
+    # Context menu
+    # ----------------------------
 
     def contextMenuEvent(self, event):
         """
@@ -40,24 +185,22 @@ class AssistantVectorStoreEditorList(BaseList):
         :param event: context menu event
         """
         actions = {}
-        actions['refresh'] = QAction(QIcon(":/icons/reload.svg"),
-                                      trans('dialog.assistant.store.menu.current.refresh_store'),
-                                      self)
-        actions['refresh'].triggered.connect(
-            lambda: self.action_refresh(event))
-
+        actions['refresh'] = QAction(
+            QIcon(":/icons/reload.svg"),
+            trans('dialog.assistant.store.menu.current.refresh_store'),
+            self
+        )
         actions['delete'] = QAction(QIcon(":/icons/delete.svg"), trans('action.delete'), self)
-        actions['delete'].triggered.connect(
-            lambda: self.action_delete(event))
-
-        actions['clear'] = QAction(QIcon(":/icons/close.svg"), trans('dialog.assistant.store.menu.current.clear_files'), self)
-        actions['clear'].triggered.connect(
-            lambda: self.action_clear(event))
-
-        actions['truncate'] = QAction(QIcon(":/icons/delete.svg"), trans('dialog.assistant.store.menu.current.truncate_files'),
-                                   self)
-        actions['truncate'].triggered.connect(
-            lambda: self.action_truncate(event))
+        actions['clear'] = QAction(
+            QIcon(":/icons/close.svg"),
+            trans('dialog.assistant.store.menu.current.clear_files'),
+            self
+        )
+        actions['truncate'] = QAction(
+            QIcon(":/icons/delete.svg"),
+            trans('dialog.assistant.store.menu.current.truncate_files'),
+            self
+        )
 
         menu = QMenu(self)
         menu.addAction(actions['refresh'])
@@ -65,50 +208,110 @@ class AssistantVectorStoreEditorList(BaseList):
         menu.addAction(actions['clear'])
         menu.addAction(actions['truncate'])
 
-        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
 
-    def action_delete(self, event):
+        # 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
+
+        # Route actions: pass list on multi, int on single
+        if multi:
+            actions['refresh'].triggered.connect(lambda: self.action_refresh(list(selected_rows)))
+            actions['delete'].triggered.connect(lambda: self.action_delete(list(selected_rows)))
+            actions['clear'].triggered.connect(lambda: self.action_clear(list(selected_rows)))
+            actions['truncate'].triggered.connect(lambda: self.action_truncate(list(selected_rows)))
+        else:
+            actions['refresh'].triggered.connect(lambda: self.action_refresh(idx))
+            actions['delete'].triggered.connect(lambda: self.action_delete(idx))
+            actions['clear'].triggered.connect(lambda: self.action_clear(idx))
+            actions['truncate'].triggered.connect(lambda: self.action_truncate(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.assistant.store.delete_by_idx(list(item))
+            return
+        idx = int(item)
         if idx >= 0:
+            self.restore_after_ctx_menu = False
             self.window.controller.assistant.store.delete_by_idx(idx)
 
-    def action_clear(self, event):
+    def action_clear(self, item):
         """
         Clear 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.assistant.batch.clear_store_files_by_idx(list(item))
+            return
+        idx = int(item)
         if idx >= 0:
+            self.restore_after_ctx_menu = False
             self.window.controller.assistant.batch.clear_store_files_by_idx(idx)
 
-    def action_truncate(self, event):
+    def action_truncate(self, item):
         """
         Truncate 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.assistant.batch.truncate_store_files_by_idx(list(item))
+            return
+        idx = int(item)
         if idx >= 0:
+            self.restore_after_ctx_menu = False
             self.window.controller.assistant.batch.truncate_store_files_by_idx(idx)
 
-    def action_refresh(self, event):
+    def action_refresh(self, item):
         """
         Refresh action handler
         """
-        item = self.indexAt(event.pos())
-        idx = item.row()
+        if isinstance(item, (list, tuple)):
+            if item:
+                self.restore_after_ctx_menu = False
+                self.window.controller.assistant.store.refresh_by_idx(list(item))
+            return
+        idx = int(item)
         if idx >= 0:
-            self.window.controller.assistant.store.refresh_by_idx(idx)
-
+            self.restore_after_ctx_menu = False
+            self.window.controller.assistant.store.refresh_by_idx(idx)