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

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:

pygpt_net/core/filesystem/actions.py

@@ -6,11 +6,11 @@
 # GitHub:  https://github.com/szczyglis-dev/py-gpt   #
 # MIT License                                        #
 # Created By  : Marcin Szczygliński                  #
-# Updated Date: 2025.08.24 23:00:00                  #
+# Updated Date: 2025.12.27 17:00:00                  #
 # ================================================== #
 
 import os
-from typing import List
+from typing import List, Union
 
 from PySide6.QtGui import QAction, QIcon
 from PySide6.QtWidgets import QWidget
@@ -27,16 +27,22 @@ class Actions:
         """
         self.window = window
 
-    def has_preview(self, path: str) -> bool:
+    def has_preview(self, path: Union[str, list]) -> bool:
         """
         Check if file has preview action
 
-        :param path: path to file
+        :param path: path to file or list of paths
         :return: True if file has preview
         """
-        if os.path.isdir(path):
+        if isinstance(path, list):
+            for p in path:
+                if not os.path.isdir(p):
+                    return True  # allow preview for any file in the list
             return False
-        return True
+        else:
+            if os.path.isdir(path):
+                return False
+            return True
 
     def has_use(self, path: str) -> bool:
         """
@@ -48,14 +54,93 @@ class Actions:
         return (self.window.core.filesystem.types.is_image(path)
                 or self.window.core.filesystem.types.is_video(path))
 
-    def get_preview(self, parent: QWidget, path: str) -> List[QAction]:
+    def get_preview_batch(self, parent: QWidget, path: list) -> List[QAction]:
+        """
+        Get preview actions for multiple files
+
+        :param parent: explorer widget
+        :param path: list of paths
+        :return: list of context menu actions
+        """
+        actions = []
+        paths_video = []
+        paths_image = []
+        paths_edit = []
+        for p in path:
+            if os.path.isdir(p):
+                continue
+            actions = []
+            if (self.window.core.filesystem.types.is_video(p)
+                    or self.window.core.filesystem.types.is_audio(p)):
+                paths_video.append(p)
+            elif self.window.core.filesystem.types.is_image(p):
+                paths_image.append(p)
+            else:
+                extra_excluded = ["pdf", "docx", "doc", "xlsx", "xls", "pptx", "ppt"]
+                ext = os.path.splitext(p)[1][1:].lower()
+                if ext not in self.window.core.filesystem.types.get_excluded_extensions() + extra_excluded:
+                    paths_edit.append(p)
+
+        # video/audio - single action for first file
+        if paths_video:
+            p = paths_video[0]  # single action for first video
+            action = QAction(
+                QIcon(":/icons/video.svg"),
+                trans('action.video.play'),
+                parent,
+            )
+            action.triggered.connect(
+                lambda: self.window.tools.get("player").play(p),
+            )
+            actions.append(action)
+            action = QAction(
+                QIcon(":/icons/hearing.svg"),
+                trans('action.video.transcribe'),
+                parent,
+            )
+            action.triggered.connect(
+                lambda: self.window.tools.get("transcriber").from_file(p),
+            )
+            actions.append(action)
+
+        # image - batch preview
+        if paths_image:
+            action = QAction(
+                QIcon(":/icons/image.svg"),
+                trans('action.preview'),
+                parent,
+            )
+            action.triggered.connect(
+                lambda: self.window.tools.get("viewer").open_preview_batch(paths_image),
+            )
+            actions.append(action)
+
+        # edit - batch edit
+        if paths_edit:
+            action = QAction(
+                QIcon(":/icons/edit.svg"),
+                trans('action.edit'),
+                parent,
+            )
+            action.triggered.connect(
+                lambda: self.window.tools.get("editor").open_batch(paths_edit),
+            )
+            actions.append(action)
+
+        return actions
+
+
+    def get_preview(self, parent: QWidget, path: Union[str, list]) -> List[QAction]:
         """
         Get preview actions for context menu
 
         :param parent: explorer widget
-        :param path: path to file
+        :param path: path to file or list of paths
         :return: list of context menu actions
         """
+        if isinstance(path, list):
+            return self.get_preview_batch(parent, path)
+
         actions = []
         if (self.window.core.filesystem.types.is_video(path)
                 or self.window.core.filesystem.types.is_audio(path)):
@@ -102,14 +187,30 @@ class Actions:
                 actions.append(action)
         return actions
 
-    def get_use(self, parent: QWidget, path: str) -> List[QAction]:
+    def get_use_batch(self, parent: QWidget, path: list) -> List[QAction]:
+        """
+        Get use actions for multiple files
+
+        :param parent: explorer widget
+        :param path: list of paths
+        :return: list of context menu actions
+        """
+        actions = []
+        for p in path:
+            actions.extend(self.get_use(parent, p))
+        return actions
+
+    def get_use(self, parent: QWidget, path: Union[str, list]) -> List[QAction]:
         """
         Get use actions for context menu
 
         :param parent: explorer widget
-        :param path: path to file
+        :param path: path to file or list of paths
         :return: list of context menu actions
         """
+        if isinstance(path, list):
+            return self.get_use_batch(parent, path)
+
         actions = []
         if self.window.core.filesystem.types.is_image(path):
             action = QAction(

pygpt_net/core/filesystem/filesystem.py

@@ -429,7 +429,8 @@ class Filesystem:
                     os.remove(item_path)
             else:
                 if item not in excluded_dirs:
-                    shutil.rmtree(item_path)
+                    if os.path.exists(item_path) and os.path.isdir(item_path):
+                        shutil.rmtree(item_path)
 
         return True