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

pygpt_net/controller/model/importer.py

@@ -6,13 +6,14 @@
 # GitHub:  https://github.com/szczyglis-dev/py-gpt   #
 # MIT License                                        #
 # Created By  : Marcin Szczygliński                  #
-# Updated Date: 2025.09.05 18:00:00                  #
+# Updated Date: 2025.12.27 21:00:00                  #
 # ================================================== #
 
 import copy
 import os
 from typing import List, Dict, Optional, Any
 
+from PySide6 import QtCore
 from PySide6.QtWidgets import QApplication
 
 from pygpt_net.core.events import Event
@@ -45,8 +46,10 @@ class Importer:
         self.items_current = {}  # current models in use
         self.pending = {}  # waiting to be imported models
         self.removed = {}  # waiting to be removed models
-        self.selected_available = None  # selected available model
-        self.selected_current = None  # selected current model
+        self.selected_available = None  # selected available model (single)
+        self.selected_current = None  # selected current model (single)
+        self.selected_available_ids: List[str] = []  # multi-selected available models
+        self.selected_current_ids: List[str] = []  # multi-selected current models
         self.all = False  # show all models, not only available for import
         self.provider = "_"  # default provider
 
@@ -69,43 +72,71 @@ class Importer:
 
     def change_available(self):
         """On change available model selection"""
-        val = self.window.ui.nodes["models.importer.available"].selectionModel().currentIndex()
-        idx = val.row()
-        if idx < 0:
+        view = self.window.ui.nodes["models.importer.available"]
+        sel_model = view.selectionModel()
+        rows = sel_model.selectedRows() if sel_model else []
+        # collect selected model keys by reading stored tooltip role (stable ID)
+        selected_ids = []
+        for ix in rows:
+            key = ix.data(QtCore.Qt.ToolTipRole)
+            if not key:
+                key = self.get_by_idx(ix.row(), self.items_available)
+            if key and key not in selected_ids:
+                selected_ids.append(key)
+
+        self.selected_available_ids = selected_ids
+        if not selected_ids:
             self.selected_available = None
             self.window.ui.nodes["models.importer.add"].setEnabled(False)
-        else:
-            self.selected_available = self.get_by_idx(idx, self.items_available)
-            if self.items_available.get(self.selected_available) is None:
-                self.selected_available = None
-                self.window.ui.nodes["models.importer.add"].setEnabled(False)
-            else:
-                # if not in current then enable add button
-                if not self.in_current(self.selected_available):
-                    self.window.ui.nodes["models.importer.add"].setEnabled(True)
-                else:
-                    self.window.ui.nodes["models.importer.add"].setEnabled(False)
+            return
+
+        # keep a single reference for backward compatibility (last selected)
+        self.selected_available = selected_ids[-1]
+
+        # enable add if any of selected can be added (not already in current)
+        can_add = False
+        for key in selected_ids:
+            if key is None:
+                continue
+            if not self.in_current(key) and self.items_available.get(key) is not None:
+                can_add = True
+                break
+        self.window.ui.nodes["models.importer.add"].setEnabled(can_add)
 
     def change_current(self):
         """On change current model selection"""
         if self.provider not in self.items_current:
             self.items_current[self.provider] = {}
-        val = self.window.ui.nodes["models.importer.current"].selectionModel().currentIndex()
-        idx = val.row()
-        if idx < 0:
+        view = self.window.ui.nodes["models.importer.current"]
+        sel_model = view.selectionModel()
+        rows = sel_model.selectedRows() if sel_model else []
+        # collect selected model keys by reading stored tooltip role (stable ID)
+        selected_ids = []
+        for ix in rows:
+            key = ix.data(QtCore.Qt.ToolTipRole)
+            if not key:
+                key = self.get_by_idx(ix.row(), self.items_current[self.provider])
+            if key and key not in selected_ids:
+                selected_ids.append(key)
+
+        self.selected_current_ids = selected_ids
+        if not selected_ids:
             self.selected_current = None
             self.window.ui.nodes["models.importer.remove"].setEnabled(False)
