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

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
 
@@ -479,3 +480,73 @@ class Filesystem:
         else:
             files = [os.path.join(path, f) for f in os.listdir(path) if os.path.isfile(os.path.join(path, f))]
         return files
+
+    # ===== Helpers for pack/unpack =====
+
+    def common_parent_dir(self, paths: List[str]) -> str:
+        """
+        Return a sensible common parent directory for the given paths.
+        For a single directory selection returns that directory; for a single file returns its parent.
+        For multiple selections returns a common existing parent, if resolvable, otherwise the parent of the first path.
+        """
+        if not paths:
+            return self.window.core.config.get_user_path()
+        norm = []
+        for p in paths:
+            p = os.path.abspath(p)
+            norm.append(p if os.path.isdir(p) else os.path.dirname(p))
+        if len(norm) == 1:
+            return norm[0]
+        try:
+            cp = os.path.commonpath(norm)
+            if os.path.isdir(cp):
+                return cp
+            return os.path.dirname(cp)
+        except Exception:
+            return norm[0]
+
+    def unique_path(self, directory: str, base_name: str, ext: str) -> str:
+        """
+        Return a unique file path within 'directory' for 'base_name' and 'ext' (ext should include dot or be empty).
+        Uses 'name', 'name (1)', 'name (2)', ... scheme.
+        """
+        os.makedirs(directory, exist_ok=True)
+        candidate = os.path.join(directory, f"{base_name}{ext}")
+        if not os.path.exists(candidate):
+            return candidate
+        i = 1
+        while True:
+            cand = os.path.join(directory, f"{base_name} ({i}){ext}")
+            if not os.path.exists(cand):
+                return cand
+            i += 1
+
+    def unique_dir(self, directory: str, base_name: str) -> str:
+        """
+        Return a unique directory path 'directory/base_name', adding ' (n)' suffix when needed.
+        """
+        os.makedirs(directory, exist_ok=True)
+        candidate = os.path.join(directory, base_name)
+        if not os.path.exists(candidate):
+            return candidate
+        i = 1
+        while True:
+            cand = os.path.join(directory, f"{base_name} ({i})")
+            if not os.path.exists(cand):
+                return cand
+            i += 1
+
+    def strip_archive_name(self, filename: str) -> str:
+        """
+        Strip known archive extensions (.zip, .tar, .tar.gz, .tar.bz2, .tar.xz, .tgz, .tbz2, .txz) from a filename.
+        Returns filename without extension(s).
+        """
+        combos = ['.tar.gz', '.tar.bz2', '.tar.xz', '.tgz', '.tbz2', '.txz']
+        lower = filename.lower()
+        for suf in combos:
+            if lower.endswith(suf):
+                return filename[:-len(suf)]
+        root, ext = os.path.splitext(filename)
+        if ext.lower() in ('.zip', '.tar'):
+            return root
+        return root

pygpt_net/core/filesystem/packer.py

