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

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

pygpt_net/controller/settings/profile.py

@@ -6,12 +6,12 @@
 # GitHub:  https://github.com/szczyglis-dev/py-gpt   #
 # MIT License                                        #
 # Created By  : Marcin Szczygliński                  #
-# Updated Date: 2025.09.26 13:00:00                  #
+# Updated Date: 2025.12.28 04:00:00                  #
 # ================================================== #
 
 import os
 from pathlib import Path
-from typing import Optional, Dict, Any
+from typing import Optional, Dict, Any, Union
 
 from PySide6.QtCore import Slot, QTimer
 from PySide6.QtGui import QAction
@@ -173,6 +173,8 @@ class Profile:
             self.setup()
             self.initialized = True
         if not self.dialog or force:
+            self.update_menu()
+            self.update_list()
             self.window.ui.dialogs.open(
                 'profile.editor',
                 width=self.width,
@@ -336,18 +338,26 @@ class Profile:
         uuid = self.get_id_by_idx(idx)
         self.switch(uuid)
 
-    def delete_by_idx(self, idx: int, force: bool = False):
+    def delete_by_idx(self, idx: Union[int, list], force: bool = False):
         """
         Delete profile by index
 
-        :param idx: profile index
+        :param idx: profile index or list of indexes
         :param force: force delete
         """
-        uuid = self.get_id_by_idx(idx)
+        uuids = []
+        ids = idx if isinstance(idx, list) else [idx]
+        for i in ids:
+            uuid = self.get_id_by_idx(i)
+            uuids.append(uuid)
         current = self.window.core.config.profile.get_current()
-        if uuid == current:
-            self.window.ui.dialogs.alert(trans("dialog.profile.alert.delete.current"))
-            return
+        for uuid in list(uuids):
+            if uuid == current:
+                if len(uuids) == 1:
+                    self.window.ui.dialogs.alert(trans("dialog.profile.alert.delete.current"))
+                    return
+                else:
+                    uuids.remove(uuid)  # skip current
         if not force:
             self.window.ui.dialogs.confirm(
                 type='profile.delete',
@@ -355,35 +365,48 @@ class Profile:
                 msg=trans('confirm.profile.delete'),
             )
             return
-        self.delete(uuid)
+        self.delete(uuids)
 
-    def delete(self, uuid: str):
+    def delete(self, uuid: Union[str, list]):
         """
         Delete profile (remove only)
 
-        :param uuid: profile ID
+        :param uuid: profile ID or list of IDs
         """
         profiles = self.get_profiles()
-        if uuid in profiles:
-            profile = profiles[uuid]
-            name = profile['name']
-            if self.window.core.config.profile.remove(uuid):
-                self.window.update_status(trans("dialog.profile.status.removed") + ": " + name)
-                self.update_list()
-                self.update_menu()
+        updated = False
+        ids = uuid if isinstance(uuid, list) else [uuid]
+        for uuid in ids:
+            if uuid in profiles:
+                profile = profiles[uuid]
+                name = profile['name']
+                if self.window.core.config.profile.remove(uuid):
+                    updated = True
+                    self.window.update_status(trans("dialog.profile.status.removed") + ": " + name)
+        if updated:
+            self.update_list()
+            self.update_menu()
 
-    def delete_all_by_idx(self, idx: int, force: bool = False):
+    def delete_all_by_idx(self, idx: Union[int, list], force: bool = False):
         """
         Delete profile with files by index
 
-        :param idx: profile index
+        :param idx: profile index or list of indexes
         :param force: force delete
         """
-        uuid = self.get_id_by_idx(idx)
+        uuids = []
+        ids = idx if isinstance(idx, list) else [idx]
+        for i in ids:
+            uuid = self.get_id_by_idx(i)
+            uuids.append(uuid)
         current = self.window.core.config.profile.get_current()
-        if uuid == current:
-            self.window.ui.dialogs.alert(trans("dialog.profile.alert.delete.current"))
-            return
+        for uuid in list(uuids):
+            if uuid == current:
+                if len(uuids) == 1:
+                    self.window.ui.dialogs.alert(trans("dialog.profile.alert.delete.current"))
+                    return
+                else:
+                    uuids.remove(uuid)  # skip current
         if not force:
             self.window.ui.dialogs.confirm(
                 type='profile.delete.all',
@@ -391,7 +414,7 @@ class Profile:
                 msg=trans('confirm.profile.delete_all'),
             )
             return
-        self.delete_all(uuid)
+        self.delete_all(uuids)
 
     def duplicate_by_idx(self, idx: int):
         """
@@ -416,13 +439,20 @@ class Profile:
         dialog.prepare()
         dialog.show()
 
-    def delete_all(self, uuid: str):
+    def delete_all(self, uuid: Union[str, list]):
         """
         Delete profile with files
 
-        :param uuid: profile ID
+        :param uuid: profile ID or list of IDs
         """
-        self.window.controller.settings.workdir.delete_files(uuid)
+        ids = uuid if isinstance(uuid, list) else [uuid]
+        batch = False
+        if len(ids) > 1:
+            batch = True
+        if not batch:
+            self.window.controller.settings.workdir.delete_files(uuid)
+        else:
+            self.window.controller.settings.workdir.delete_files(ids, batch=batch)
 
     @Slot(str)
     def after_delete(self, name: str):
@@ -468,22 +498,33 @@ class Profile:
         if self.window.ui.nodes['dialog.profile.checkbox.switch'].isChecked():
             self.switch(uuid, force=True)
 
-    def reset(self, uuid: str):
+    def reset(self, uuid: Union[str, list]):
         """
         Reset profile
 
-        :param uuid: profile ID
+        :param uuid: profile ID or list of IDs
         """
-        self.window.controller.settings.workdir.reset(uuid)
+        ids = uuid if isinstance(uuid, list) else [uuid]
+        batch = False
+        if len(ids) > 1:
+            batch = True
+        if not batch:
+            self.window.controller.settings.workdir.reset(uuid)
+        else:
+            self.window.controller.settings.workdir.reset(ids, batch=batch)
 
-    def reset_by_idx(self, idx: int, force: bool = False):
+    def reset_by_idx(self, idx: Union[int, list], force: bool = False):
         """
         Reset profile by index
 
-        :param idx: profile index
+        :param idx: profile index or list of indexes
         :param force: force reset
         """
-        uuid = self.get_id_by_idx(idx)
+        uuids = []
+        ids = idx if isinstance(idx, list) else [idx]
+        for i in ids:
+            uuid = self.get_id_by_idx(i)
+            uuids.append(uuid)
         if not force:
             self.window.ui.dialogs.confirm(
                 type='profile.reset',
@@ -491,7 +532,7 @@ class Profile:
                 msg=trans('confirm.profile.reset'),
             )
             return
-        self.reset(uuid)
+        self.reset(uuids)
 
     def is_include_db(self):
         """Get include db"""

pygpt_net/controller/settings/workdir.py

@@ -6,13 +6,13 @@
 # GitHub:  https://github.com/szczyglis-dev/py-gpt   #
 # MIT License                                        #
 # Created By  : Marcin Szczygliński                  #
-# Updated Date: 2025.09.26 13:00:00                  #
+# Updated Date: 2025.12.28 04:00:00                  #
 # ================================================== #
 
 import copy
 import os
 from pathlib import Path
-from typing import Optional
+from typing import Optional, Union
 from uuid import uuid4
 
 from PySide6.QtCore import QObject, QRunnable, Signal, Slot
@@ -50,9 +50,10 @@ class WorkdirWorker(QRunnable):
             force: bool = False,
             current: Optional[str] = None,
             profile_name: Optional[str] = None,
-            profile_uuid: Optional[str] = None,
+            profile_uuid: Optional[Union[str, list]] = None,
             profile_new_name: Optional[str] = None,
             profile_new_path: Optional[str] = None,
+            batch: bool = False,
     ):
         super().__init__()
         self.window = window
@@ -65,6 +66,7 @@ class WorkdirWorker(QRunnable):
         self.profile_new_name = profile_new_name
         self.profile_new_path = profile_new_path
         self.signals = WorkerSignals()
+        self.batch = batch
 
     @Slot()
     def run(self):
@@ -104,22 +106,34 @@ class WorkdirWorker(QRunnable):
         profiles = self.window.controller.settings.profile.get_profiles()
         remove_datadir = True
         remove_db = True
-        if uuid in profiles:
-            profile = profiles[uuid]
-            name = profile['name']
-            path = profile['workdir'].replace("%HOME%", str(Path.home()))
-            # remove profile
-            if self.window.core.config.profile.remove(uuid):
-                if not os.path.exists(path) or not os.path.isdir(path):
-                    self.signals.alert.emit(trans("dialog.profile.alert.path.not_exists"))
-                    return
-                print(f"Clearing workdir: {path}")
-                self.window.core.filesystem.clear_workdir(
-                    path,
-                    remove_db=remove_db,
-                    remove_datadir=remove_datadir,
-                )
-                self.signals.deleted.emit(name)
+        uuids = uuid if isinstance(uuid, list) else [uuid]
+        for uuid in uuids:
+            if uuid in profiles:
+                profile = profiles[uuid]
+                name = profile['name']
+                path = profile['workdir'].replace("%HOME%", str(Path.home()))
+                # remove profile
+                if self.window.core.config.profile.remove(uuid):
+                    if not os.path.exists(path) or not os.path.isdir(path):
+                        if not self.batch:
+                            self.signals.deleted.emit(name)
+                            self.signals.alert.emit(trans("dialog.profile.alert.path.not_exists"))
+                            return
+                        else:
+                            print("Directory not exists, ignoring: ", path)
+                            self.signals.updateGlobalStatus.emit(f"Directory not exists: {path}")
+                            self.signals.deleted.emit(name)
+                            return # nothing to delete
+                    print(f"Clearing workdir: {path}")
+                    try:
+                        self.window.core.filesystem.clear_workdir(
+                            path,
+                            remove_db=remove_db,
+                            remove_datadir=remove_datadir,
+                        )
+                    except Exception as e:
+                        print("Error deleting profile files: ", e)
+                    self.signals.deleted.emit(name)
 
     def worker_duplicate(self):
         """Duplicate profile"""
@@ -168,22 +182,30 @@ class WorkdirWorker(QRunnable):
         current = self.window.core.config.profile.get_current()
         remove_datadir = False
         remove_db = True
-        if uuid in profiles:
-            profile = profiles[uuid]
-            path = profile['workdir'].replace("%HOME%", str(Path.home()))
-            if not os.path.exists(path) or not os.path.isdir(path):
-                self.signals.alert.emit(f"Directory not exists: {path}")
-                return
-            print("Clearing workdir: ", path)
-            self.window.core.db.close()
-            self.window.core.filesystem.clear_workdir(
-                path,
-                remove_db=remove_db,
-                remove_datadir=remove_datadir,
-            )
-            if uuid == current:
-                self.signals.switch.emit(uuid)  # switch to profile
-            self.signals.updateGlobalStatus.emit(f"Profile cleared: {profile['name']}")
+        uuids = uuid if isinstance(uuid, list) else [uuid]
+        for uuid in uuids:
+            if uuid in profiles:
+                profile = profiles[uuid]
+                path = profile['workdir'].replace("%HOME%", str(Path.home()))
+                if not os.path.exists(path) or not os.path.isdir(path):
+                    if not self.batch:
+                        self.signals.alert.emit(f"Directory not exists: {path}")
+                        return
+                    else:
+                        print("Directory not exists, ignoring: ", path)
+                        self.signals.updateGlobalStatus.emit(f"Directory not exists: {path}")
+                        return
+                print("Clearing workdir: ", path)
+                if uuid == current:
+                    self.window.core.db.close()
+                self.window.core.filesystem.clear_workdir(
+                    path,
+                    remove_db=remove_db,
+                    remove_datadir=remove_datadir,
+                )
+                if uuid == current and not self.batch:
+                    self.signals.switch.emit(uuid)  # switch to profile
+                self.signals.updateGlobalStatus.emit(f"Profile cleared: {profile['name']}")
 
     def worker_migrate(self):
         """Migrate working directory"""
@@ -471,9 +493,10 @@ class Workdir:
             force: bool = False,
             current: str = None,
             profile_name: Optional[str] = None,
-            profile_uuid: Optional[str] = None,
+            profile_uuid: Optional[Union[str, list]] = None,
             profile_new_name: Optional[str] = None,
             profile_new_path: Optional[str] = None,
+            batch: bool = False,
     ):
         """
         Run action in thread
@@ -483,9 +506,10 @@ class Workdir:
         :param force: force action (confirm)
         :param current: current working directory (for restore action)
         :param profile_name: profile name (optional, for after update callback)
-        :param profile_uuid: profile UUID (optional, for delete files action)
+        :param profile_uuid: profile UUID (optional, for delete files action) or list of UUIDs
         :param profile_new_name: new profile name (optional, for duplicate action)
         :param profile_new_path: new profile path (optional, for duplicate action)
+        :param batch: if True, run in batch mode (no UI updates)
         """
         worker = WorkdirWorker(
             window=self.window,
@@ -497,6 +521,7 @@ class Workdir:
             profile_uuid=profile_uuid,
             profile_new_name=profile_new_name,
             profile_new_path=profile_new_path,
+            batch=batch,
         )
 
         # connect signals
@@ -569,16 +594,19 @@ class Workdir:
 
     def delete_files(
             self,
-            profile_uuid: str
+            profile_uuid: Union[str, list],
+            batch: bool = False
     ):
         """
         Delete files and directories associated with the profile
 
         :param profile_uuid: profile UUID
+        :param batch: if True, run in batch mode (no UI updates)
         """
         self.run_action(
             action="delete",
             profile_uuid=profile_uuid,
+            batch=batch,
         )
 
     def duplicate(
@@ -603,14 +631,17 @@ class Workdir:
 
     def reset(
             self,
-            profile_uuid: str
+            profile_uuid: Union[str, list],
+            batch: bool = False
     ):
         """
         Reset profile
 
         :param profile_uuid: profile UUID to reset
+        :param batch: if True, run in batch mode (no UI updates)
         """
         self.run_action(
             action="reset",
             profile_uuid=profile_uuid,
+            batch=batch,
         )

pygpt_net/core/assistants/files.py

@@ -6,10 +6,10 @@
 # GitHub:  https://github.com/szczyglis-dev/py-gpt   #
 # MIT License                                        #
 # Created By  : Marcin Szczygliński                  #
-# Updated Date: 2024.12.14 08:00:00                  #
+# Updated Date: 2025.12.27 00:00:00                  #
 # ================================================== #
 
-from typing import Optional, List, Dict
+from typing import Optional, List, Dict, Union
 
 from packaging.version import Version
 
@@ -231,30 +231,32 @@ class Files:
         """
         return self.provider.get_all_by_file_id(file_id)
 
-    def delete(self, file: AssistantFileItem) -> bool:
+    def delete(self, file: Union[AssistantFileItem, list]) -> bool:
         """
         Delete file and remove from vector stores if exists
 
         :param file: file item
         :return: True if file was deleted
         """
-        file_id = file.file_id
-        items = self.get_all_by_file_id(file_id)  # get store_ids
-        for id in items:
-            store_id = items[id].store_id
-            if store_id is None or store_id == "":
-                continue  # skip if no store_id
+        files = file if isinstance(file, list) else [file]
+        for file in files:
+            file_id = file.file_id
+            items = self.get_all_by_file_id(file_id)  # get store_ids
+            for id in items:
+                store_id = items[id].store_id
+                if store_id is None or store_id == "":
+                    continue  # skip if no store_id
+                try:
+                    self.window.core.api.openai.store.delete_store_file(store_id, file_id)  # remove from vector store
+                except Exception as e:
+                    self.window.core.debug.log("Failed to delete file from vector store: " + str(e))
+            self.provider.delete_by_id(file.record_id)  # delete file in DB
             try:
-                self.window.core.api.openai.store.delete_store_file(store_id, file_id)  # remove from vector store
+                self.window.core.api.openai.store.delete_file(file.file_id)  # delete file in API
             except Exception as e:
-                self.window.core.debug.log("Failed to delete file from vector store: " + str(e))
-        self.provider.delete_by_id(file.record_id)  # delete file in DB
-        try:
-            self.window.core.api.openai.store.delete_file(file.file_id)  # delete file in API
-        except Exception as e:
-            self.window.core.debug.log("Failed to delete remote file: " + str(e))
-        if file.record_id in self.items:
-            del self.items[file.record_id]
+                self.window.core.debug.log("Failed to delete remote file: " + str(e))
+            if file.record_id in self.items:
+                del self.items[file.record_id]
         return True
 
     def delete_by_file_id(self, file_id: str) -> bool: