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

pygpt_net/ui/widget/lists/profile.py

@@ -6,11 +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.28 04:00:00                  #
 # ================================================== #
 
+from PySide6.QtCore import Qt, QItemSelectionModel
 from PySide6.QtGui import QAction, QIcon
-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
@@ -28,50 +29,158 @@ class ProfileList(BaseList):
         self.window = window
         self.id = id
 
+        # Enable row-based multi-select with native Ctrl/Shift gestures
+        self.setSelectionBehavior(QAbstractItemView.SelectRows)
+        self.setSelectionMode(QAbstractItemView.ExtendedSelection)
+
+        # Context menu restore helper
+        self._backup_selection = None
+        self.restore_after_ctx_menu = True
+
+    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:
+        """Return True when multiple rows are selected."""
+        try:
+            return len(self.selectionModel().selectedRows()) > 1
+        except Exception:
+            return False
+
+    def mousePressEvent(self, event):
+        """
+        Mouse press event
+        - Ctrl: let Qt toggle selection (virtual; no business action).
+        - Shift: let Qt range-select (virtual).
+        - If multiple are selected: a single left click anywhere clears selection.
+        """
+        if event.button() == Qt.LeftButton and (event.modifiers() & Qt.ControlModifier):
+            idx = self.indexAt(event.pos())
+            if idx.isValid():
+                super(ProfileList, self).mousePressEvent(event)  # native toggle
+            else:
+                event.accept()
+            return
+
+        if event.button() == Qt.LeftButton and (event.modifiers() & Qt.ShiftModifier):
+            idx = self.indexAt(event.pos())
+            if idx.isValid():
+                super(ProfileList, self).mousePressEvent(event)  # native range
+            else:
+                event.accept()
+            return
+
+        if event.button() == Qt.LeftButton:
+            index = self.indexAt(event.pos())
+            # Clear multi-selection with a single click (also on empty area)
+            if self._has_multi_selection():
+                sel_model = self.selectionModel()
+                sel_model.clearSelection()
+                if not index.isValid():
+                    event.accept()
+                    return
+            # Default selection behavior
+            super(ProfileList, self).mousePressEvent(event)
+            return
+
+        super(ProfileList, self).mousePressEvent(event)
+
     def click(self, val):
         pass
 
     def contextMenuEvent(self, event):
         """
         Context menu event
-
-        :param event: context menu event
+        - Shows menu on a row, or on empty area when multi-selection is active.
+        - For multi-selection, actions pass list[int] of selected rows.
+        - For single selection, actions pass single int (legacy behavior).
         """
         actions = {}
         actions['use'] = QAction(QIcon(":/icons/check.svg"), trans('action.use'), self)
-        actions['use'].triggered.connect(
-            lambda: self.action_use(event))
         actions['edit'] = QAction(QIcon(":/icons/edit.svg"), trans('action.edit'), self)
-        actions['edit'].triggered.connect(
-            lambda: self.action_edit(event))
         actions['duplicate'] = QAction(QIcon(":/icons/copy.svg"), trans('action.duplicate'), self)
-        actions['duplicate'].triggered.connect(
-            lambda: self.action_duplicate(event))
-
-
         actions['reset'] = QAction(QIcon(":/icons/close.svg"), trans('action.reset'), self)
-        actions['reset'].triggered.connect(
-            lambda: self.action_reset(event))
         actions['delete'] = QAction(QIcon(":/icons/delete.svg"), trans('action.profile.delete'), self)
-        actions['delete'].triggered.connect(
-            lambda: self.action_delete(event))
         actions['delete_all'] = QAction(QIcon(":/icons/delete.svg"), trans('action.profile.delete_all'), self)
-        actions['delete_all'].triggered.connect(
-            lambda: self.action_delete_all(event))
+
+        # Hit test
+        index = self.indexAt(event.pos())
+        idx = index.row() if index.isValid() else -1
+
+        # Current selection state
+        sel_model = self.selectionModel()
+        selected_indexes = list(sel_model.selectedRows()) if sel_model else []
+        selected_rows = [ix.row() for ix in selected_indexes]
+        multi = len(selected_rows) > 1
+
+        # Allow menu on empty area only when multi-selection is active
+        if not index.isValid() and not multi:
+            return
+
+        # If right-click outside the current multi-selection, temporarily select clicked row
+        backup_selection = None
+        if index.isValid():
+            if multi and idx in selected_rows:
+                backup_selection = None  # keep selection as-is
+            else:
+                backup_selection = list(sel_model.selectedIndexes())
+                sel_model.clearSelection()
+                sel_model.select(index, QItemSelectionModel.Select | QItemSelectionModel.Rows)
+                selected_rows = [idx]
+                multi = False
 
         menu = QMenu(self)
