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

pygpt_net/controller/model/editor.py

@@ -6,12 +6,12 @@
 # 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 20:00:00                  #
 # ================================================== #
 
 import copy
 import json
-from typing import Optional, Any
+from typing import Optional, Any, Union
 
 from pygpt_net.core.events import Event
 from pygpt_net.utils import trans
@@ -33,6 +33,7 @@ class Editor:
         self.height = 500
         self.selected = []
         self.locked = False
+        self.provider = "-" # all providers by default
         self.options = {
             "id": {
                 "type": "text",
@@ -137,12 +138,40 @@ class Editor:
         if key in self.options:
             return self.options[key]
 
+    def get_provider_option(self) -> dict:
+        """
+        Get provider option
+
+        :return: provider option
+        """
+        return {
+            "type": "combo",
+            "use": "llm_providers",
+            "label": "model.provider",
+            "description": "model.provider.desc",
+        }
+
     def setup(self):
         """Set up editor"""
         idx = None
         self.window.model_settings.setup(idx)  # widget dialog setup
         self.window.ui.add_hook("update.model.name", self.hook_update)
         self.window.ui.add_hook("update.model.mode", self.hook_update)
+        self.update_provider(self.provider)
+        self.window.ui.add_hook("update.model.provider_global", self.hook_update)
+
+    def update_provider(self, provider: str):
+        """
+        Set provider
+
+        :param provider: provider name
+        """
+        self.window.controller.config.apply_value(
+            parent_id="model",
+            key="provider_global",
+            option=self.get_provider_option(),
+            value=provider,
+        )
 
     def hook_update(
             self,
@@ -163,6 +192,21 @@ class Editor:
         """
         if self.window.controller.reloading or self.locked:
             return  # ignore hooks during reloading process
+
+        if key == "provider_global":
+            # update provider option dynamically
+            if self.provider == value:
+                return
+            self.save(persist=False)
+            self.locked = True
+            self.current = None
+            self.provider = value
+            self.reload_items()
+            if self.current is None:
+                self.init()
+            self.locked = False
+            return
+
         if key in ["id", "name", "mode"]:
             self.save(persist=False)
             self.reload_items()
@@ -184,6 +228,7 @@ class Editor:
 
         :param force: force open dialog
         """
+        self.locked = True
         if not self.config_initialized:
             self.setup()
             self.config_initialized = True
@@ -197,6 +242,9 @@ class Editor:
                 height=self.height,
             )
             self.dialog = True
+            if "models.editor.search" in self.window.ui.nodes:
+                self.window.ui.nodes['models.editor.search'].setFocus()  # focus on search
+        self.locked = False
 
     def undo(self):
         """Undo last changes in models editor"""
@@ -219,15 +267,16 @@ class Editor:
         self.window.core.models.sort_items()
         self.reload_items()
 
-        # select the first plugin on list if no plugin selected yet
+        # select the first model on list if no model selected yet
+        items = self.prepare_items()
         if self.current is None:
-            if len(self.window.core.models.items) > 0:
-                self.current = list(self.window.core.models.items.keys())[0]
+            if len(items) > 0:
+                self.current = list(items.keys())[0]
 
         # assign model options to config dialog fields
         options = copy.deepcopy(self.get_options())  # copy options
-        if self.current in self.window.core.models.items:
-            model = self.window.core.models.items[self.current]
+        if self.current in items:
+            model = items[self.current]
             data_dict = model.to_dict()
             for key in options:
                 if key in data_dict:
@@ -237,7 +286,7 @@ class Editor:
             # custom fields
             options["extra_json"]["value"] = json.dumps(model.extra, indent=4) if model.extra else ""
 
-        if self.current is not None and self.current in self.window.core.models.items:
+        if self.current is not None and self.current in items:
             self.set_tab_by_id(self.current)
 
         # load and apply options to config dialog
@@ -313,10 +362,26 @@ class Editor:
         event = Event(Event.MODELS_CHANGED)
         self.window.dispatch(event, all=True)
 
+    def prepare_items(self) -> dict:
+        """
+        Prepare items by provider
+
+        :return: items by provider
+        """
+        items = self.window.core.models.items
+        if self.provider == "-":
+            return items # all providers
+        items_by_provider = {}
+        for model_id, model in items.items():
+            provider = model.provider
+            if provider != self.provider:
+                continue
+            items_by_provider[model_id] = model
+        return items_by_provider
+
     def reload_items(self):
         """Reload items"""
-        items = self.window.core.models.items
-        self.window.model_settings.update_list("models.list", items)
+        self.window.model_settings.update_list("models.list", self.prepare_items())
 
     def select(self, idx: int):
         """Select model"""
@@ -330,14 +395,15 @@ class Editor:
         """Create new model"""
         self.locked = True
         self.save(persist=False)
-        model = self.window.core.models.create_empty()
+        model, new_id = self.window.core.models.create_empty()
+        if self.provider != "-":
+            model.provider = self.provider
         self.window.core.models.sort_items()
         self.window.core.models.save()
         self.reload_items()
 
         # switch to created model
         self.current = model.id
-        # sort here
         idx = self.get_tab_by_id(self.current)
         self.set_by_tab(idx)
         self.init()
@@ -345,17 +411,15 @@ class Editor:
 
     def delete_by_idx(
             self,
-            idx: int,
+            idx: Union[int, list],
             force: bool = False
     ):
         """
         Delete model by idx
 
-        :param idx: model idx
+        :param idx: model idx or list of idxs
         :param force: force delete
         """
-        self.locked = True
-        model = self.get_model_by_tab_idx(idx)
         if not force:
             self.window.ui.dialogs.confirm(
                 type="models.editor.delete",
@@ -363,14 +427,70 @@ class Editor:
                 msg=trans("dialog.models.editor.delete.confirm"),
             )
             return
-        self.window.core.models.delete(model)
-        self.window.core.models.save()
-        self.reload_items()
-        if self.current == model:
-            self.current = None
+
+        self.locked = True
+        models = []
+        last_idx = None
+        ids = idx if isinstance(idx, list) else [idx]
+        for i in ids:
+            model = self.get_model_by_tab_idx(i)
+            if model:
+                models.append(model)
+            last_idx = i
+
+        for model in models:
+            self.window.core.models.delete(model)
+            self.window.core.models.save()
+            self.reload_items()
+            if self.current == model:
+                self.current = None
+
+        # switch to previous model if available
+        items = self.prepare_items()
+        if len(items) > 0:
+            model = self.get_model_by_tab_idx(last_idx - 1)
+            if model:
+                self.current = model
+
         self.init()
         self.locked = False
 
+    def duplicate_by_idx(
+            self,
+            idx: Union[int, list]
+    ):
+        """
+        Duplicate model by idx
+
+        :param idx: model idx or list of idxs
+        """
+        self.locked = True
+        self.save(persist=False)
+        ids = idx if isinstance(idx, list) else [idx]
+        models = []
+        for i in ids:
+            model = self.get_model_by_tab_idx(i)
+            if model:
+                models.append(model)
+
+        for model in models:
+            if model:
+                new_model, new_id = self.window.core.models.create_empty()
+                new_model.from_dict(self.window.core.models.items[model].to_dict())
+                new_model.name += " (Copy)"
+                self.window.core.models.sort_items()
+                self.window.core.models.save()
+                self.reload_items()
+
+                # switch to created model if only one duplicated
+                if len(models) == 1:
+                    self.current = new_id
+                    idx = self.get_tab_by_id(self.current)
+                    self.set_by_tab(idx)
+                    self.init()
+
+        self.locked = False
+
     def load_defaults_user(self, force: bool = False):
         """
         Load models editor user defaults

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