@@ -84,4 +84,164 @@ class Packer:
         :param path: path to directory
         """
         if os.path.exists(path) and os.path.isdir(path):
-            shutil.rmtree(path)
+            shutil.rmtree(path)
+
+    # ===== New high-level pack/unpack API (non-breaking) =====
+
+    def can_unpack(self, path: str) -> bool:
+        """
+        Check using stdlib detectors whether given file is a supported archive.
+        """
+        if not (path and os.path.isfile(path)):
+            return False
+        try:
+            import zipfile, tarfile
+            return zipfile.is_zipfile(path) or tarfile.is_tarfile(path)
+        except Exception:
+            return False
+
+    def _detect_kind(self, path: str) -> str:
+        """
+        Detect archive kind: 'zip' or 'tar'. Returns '' if unknown.
+        """
+        try:
+            import zipfile, tarfile
+            if zipfile.is_zipfile(path):
+                return 'zip'
+            if tarfile.is_tarfile(path):
+                return 'tar'
+        except Exception:
+            pass
+        return ''
+
+    def pack_paths(self, paths: list, fmt: str, dest_dir: str = None, base_name: str = None) -> str:
+        """
+        Pack given paths into a single archive.
+
+        :param paths: list of files/dirs to include
+        :param fmt: 'zip' or 'tar.gz'
+        :param dest_dir: output directory (default: common parent of paths)
+        :param base_name: output archive base name without extension (optional)
+        :return: created archive path or empty string on error
+        """
+        if not paths:
+            return ""
+        fs = self.window.core.filesystem
+        paths = [os.path.abspath(p) for p in paths if p]
+        dest_dir = dest_dir or fs.common_parent_dir(paths)
+
+        if base_name is None:
+            if len(paths) == 1:
+                name = os.path.basename(paths[0].rstrip(os.sep))
+                if os.path.isfile(paths[0]):
+                    root, _ = os.path.splitext(name)
+                    base_name = root or name
+                else:
+                    base_name = name
+            else:
+                base_name = "archive"
+
+        fmt = (fmt or "").lower()
+        if fmt == 'zip':
+            ext = ".zip"
+            out_path = fs.unique_path(dest_dir, base_name, ext)
+            try:
+                self._pack_zip(paths, out_path)
+                return out_path
+            except Exception as e:
+                try:
+                    self.window.core.debug.log(e)
+                except Exception:
+                    pass
+                return ""
+        elif fmt in ('tar.gz', 'tgz'):
+            ext = ".tar.gz"
+            out_path = fs.unique_path(dest_dir, base_name, ext)
+            try:
+                self._pack_tar_gz(paths, out_path)
+                return out_path
+            except Exception as e:
+                try:
+                    self.window.core.debug.log(e)
+                except Exception:
+                    pass
+                return ""
+        else:
+            return ""
+
+    def _pack_zip(self, paths: list, out_path: str):
+        """
+        Create ZIP archive with selected paths, preserving top-level names.
+        """
+        import zipfile
+        with zipfile.ZipFile(out_path, 'w', compression=zipfile.ZIP_DEFLATED) as zf:
+            for src in paths:
+                top = os.path.basename(src.rstrip(os.sep))
+                if os.path.isdir(src):
+                    for root, dirs, files in os.walk(src):
+                        rel = os.path.relpath(root, src)
+                        arc_root = top if rel == "." else os.path.join(top, rel)
+                        # Add empty directories explicitly
+                        if not files and not dirs:
+                            zinfo = zipfile.ZipInfo(arc_root + "/")
+                            zf.writestr(zinfo, "")
+                        for f in files:
+                            absf = os.path.join(root, f)
+                            arcf = os.path.join(arc_root, f)
+                            zf.write(absf, arcf)
+                else:
+                    zf.write(src, top)
+
+    def _pack_tar_gz(self, paths: list, out_path: str):
+        """
+        Create TAR.GZ archive with selected paths, preserving top-level names.
+        """
+        import tarfile
+        with tarfile.open(out_path, 'w:gz') as tf:
+            for src in paths:
+                top = os.path.basename(src.rstrip(os.sep))
+                tf.add(src, arcname=top, recursive=True)
+
+    def unpack_to_dir(self, path: str, dest_dir: str) -> str:
+        """
+        Unpack archive at 'path' into 'dest_dir'.
+
+        :param path: archive file path
+        :param dest_dir: destination directory to extract into
+        :return: dest_dir on success, empty string otherwise
+        """
+        if not self.can_unpack(path):
+            return ""
+        try:
+            import zipfile, tarfile
+            os.makedirs(dest_dir, exist_ok=True)
+            kind = self._detect_kind(path)
+            if kind == 'zip':
+                with zipfile.ZipFile(path, 'r') as zf:
+                    zf.extractall(dest_dir)
+            elif kind == 'tar':
+                with tarfile.open(path, 'r:*') as tf:
+                    tf.extractall(dest_dir)
+            else:
+                return ""
+            return dest_dir
+        except Exception as e:
+            try:
+                self.window.core.debug.log(e)
+            except Exception:
+                pass
+            return ""
+
+    def unpack_to_sibling_dir(self, path: str) -> str:
+        """
+        Unpack archive into directory placed next to the archive, named after archive base name.
+
+        :param path: archive file path
+        :return: created directory path or empty string
+        """
+        if not (path and os.path.isfile(path)):
+            return ""
+        parent = os.path.dirname(path)
+        base = self.window.core.filesystem.strip_archive_name(os.path.basename(path))
+        out_dir = self.window.core.filesystem.unique_dir(parent, base)
+        return self.unpack_to_dir(path, out_dir)

pygpt_net/core/idx/idx.py

@@ -6,7 +6,7 @@
 # GitHub:  https://github.com/szczyglis-dev/py-gpt   #
 # MIT License                                        #
 # Created By  : Marcin Szczygliński                  #
-# Updated Date: 2025.08.21 07:00:00                  #
+# Updated Date: 2025.12.27 17:00:00                  #
 # ================================================== #
 
 import datetime
@@ -505,16 +505,17 @@ class Idx:
         self.llm.get_service_context(stream=False)  # init environment only (ENV API keys, etc.)
         store_id = self.get_current_store()
         if store_id in self.items and idx in self.items[store_id]:
-            if file in self.items[store_id][idx].items:
-                # remove from storage
-                doc_id = self.items[store_id][idx].items[file]["id"]
-                self.storage.remove_document(
-                    id=idx,
-                    doc_id=doc_id,
-                )
-                # remove from index data and db
-                del self.items[store_id][idx].items[file]
-                self.files.remove(store_id, idx, doc_id)
+            for basename in list(self.items[store_id][idx].items.keys()):
+                item = self.items[store_id][idx].items[basename]
+                if file == item["path"]:
+                    doc_id = item ["id"]
+                    self.storage.remove_document(
+                        id=idx,
+                        doc_id=doc_id,
+                    )
+                    # remove from index data and db
+                    del self.items[store_id][idx].items[basename]
+                    self.files.remove(store_id, idx, doc_id)
 
     def load(self):
         """Load indexes and indexed items"""

pygpt_net/core/idx/worker.py

@@ -6,7 +6,7 @@
 # GitHub:  https://github.com/szczyglis-dev/py-gpt   #
 # MIT License                                        #
 # Created By  : Marcin Szczygliński                  #
-# Updated Date: 2025.08.21 07:00:00                  #
+# Updated Date: 2025.12.27 19:00:00                  #
 # ================================================== #
 
 from PySide6.QtCore import QObject, Signal, QRunnable, Slot
@@ -29,6 +29,7 @@ class IndexWorker(QRunnable):
         self.replace = None
         self.recursive = None
         self.from_ts = 0
+        self.from_ts_batch = {}
         self.idx = None
         self.type = None
         self.silent = False
@@ -70,6 +71,17 @@ class IndexWorker(QRunnable):
                     self.content,
                     self.from_ts,
                 )
+            elif self.type == "db_meta_batch":
+                result = 0
+                errors = []
+                for meta_id in self.content:
+                    r, e = self.window.core.idx.index_db_by_meta_id(
+                        self.idx,
+                        meta_id,
+                        self.from_ts_batch[meta_id],
+                    )
+                    result += r
+                    errors.extend(e)
             elif self.type == "db_current":
                 result, errors = self.window.core.idx.index_db_from_updated_ts(
                     self.idx,

pygpt_net/core/image/image.py

@@ -152,7 +152,7 @@ class Image(QObject):
         """
         return {
             "type": "combo",
-            "slider": True,
+            #"search": False,
             "label": "img_resolution",
             "value": "1024x1024",
             "keys": self.get_available_resolutions(),
@@ -166,7 +166,7 @@ class Image(QObject):
         """
         return {
             "type": "combo",
-            "slider": True,
+            #"search": False,
             "label": "img_mode",
             "value": "image",
             "keys": self.get_available_modes(),

pygpt_net/core/models/models.py

@@ -6,11 +6,11 @@
 # GitHub:  https://github.com/szczyglis-dev/py-gpt   #
 # MIT License                                        #
 # Created By  : Marcin Szczygliński                  #
-# Updated Date: 2025.09.17 19:00:00                  #
+# Updated Date: 2025.12.26 20:00:00                  #
 # ================================================== #
 
 import copy
-from typing import Optional, List, Dict
+from typing import Optional, List, Dict, Tuple
 
 from httpx_socks import SyncProxyTransport
 from openai import DefaultHttpxClient
@@ -272,7 +272,7 @@ class Models:
         """
         return self.multimodal
 
-    def create_empty(self, append: bool = True) -> ModelItem:
+    def create_empty(self, append: bool = True) -> Tuple[ModelItem, str]:
         """
         Create new empty model
 
@@ -288,7 +288,7 @@ class Models:
         model.output = ["text"]
         if append:
             self.items[id] = model
-        return model
+        return model, id
 
     def get_all(self) -> Dict[str, ModelItem]:
         """

pygpt_net/core/profile/profile.py

@@ -6,7 +6,7 @@
 # GitHub:  https://github.com/szczyglis-dev/py-gpt   #
 # MIT License                                        #
 # Created By  : Marcin Szczygliński                  #
-# Updated Date: 2024.12.14 22:00:00                  #
+# Updated Date: 2025.12.28 04:00:00                  #
 # ================================================== #
 
 import json
@@ -116,9 +116,19 @@ class Profile:
             'profiles': self.profiles
         }
         json_data = json.dumps(config, indent=4)