-        else:
-            self.selected_current = self.get_by_idx(idx, self.items_current[self.provider])
-            if self.items_current[self.provider].get(self.selected_current) is None:
-                self.selected_current = None
-                self.window.ui.nodes["models.importer.remove"].setEnabled(False)
-            else:
-                if (self.selected_current in self.items_current[self.provider]
-                        and self.in_available(self.selected_current)):
-                    self.window.ui.nodes["models.importer.remove"].setEnabled(True)
-                else:
-                    self.window.ui.nodes["models.importer.remove"].setEnabled(False)
+            return
+
+        # keep a single reference for backward compatibility (last selected)
+        self.selected_current = selected_ids[-1]
+
+        # enable remove if any of selected can be removed
+        can_remove = False
+        for key in selected_ids:
+            if key is None:
+                continue
+            if (key in self.items_current[self.provider]) and self.in_available(key):
+                can_remove = True
+                break
+        self.window.ui.nodes["models.importer.remove"].setEnabled(can_remove)
 
     def in_available(self, model: str) -> bool:
         """
@@ -122,43 +153,111 @@ class Importer:
                 return True
         return False
 
+    def _selected_keys_from_view(self, node_id: str, items: Dict) -> List[str]:
+        """
+        Resolve selected model keys from a given list view using stored tooltip role,
+        falling back to index->dict mapping when needed.
+
+        :param node_id: ui node id
+        :param items: dict used to build the view's model
+        :return: list of selected keys
+        """
+        keys: List[str] = []
+        try:
+            view = self.window.ui.nodes[node_id]
+            sel_model = view.selectionModel()
+            rows = sel_model.selectedRows() if sel_model else []
+            for ix in rows:
+                key = ix.data(QtCore.Qt.ToolTipRole)
+                if not key:
+                    key = self.get_by_idx(ix.row(), items)
+                if key and key not in keys:
+                    keys.append(key)
+        except Exception:
+            pass
+        return keys
+
     def add(self):
-        """Add model to current list"""
+        """Add model(s) to current list"""
         if self.provider not in self.items_current:
             self.items_current[self.provider] = {}
-        if self.selected_available is None:
+
+        # collect multi-selection; fallback to single selection
+        keys = self._selected_keys_from_view(
+            'models.importer.available',
+            self.items_available,
+        )
+        if not keys and self.selected_available is not None:
+            keys = [self.selected_available]
+
+        if not keys:
             self.set_status(trans('models.importer.error.add.no_model'))
             return
-        if self.in_current(self.selected_available):
+
+        any_added = False
+        for key in list(keys):
+            if key is None:
+                continue
+            if self.in_current(key):
+                continue
+            model = self.items_available.get(key)
+            if model is None:
+                continue
+            self.items_current[self.provider][key] = model
+            if key not in self.pending:
+                self.pending[key] = model
+            if key in self.removed:
+                del self.removed[key]
+            if not self.all and key in self.items_available:
+                del self.items_available[key]
+            any_added = True
+
+        if not any_added:
             self.set_status(trans('models.importer.error.add.not_exists'))
             return
-        model = self.items_available[self.selected_available]
-        self.items_current[self.provider][self.selected_available] = model
-        if self.selected_available not in self.pending:
-            self.pending[self.selected_available] = model
-        if self.selected_available in self.removed:
-            del self.removed[self.selected_available]
-        if not self.all:
-            del self.items_available[self.selected_available]
+
         self.refresh()
 
     def remove(self):
-        """Remove model from current list"""
+        """Remove model(s) from current list"""
         if self.provider not in self.items_current:
             self.items_current[self.provider] = {}
-        if self.selected_current is None:
+
+        # collect multi-selection; fallback to single selection
+        keys = self._selected_keys_from_view(
+            'models.importer.current',
+            self.items_current[self.provider],
+        )
+        if not keys and self.selected_current is not None:
+            keys = [self.selected_current]
+
+        if not keys:
             self.set_status(trans('models.importer.error.remove.no_model'))
             return
-        if not self.in_current(self.selected_current):
+
+        any_removed = False
+        for key in list(keys):
+            if key is None:
+                continue
+            if not self.in_current(key):
+                continue
+            model = self.items_current[self.provider].get(key)
+            if model is None:
+                continue
+            # return to available list
+            self.items_available[key] = model
+            if key not in self.removed:
+                self.removed[key] = model
+            if key in self.items_current[self.provider]:
+                del self.items_current[self.provider][key]
+            if key in self.pending:
+                del self.pending[key]
+            any_removed = True
+
+        if not any_removed:
             self.set_status(trans('models.importer.error.remove.not_exists'))
             return
-        model = self.items_current[self.provider][self.selected_current]
-        self.items_available[self.selected_current] = model
-        if self.selected_current not in self.removed:
-            self.removed[self.selected_current] = model
-        del self.items_current[self.provider][self.selected_current]
-        if self.selected_current in self.pending:
-            del self.pending[self.selected_current]
+
         self.refresh()
 
     def setup(self):
@@ -328,7 +427,7 @@ class Importer:
             name = model.get('id')
             if "name" in model:
                 name = model.get('name')
-            m = self.window.core.models.create_empty(append=False)
+            m, _ = self.window.core.models.create_empty(append=False)
             m.id = id
             m.name = name
             m.mode = [
@@ -504,7 +603,7 @@ class Importer:
             else:
                 for model in ollama_models:
                     name = model.get('name')
-                    m = self.window.core.models.create_empty(append=False)
+                    m, _ = self.window.core.models.create_empty(append=False)
                     m.id = name
                     m.name = name
                     m.mode = [

pygpt_net/controller/painter/painter.py

@@ -6,7 +6,7 @@
 # GitHub:  https://github.com/szczyglis-dev/py-gpt   #
 # MIT License                                        #
 # Created By  : Marcin Szczygliński                  #
-# Updated Date: 2025.09.02 15:00:00                  #
+# Updated Date: 2025.12.27 17:00:00                  #
 # ================================================== #
 
 import os
@@ -53,7 +53,7 @@ class Painter:
         """
         self.open(path)
         if not self.is_active():