-        menu.addAction(actions['edit'])
-        menu.addAction(actions['use'])
-        menu.addAction(actions['duplicate'])
-        menu.addAction(actions['reset'])
-        menu.addAction(actions['delete'])
-        menu.addAction(actions['delete_all'])
 
-        item = self.indexAt(event.pos())
-        idx = item.row()
-        if idx >= 0:
+        if not multi:
+            # Single: keep legacy behavior (pass single index via event)
+            menu.addAction(actions['edit'])
+            actions['edit'].triggered.connect(lambda: self.action_edit(event))
+
+            menu.addAction(actions['use'])
+            actions['use'].triggered.connect(lambda: self.action_use(event))
+
+            menu.addAction(actions['duplicate'])
+            actions['duplicate'].triggered.connect(lambda: self.action_duplicate(event))
+
+            menu.addAction(actions['reset'])
+            actions['reset'].triggered.connect(lambda: self.action_reset(event))
+
+            menu.addAction(actions['delete'])
+            actions['delete'].triggered.connect(lambda: self.action_delete(event))
+
+            menu.addAction(actions['delete_all'])
+            actions['delete_all'].triggered.connect(lambda: self.action_delete_all(event))
+        else:
+            # Multi: keep only actions that make sense in bulk; Use/Edit/Duplicate are single-only
+            rows = list(selected_rows)
+
+            menu.addAction(actions['reset'])
+            actions['reset'].triggered.connect(lambda checked=False, r=rows: self._action_reset_multi(r))
+
+            menu.addAction(actions['delete'])
+            actions['delete'].triggered.connect(lambda checked=False, r=rows: self._action_delete_multi(r))
+
+            menu.addAction(actions['delete_all'])
+            actions['delete_all'].triggered.connect(lambda checked=False, r=rows: self._action_delete_all_multi(r))
+
+        # Show menu
+        if index.isValid() or multi:
             menu.exec_(event.globalPos())
 
+        # Restore selection after context menu if it was temporarily changed
+        if backup_selection is not None and self.restore_after_ctx_menu:
+            sel_model.clearSelection()
+            for i in backup_selection:
+                sel_model.select(i, QItemSelectionModel.Select | QItemSelectionModel.Rows)
+        self._backup_selection = None
+        self.restore_after_ctx_menu = True
+
+    # ---------- Single-item handlers (legacy; keep unchanged signatures) ----------
+
     def action_use(self, event):
         """
         Use action handler
@@ -138,3 +247,16 @@ class ProfileList(BaseList):
         if idx >= 0:
             self.window.controller.settings.profile.edit_by_idx(idx)
 
+    # ---------- Multi-item handlers (new; pass list[int]) ----------
+
+    def _action_reset_multi(self, rows: list[int]):
+        if rows:
+            self.window.controller.settings.profile.reset_by_idx(list(rows))
+
+    def _action_delete_multi(self, rows: list[int]):
+        if rows:
+            self.window.controller.settings.profile.delete_by_idx(list(rows))
+
+    def _action_delete_all_multi(self, rows: list[int]):
+        if rows:
+            self.window.controller.settings.profile.delete_all_by_idx(list(rows))

pygpt_net/ui/widget/lists/uploaded.py

@@ -6,11 +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 00:00:00                  #
 # ================================================== #
 
 from PySide6.QtGui import QAction, QIcon, QResizeEvent, Qt
-from PySide6.QtWidgets import QMenu
+from PySide6.QtCore import QItemSelectionModel
+from PySide6.QtWidgets import QMenu, QAbstractItemView
 
 from pygpt_net.ui.widget.lists.base import BaseList
 from pygpt_net.utils import trans
@@ -27,10 +28,30 @@ class UploadedFileList(BaseList):
         super(UploadedFileList, self).__init__(window)
         self.window = window
         self.id = id
+
+        # double click selects item (business action)
         self.doubleClicked.connect(self.dblclick)
+
+        # keep header visible here
         self.setHeaderHidden(False)
+
+        # disable default click handler from BaseList; we drive selection manually
         self.clicked.disconnect(self.click)
 
+        # Flat, row-based, multi-select behavior
+        self.setSelectionBehavior(QAbstractItemView.SelectRows)
+        self.setSelectionMode(QAbstractItemView.ExtendedSelection)
+
+        # 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
+
         self.header = self.header()
         self.header.setStretchLastSection(False)
 
@@ -48,24 +69,139 @@ class UploadedFileList(BaseList):
         super().resizeEvent(event)
         self.adjustColumnWidths()
 
+    # ----------------------------
+    # 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
         """