+        f_lock = os.path.join(self.base_workdir, self.PROFILE_FILE + '.lock')
         f = os.path.join(self.base_workdir, self.PROFILE_FILE)
-        with open(f, 'w', encoding='utf-8') as f:
-            f.write(json_data)
+        # check lock first
+        if os.path.exists(f_lock):
+            print("WARNING: Profile save aborted, lock exists. Please remove lock file:", f_lock)
+            return  # abort if lock exists
+        with open(f_lock, 'w', encoding='utf-8') as file:
+            file.write('lock')
+        with open(f, 'w', encoding='utf-8') as file:
+            file.write(json_data)
+        # remove lock
+        if os.path.exists(f_lock):
+            os.remove(f_lock)
 
     def add(
             self,

pygpt_net/core/video/video.py

@@ -276,7 +276,7 @@ class Video(QObject):
         """
         return {
             "type": "combo",
-            "slider": True,
+           # "search": False,
             "label": "video.aspect_ratio",
             "value": "16:9",
             "keys": self.get_available_aspect_ratio(),
@@ -290,7 +290,7 @@ class Video(QObject):
         """
         return {
             "type": "combo",
-            "slider": True,
+           # "search": False,
             "label": "video.resolution",
             "value": "720p",
             "keys": self.get_available_resolutions(),
@@ -304,7 +304,6 @@ class Video(QObject):
         """
         return {
             "type": "int",
-            "slider": False,
             "label": "video.duration",
             "value": 8,
             "placeholder": "s",

pygpt_net/data/config/config.json

@@ -1,8 +1,8 @@
 {
   "__meta__": {
-    "version": "2.6.67",
-    "app.version": "2.6.67",
-    "updated_at": "2025-12-26T00:00:00"
+    "version": "2.7.1",
+    "app.version": "2.7.1",
+    "updated_at": "2025-12-28T00:00:00"
   },
   "access.audio.event.speech": false,
   "access.audio.event.speech.disabled": [],

pygpt_net/data/config/models.json

@@ -1,8 +1,8 @@
 {
     "__meta__": {
-        "version": "2.6.67",
-        "app.version": "2.6.67",
-        "updated_at": "2025-12-26T00:00:00"
+        "version": "2.7.1",
+        "app.version": "2.7.1",
+        "updated_at": "2025-12-28T00:00:00"
     },
     "items": {
         "SpeakLeash/bielik-11b-v2.3-instruct:Q4_K_M": {

pygpt_net/data/css/style.dark.css

@@ -174,4 +174,49 @@ NodeEditor {{
 /* Status Bar */
 #StatusBarTimer {{
   color: #999 !important;
+}}
+
+/* ComboBox */
+QComboBox QAbstractItemView {{
+  border: 1px solid rgba(0,0,0,0.18);
+}}
+
+QListView#ComboPopupList {{
+  border-radius: 10px;
+  background: #1f2123;
+  border: 2px solid #4f5b62;
+}}
+
+QComboBox QAbstractItemView::item,
+QListView#ComboPopupList::item {{
+  min-height: 20px;
+  padding: 8px 33px;
+  margin: 0;
+  color: #fff;
+}}
+
+QComboBox QAbstractItemView::item:selected,
+QListView#ComboPopupList::item:selected {{
+   background: #fff;
+   color: #000;
+   selection-color: #000;
+   font-weight: bold;
+ }}
+
+QListView#ComboPopupList::item:disabled {{
+  color: #c9c9c9;
+  background: #363d42;
+  padding: 15px;
+}}
+
+QComboBox QAbstractItemView::item:hover,
+QListView#ComboPopupList::item:hover {{ }}
+
+QWidget#ComboPopupWindow {{
+  background: transparent;
+  border: 0;
+}}
+QListView#ComboPopupList > QWidget#ComboPopupViewport {{
+  background: transparent;
+  border-radius: 0px;
 }}