-            self.window.controller.ui.switch_tab('draw')
+            self.window.controller.ui.tabs.switch_tab(Tab.TAB_TOOL_PAINTER)
 
     def save(self):
         """Store current image"""

pygpt_net/controller/presets/experts.py

@@ -6,9 +6,11 @@
 # GitHub:  https://github.com/szczyglis-dev/py-gpt   #
 # MIT License                                        #
 # Created By  : Marcin Szczygliński                  #
-# Updated Date: 2025.08.14 13:00:00                  #
+# Updated Date: 2025.12.27 21:00:00                  #
 # ================================================== #
 
+from PySide6 import QtCore
+
 from pygpt_net.core.types import (
     MODE_EXPERT,
 )
@@ -23,6 +25,8 @@ class Experts:
         :param window: Window instance
         """
         self.window = window
+        self.selected_available_uuids = []  # multi-selected available experts
+        self.selected_selected_uuids = []   # multi-selected selected experts
 
     def refresh(self):
         """Refresh presets"""
@@ -78,13 +82,43 @@ class Experts:
 
         self.update_tab()
 
+    def _selected_uuids_from_view(self, node_id: str, fallback_idx_resolver) -> list[str]:
+        """
+        Resolve selected expert UUIDs from a given list view using stored tooltip role,
+        falling back to idx -> uuid resolver when needed.
+
+        :param node_id: ui node id
+        :param fallback_idx_resolver: callable that maps row index -> uuid
+        :return: list of selected uuids
+        """
+        uuids = []
+        try:
+            view = self.window.ui.nodes[node_id]
+            sel_model = view.selectionModel()
+            rows = sel_model.selectedRows() if sel_model else []
+            for ix in rows:
+                uuid = ix.data(QtCore.Qt.ToolTipRole)
+                if not uuid:
+                    uuid = fallback_idx_resolver(ix.row())
+                if uuid and uuid not in uuids:
+                    uuids.append(uuid)
+        except Exception:
+            pass
+        return uuids
+
     def change_available(self):
-        """Change selected expert"""
-        pass
+        """Change selected expert(s) in available list"""
+        self.selected_available_uuids = self._selected_uuids_from_view(
+            "preset.experts.available",
+            self.get_available_by_idx
+        )
 
     def change_selected(self):
-        """Change selected expert"""
-        pass
+        """Change selected expert(s) in selected list"""
+        self.selected_selected_uuids = self._selected_uuids_from_view(
+            "preset.experts.selected",
+            self.get_selected_by_idx
+        )
 
     def get_current_available(self) -> str:
         """