-        if event.buttons() == Qt.LeftButton:
-            index = self.indexAt(event.pos())
-            if index.isValid():
-                self.window.controller.assistant.files.select(index.row())
+        # 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
+            # Ctrl on empty space -> just suppress
+            self._suppress_item_click = True
+            event.accept()
+            return
+
+        # Shift+Left: let Qt perform range selection, but 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(UploadedFileList, 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 clicked on empty area: just clear and return.
+            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
+
+            # Perform default selection handling (no business click here)
+            super(UploadedFileList, 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(UploadedFileList, 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(UploadedFileList, 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.files.select(idx.row())
+            self._suppress_item_click = False
+            super(UploadedFileList, self).mouseReleaseEvent(event)
+            return
+
+        super(UploadedFileList, self).mouseReleaseEvent(event)
+
     def click(self, val):
         """
         Click event
 
         :param val: click event
         """
+        # Not used; single-selection business click is handled in mouseReleaseEvent
         pass
 
     def dblclick(self, val):
@@ -74,7 +210,13 @@ class UploadedFileList(BaseList):
 
         :param val: double click event
         """
-        self.window.controller.assistant.files.select(val.row())
+        row = val.row()
+        if row >= 0:
+            self.window.controller.assistant.files.select(row)
+
+    # ----------------------------
+    # Context menu
+    # ----------------------------
 
     def contextMenuEvent(self, event):
         """
@@ -83,58 +225,108 @@ class UploadedFileList(BaseList):
         :param event: context menu event
         """
         actions = {}
-        actions['download'] = QAction(QIcon(":/icons/download.svg"), trans('action.download'), self)
-        actions['download'].triggered.connect(
-            lambda: self.action_download(event))
+        # actions['download'] = QAction(QIcon(":/icons/download.svg"), trans('action.download'), self)
+        menu = QMenu(self)
+        # menu.addAction(actions['download'])  # not allowed for download files with purpose: assistants :(
+        index = self.indexAt(event.pos())
+        idx = index.row() if index.isValid() else -1
 
-        actions['rename'] = QAction(QIcon(":/icons/edit.svg"), trans('action.rename'), self)
-        actions['rename'].triggered.connect(
-            lambda: self.action_rename(event))
+        # Selection state for multi / single
+        selected_rows = self._selected_rows()
+        multi = len(selected_rows) > 1
 
-        actions['delete'] = QAction(QIcon(":/icons/delete.svg"), trans('action.delete'), self)
-        actions['delete'].triggered.connect(
-            lambda: self.action_delete(event))
+        # Allow menu on empty area only when multi-selection is active
+        if not index.isValid() and not multi:
+            # Restore selection if it was temporarily changed on right click
+            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
 
-        menu = QMenu(self)
-        # menu.addAction(actions['download'])  # not allowed for download files with purpose: assistants :(
-        menu.addAction(actions['rename'])
-        menu.addAction(actions['delete'])
+        # Route actions: pass list on multi, int on single
+        if multi:
+            # actions['rename'] = QAction(QIcon(":/icons/edit.svg"), trans('action.rename'), self)
+            actions['delete'] = QAction(QIcon(":/icons/delete.svg"), trans('action.delete'), self)
+            # actions['rename'].triggered.connect(lambda: self.action_rename(list(selected_rows)))
+            actions['delete'].triggered.connect(lambda: self.action_delete(list(selected_rows)))
+            # menu.addAction(actions['rename'])
+            menu.addAction(actions['delete'])
+            # actions['download'].triggered.connect(lambda: self.action_download(list(selected_rows)))
+        else:
+            # Keep legacy behavior: on single right click also select item in controller
+            if idx >= 0:
+                self.window.controller.assistant.files.select(idx)
+            actions['rename'] = QAction(QIcon(":/icons/edit.svg"), trans('action.rename'), self)
+            actions['delete'] = QAction(QIcon(":/icons/delete.svg"), trans('action.delete'), self)
+            actions['rename'].triggered.connect(lambda: self.action_rename(idx))
+            actions['delete'].triggered.connect(lambda: self.action_delete(idx))
+            menu.addAction(actions['rename'])
+            menu.addAction(actions['delete'])
+            # actions['download'].triggered.connect(lambda: self.action_download(idx))
+        menu.exec_(event.globalPos())
 
-        item = self.indexAt(event.pos())
-        idx = item.row()
-        if idx >= 0:
-            self.window.controller.assistant.files.select(item.row())
-            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_rename(self, event):
+    def action_rename(self, item):
         """
         Rename 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.files.rename(list(item))
+            return
+        idx = int(item)
         if idx >= 0:
+            self.restore_after_ctx_menu = False
             self.window.controller.assistant.files.rename(idx)
 
-    def action_download(self, event):
+    def action_download(self, item):
         """
         Download 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.files.download(list(item))
+            return
+        idx = int(item)
         if idx >= 0:
+            self.restore_after_ctx_menu = False
             self.window.controller.assistant.files.download(idx)
 
-    def action_delete(self, event):
+    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.files.delete(list(item))
+            return
+        idx = int(item)
         if idx >= 0:
-            self.window.controller.assistant.files.delete(idx)
+            self.restore_after_ctx_menu = False
+            self.window.controller.assistant.files.delete(idx)