pygpt-net 2.6.67__py3-none-any.whl → 2.7.1__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/common.py

@@ -47,7 +47,12 @@ class Common:
         :param width: Canvas width
         :param height: Canvas height
         """
-        self.window.ui.painter.setFixedSize(QSize(width, height))
+        painter = self.window.ui.painter
+        if hasattr(painter, "set_canvas_size_pixels"):
+            painter.set_canvas_size_pixels(width, height)
+        else:
+            # required on image open
+            self.window.ui.painter.setFixedSize(QSize(width, height))
 
     def set_brush_mode(self, enabled: bool):
         """
@@ -81,14 +86,21 @@ class Common:
         if self._changing_canvas_size:
             return
 
-        combo: QComboBox = self.window.ui.nodes['painter.select.canvas.size']
+        # Be resilient if combobox node is not present in a given UI layout
+        combo: Optional[QComboBox] = None
+        try:
+            if hasattr(self.window.ui, "nodes"):
+                combo = self.window.ui.nodes.get('painter.select.canvas.size', None)
+        except Exception:
+            combo = None
+
         painter = self.window.ui.painter
 
         # Heuristic to detect manual UI change vs programmatic call
         # - manual if: no arg, or int index (Qt int overload), or arg equals currentText/currentData
         raw_arg = selected
-        current_text = combo.currentText()
-        current_data = combo.currentData()
+        current_text = combo.currentText() if combo is not None else ""
+        current_data = combo.currentData() if combo is not None else None
         current_data_str = current_data if isinstance(current_data, str) else None
         is_manual = (
             raw_arg is None
@@ -105,8 +117,15 @@ class Common:
         if not selected_norm:
             return
 
+        # Use true logical canvas size when available
+        if hasattr(painter, "get_canvas_size"):
+            cur_sz = painter.get_canvas_size()
+            cur_val = f"{cur_sz.width()}x{cur_sz.height()}"
+        else:
+            cur_val = f"{painter.width()}x{painter.height()}"
+
         # Save undo only for manual changes and only if size will change
-        will_change = selected_norm != f"{painter.width()}x{painter.height()}"
+        will_change = selected_norm != cur_val
         if is_manual and will_change:
             painter.saveForUndo()
 
@@ -124,9 +143,10 @@ class Common:
                     self._sticky_custom_value = selected_norm
 
             # Ensure combo reflects single custom at index 0 (sticky respected), then select current value
-            self._sync_canvas_size_combo(combo, selected_norm, sticky_to_keep=self._sticky_custom_value)
+            if combo is not None:
+                self._sync_canvas_size_combo(combo, selected_norm, sticky_to_keep=self._sticky_custom_value)
 
-            # Apply canvas size; PainterWidget handles rescaling in resizeEvent
+            # Apply canvas size; PainterWidget handles rescaling in its own logic
             w, h = self.convert_to_size(selected_norm)
             self.set_canvas_size(w, h)
 
@@ -272,10 +292,22 @@ class Common:
         if self._changing_canvas_size:
             return
 
-        combo: QComboBox = self.window.ui.nodes['painter.select.canvas.size']
+        combo: Optional[QComboBox] = None
+        try:
+            if hasattr(self.window.ui, "nodes"):
+                combo = self.window.ui.nodes.get('painter.select.canvas.size', None)
+        except Exception:
+            combo = None
+
         painter = self.window.ui.painter
 
-        canvas_value = f"{painter.width()}x{painter.height()}"
+        # Use true logical canvas size, not widget size
+        if hasattr(painter, "get_canvas_size"):
+            sz = painter.get_canvas_size()
+            canvas_value = f"{sz.width()}x{sz.height()}"
+        else:
+            canvas_value = f"{painter.width()}x{painter.height()}"
+
         canvas_norm = self._normalize_canvas_value(canvas_value)
         if not canvas_norm:
             return
@@ -292,7 +324,8 @@ class Common:
         try:
             self._changing_canvas_size = True
             self._sticky_custom_value = sticky
-            self._sync_canvas_size_combo(combo, canvas_norm, sticky_to_keep=sticky)
+            if combo is not None:
+                self._sync_canvas_size_combo(combo, canvas_norm, sticky_to_keep=sticky)
 
             # Persist canvas size only (do not change sticky config-scope)
             self.window.core.config.set('painter.canvas.size', canvas_norm)
@@ -409,7 +442,6 @@ class Common:
                 combo.setCurrentText(value)
         else:
             # Current value is custom: ensure it exists at index 0 and select it
-            # If sticky differs or is None, overwrite/create the custom at index 0 to reflect true current value.
             if not sticky_to_keep or sticky_to_keep != value:
                 self._ensure_custom_index0(combo, value, predef)
             if combo.currentIndex() != 0:

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})")