@@ -138,27 +172,47 @@ class Experts:
             i += 1
 
     def add_expert(self):
-        """Add expert"""
+        """Add expert(s)"""
         agent_uuid = self.get_current_agent_id()
         if agent_uuid is None or not self.window.core.presets.exists_uuid(agent_uuid):
             self.window.controller.presets.editor.save(close=False)
             return
-        expert_uuid = self.get_current_available()
-        if expert_uuid is None:
+
+        uuids = self.selected_available_uuids[:]
+        if not uuids:
+            one = self.get_current_available()
+            if one:
+                uuids = [one]
+
+        if not uuids:
             return
-        self.window.core.presets.add_expert(agent_uuid, expert_uuid)
+
+        for expert_uuid in uuids:
+            if expert_uuid and not self.is_active(expert_uuid):
+                self.window.core.presets.add_expert(agent_uuid, expert_uuid)
+
         self.update_list()
 
     def remove_expert(self):
-        """Remove expert"""
+        """Remove expert(s)"""
         agent_uuid = self.get_current_agent_id()
         if agent_uuid is None or not self.window.core.presets.exists_uuid(agent_uuid):
             self.window.controller.presets.editor.save(close=False)
             return
-        expert_uuid = self.get_current_selected()
-        if expert_uuid is None:
+
+        uuids = self.selected_selected_uuids[:]
+        if not uuids:
+            one = self.get_current_selected()
+            if one:
+                uuids = [one]
+
+        if not uuids:
             return
-        self.window.core.presets.remove_expert(agent_uuid, expert_uuid)
+
+        for expert_uuid in uuids:
+            if expert_uuid and self.is_active(expert_uuid):
+                self.window.core.presets.remove_expert(agent_uuid, expert_uuid)
+
         self.update_list()
 
     def update_tab(self):
@@ -174,5 +228,4 @@ class Experts:
         if num == 0:
             tabs.setTabText(idx, trans("preset.tab.experts"))
         else:
-            tabs.setTabText(idx, trans("preset.tab.experts") + f" ({num})")
-
+            tabs.setTabText(idx, trans("preset.tab.experts") + f" ({num})")

pygpt_net/controller/presets/presets.py

@@ -6,11 +6,11 @@
 # GitHub:  https://github.com/szczyglis-dev/py-gpt   #
 # MIT License                                        #
 # Created By  : Marcin Szczygliński                  #
-# Updated Date: 2025.12.25 20:00:00                  #
+# Updated Date: 2025.12.27 21:00:00                  #
 # ================================================== #
 
 import re
-from typing import Optional, List, Dict
+from typing import Optional, List, Dict, Union
 
 from PySide6.QtCore import QTimer
 from PySide6.QtGui import QTextCursor
@@ -536,25 +536,39 @@ class Presets:
         """
         return _FILENAME_SANITIZE_RE.sub('_', name.lower())
 
-    def duplicate(self, idx: Optional[int] = None):
+    def duplicate(self, idx: Optional[Union[int, list]] = None):
         """
         Duplicate preset
 
-        :param idx: preset index (row index)
+        :param idx: preset ID (or list of IDs)
         """
-        if idx is not None:
-            w = self.window
-            mode = w.core.config.get('mode')
-            preset = w.core.presets.get_by_idx(idx, mode)
-            if preset:
-                if preset in w.core.presets.items:
-                    new_id = w.core.presets.duplicate(preset)
-                    self.update_list()
-                    self.refresh(no_scroll=True)
-                    idx = w.core.presets.get_idx_by_id(mode, new_id)
-                    self.editor.edit(idx)
-                    self.select(idx) # switch to the new preset
-                    w.update_status(trans('status.preset.duplicated'))
+        ids = idx if isinstance(idx, list) else [idx]
+        last_id = None
+        updated = False
+        w = self.window
+        mode = w.core.config.get('mode')
+        for idx in ids:
+            if idx is not None:
+                if len(ids) > 1:
+                    preset = w.core.presets.get_by_id(mode, idx)  # by ID, PresetItem
+                    preset_id = preset.filename if preset else None
+                else:
+                    preset = w.core.presets.get_by_idx(idx, mode) # by index, str
+                    preset_id = preset
+                if preset_id:
+                    new_id = w.core.presets.duplicate(preset_id)
+                    last_id = new_id
+                    updated = True
+
+        if updated:
+            self.update_list()
+            self.refresh(no_scroll=True)
+            if len(ids) == 1 and idx is not None:
+                idx = w.core.presets.get_idx_by_id(mode, last_id)
+                self.editor.edit(idx)
+                self.select(idx)  # switch to the new preset if only one was duplicated
+            w.update_status(trans('status.preset.duplicated'))
+
 
     def enable(self, idx: Optional[int] = None):
         """
@@ -654,30 +668,49 @@ class Presets:
 
     def delete(
             self,
-            idx: Optional[int] = None,
+            idx: Optional[Union[int, list]] = None,
             force: bool = False
     ):
         """
         Delete preset
 
-        :param idx: preset index (row index)
+        :param idx: preset index (row index) or list of indices
         :param force: force delete without confirmation
         """
-        if idx is not None:
-            w = self.window
-            mode = w.core.config.get('mode')
-            preset_id = w.core.presets.get_by_idx(idx, mode)
-            if preset_id and preset_id in w.core.presets.items:
-                if not force:
-                    w.ui.dialogs.confirm(
-                        type='preset_delete',
-                        id=idx,
-                        msg=trans('confirm.preset.delete'),
-                    )
-                    return
-
-                # Determine neighbor only if the deleted preset is currently active.
-                # This keeps API semantics untouched and prevents unexpected selection changes.
+        ids = idx if isinstance(idx, list) else [idx]
+        w = self.window
+        mode = w.core.config.get('mode')
+        is_preset = False
+        updated = False
+        for tmp_id in ids:
+            if len(ids) > 1:
+                preset = w.core.presets.get_by_id(mode, tmp_id)  # by ID, PresetItem
+            else:
+                preset = w.core.presets.get_by_idx(tmp_id, mode)  # by index, str
+            if preset:
+                is_preset = True
+                break
+
+        if ids and is_preset:
+            if not force:
+                w.ui.dialogs.confirm(
+                    type='preset_delete',
+                    id=idx,
+                    msg=trans('confirm.preset.delete'),
+                )
+                return
+
+            # Determine neighbor only if the deleted preset is currently active.
+            # This keeps API semantics untouched and prevents unexpected selection changes.
+            for idx in ids:
+                if len(ids) > 1:
+                    preset = w.core.presets.get_by_id(mode, idx) # by ID, PresetItem
+                    preset_id = preset.filename if preset else None
+                else:
+                    preset = w.core.presets.get_by_idx(idx, mode) # by index, str
+                    preset_id = preset
+                if not preset:
+                    continue
                 is_current = (preset_id == w.core.config.get('preset'))
                 target_id = None
                 if is_current:
@@ -700,8 +733,11 @@ class Presets:
                         w.core.config.set('preset', None)
                         w.ui.nodes['preset.prompt'].setPlainText("")
 
-                self.refresh(no_scroll=True)
-                w.update_status(trans('status.preset.deleted'))
+                updated = True
+
+        if updated:
+            self.refresh(no_scroll=True)
+            w.update_status(trans('status.preset.deleted'))
 
     def restore(self, force: bool = False):
         """