pygpt-net 2.7.7__py3-none-any.whl → 2.7.8__py3-none-any.whl

pygpt_net/provider/api/google/chat.py

@@ -362,6 +362,12 @@ class Chat:
         except Exception:
             pass
 
+        # Download Files API file_data parts if present
+        try:
+            self._maybe_download_response_files(response, ctx)
+        except Exception:
+            pass
+
     def extract_text(self, response) -> str:
         """
         Extract output text.
@@ -792,7 +798,7 @@ class Chat:
                 return bytes(data)
             if isinstance(data, str):
                 import base64
-                return base64.b64decode(data)
+                return base64.b64encode(bytes()) if data == "" else base64.b64decode(data)
         except Exception:
             return None
         return None
@@ -1000,4 +1006,55 @@ class Chat:
                     out.append({"type": typ, "uri": uri})
                 continue
 
-        return out
+        return out
+
+    def _maybe_download_response_files(self, response, ctx: CtxItem) -> None:
+        """
+        Inspect non-stream response parts for Files API references and download them.
+        """
+        try:
+            cands = getattr(response, "candidates", None) or []
+            if not cands:
+                return
+            first = cands[0]
+            content = getattr(first, "content", None)
+            parts = getattr(content, "parts", None) or []
+        except Exception:
+            parts = []
+
+        if not parts:
+            return
+
+        downloaded: List[str] = []
+        for p in parts:
+            fdata = getattr(p, "file_data", None)
+            if not fdata:
+                continue
+            try:
+                uri = getattr(fdata, "file_uri", None) or getattr(fdata, "uri", None)
+                prefer = getattr(fdata, "file_name", None) or getattr(fdata, "display_name", None)
+                if not uri or not isinstance(uri, str):
+                    continue
+                # Only Gemini Files API refs are supported for direct download
+                save_path = self.window.core.api.google.store.download_to_dir(uri, prefer_name=prefer)
+                if save_path:
+                    downloaded.append(save_path)
+            except Exception:
+                continue
+
+        if downloaded:
+            downloaded = self.window.core.filesystem.make_local_list(downloaded)
+            if not isinstance(ctx.files, list):
+                ctx.files = []
+            for path in downloaded:
+                if path not in ctx.files:
+                    ctx.files.append(path)
+            images = []
+            for path in downloaded:
+                ext = os.path.splitext(path)[1].lower().lstrip(".")
+                if ext in ["png", "jpg", "jpeg", "gif", "bmp", "tiff", "webp"]:
+                    images.append(path)
+            if images:
+                if not isinstance(ctx.images, list):
+                    ctx.images = []
+                ctx.images += images

pygpt_net/provider/api/google/store.py

@@ -6,12 +6,13 @@
 # GitHub:  https://github.com/szczyglis-dev/py-gpt   #
 # MIT License                                        #
 # Created By  : Marcin Szczygliński                  #
-# Updated Date: 2026.01.02 20:00:00                  #
+# Updated Date: 2026.01.06 06:00:00                  #
 # ================================================== #
 
 import os
 import time
-from typing import Optional, List, Dict, Any
+import mimetypes
+from typing import Optional, List, Dict, Any, Union
 
 from pygpt_net.item.store import RemoteStoreItem
 
@@ -63,6 +64,53 @@ class Store:
             v = hi
         return v
 
+    def _download_dir(self) -> str:
+        """
+        Resolve target download directory (uses download.dir if set).
+        """
+        if self.window.core.config.has("download.dir") and self.window.core.config.get("download.dir") != "":
+            dir_path = os.path.join(
+                self.window.core.config.get_user_dir('data'),
+                self.window.core.config.get("download.dir"),
+            )
+        else:
+            dir_path = self.window.core.config.get_user_dir('data')
+        os.makedirs(dir_path, exist_ok=True)
+        return dir_path
+
+    def _ensure_unique_path(self, dir_path: str, filename: str) -> str:
+        """
+        Ensure unique filename in dir, add timestamp prefix if exists.
+        """
+        path = os.path.join(dir_path, filename)
+        if os.path.exists(path):
+            prefix = time.strftime("%Y%m%d_%H%M%S_")
+            path = os.path.join(dir_path, f"{prefix}{filename}")
+        return path
+
+    def _guess_filename(self, file_meta: Any, fallback: str = "downloaded.bin") -> str:
+        """
+        Best-effort filename from File metadata or URI.
+        """
+        name = None
+        for attr in ("display_name", "filename", "name", "file_name"):
+            try:
+                val = getattr(file_meta, attr, None)
+                if not name and isinstance(val, str) and val:
+                    name = os.path.basename(val)
+            except Exception:
+                pass
+            if not name and isinstance(file_meta, dict):
+                val = file_meta.get(attr)
+                if isinstance(val, str) and val:
+                    name = os.path.basename(val)
+
+        if not name:
+            # allow URI-like strings
+            if isinstance(file_meta, str):
+                name = os.path.basename(file_meta.split("?")[0].split("#")[0])
+        return name or fallback
+
     # -----------------------------
     # Files service (global)
     # -----------------------------
@@ -105,6 +153,79 @@ class Store:
         if res is not None:
             return file_name
 
+    def download(self, file: Union[str, Any], path: str) -> bool:
+        """
+        Download a Files API item into the given path.
+
+        :param file: file name ('files/...'), file object, or file URI
+        :param path: target local path
+        :return: True on success
+        """
+        client = self.get_client()
+        data = None
+        try:
+            data = client.files.download(file=file)
+        except Exception:
+            pass
+        if not data:
+            return False
+        # google-genai returns bytes
+        try:
+            with open(path, "wb") as f:
+                f.write(data if isinstance(data, (bytes, bytearray)) else bytes(data))
+            return True
+        except Exception:
+            return False
+
+    def download_to_dir(self, file: Union[str, Any], prefer_name: Optional[str] = None) -> Optional[str]:
+        """
+        Download a Files API item into configured download directory.
+
+        :param file: file name ('files/...'), file object, or file URI
+        :param prefer_name: optional preferred filename
+        :return: saved path or None
+        """
+        dir_path = self._download_dir()
+        filename = None
+
+        # Try to resolve filename from metadata
+        file_meta = None
+        try:
+            name = None
+            if isinstance(file, str) and file.startswith("files/"):
+                name = file
+            elif hasattr(file, "name"):
+                name = getattr(file, "name", None)
+
+            if name:
+                file_meta = self.get_file(name)
+        except Exception:
+            file_meta = None
+
+        if prefer_name and isinstance(prefer_name, str):
+            filename = os.path.basename(prefer_name)
+
+        if not filename:
+            filename = self._guess_filename(file_meta if file_meta is not None else file)
+
+        # Infer extension from mime, if missing
+        if not os.path.splitext(filename)[1] and file_meta is not None:
+            try:
+                mime = getattr(file_meta, "mime_type", None)
+                if isinstance(file_meta, dict):
+                    mime = file_meta.get("mime_type", mime)
+                if mime:
+                    ext = mimetypes.guess_extension(mime) or ""
+                    if ext:
+                        filename = filename + ext
+            except Exception:
+                pass
+
+        path = self._ensure_unique_path(dir_path, filename)
+        if self.download(file, path):
+            return path
+        return None
+
     def get_files_ids_all(
             self,
             items: list,
@@ -377,7 +498,7 @@ class Store:
         for doc_name in files:
             self.log("Removing document from store [{}]:{} ".format(store_id, doc_name))
             self.delete_store_file(store_id, doc_name)
-            num += 1
+            num += 1        
         return num
 
     def remove_all(self, callback: Optional[callable] = None) -> int:

pygpt_net/provider/api/google/stream.py

@@ -93,6 +93,43 @@ def process_google_chunk(ctx, core, state, chunk) -> Optional[str]:
             except Exception:
                 pass
 
+    def _try_download_uri(uri: Optional[str], prefer_name: Optional[str] = None) -> Optional[str]:
+        """
+        Attempt to download a Files API URI via store; return local path or None.
+        """
+        if not isinstance(uri, str) or not uri:
+            return None
+        try:
+            path = core.api.google.store.download_to_dir(uri, prefer_name=prefer_name)
+            return path
+        except Exception:
+            return None
+
+    def _append_downloaded(paths):
+        if not paths:
+            return
+        try:
+            loc = core.filesystem.make_local_list(paths)
+        except Exception:
+            loc = paths
+        if not isinstance(ctx.files, list):
+            ctx.files = []
+        for p in loc:
+            if p not in ctx.files:
+                ctx.files.append(p)
+        # images
+        imgs = []
+        for p in loc:
+            ext = p.lower().rsplit(".", 1)[-1] if "." in p else ""
+            if ext in ["png", "jpg", "jpeg", "gif", "bmp", "tiff", "webp"]:
+                imgs.append(p)
+        if imgs:
+            if not isinstance(ctx.images, list):
+                ctx.images = []
+            for p in imgs:
+                if p not in ctx.images:
+                    ctx.images.append(p)
+
     # Collect function calls from Responses API style stream
     if fc_list:
         for fc in fc_list:
@@ -114,6 +151,23 @@ def process_google_chunk(ctx, core, state, chunk) -> Optional[str]:
                 content = getattr(cand, "content", None)
                 parts = getattr(content, "parts", None) or []
                 for p in parts:
+                    # Download Files API file_data parts if present
+                    try:
+                        fdata = getattr(p, "file_data", None)
+                        if fdata:
+                            uri = getattr(fdata, "file_uri", None) or getattr(fdata, "uri", None)
+                            name = getattr(fdata, "file_name", None) or getattr(fdata, "display_name", None)
+                            if uri and isinstance(uri, str):
+                                if not hasattr(state, "google_downloaded_uris"):
+                                    state.google_downloaded_uris = set()
+                                if uri not in state.google_downloaded_uris:
+                                    save = _try_download_uri(uri, name)
+                                    if save:
+                                        _append_downloaded([save])
+                                        state.google_downloaded_uris.add(uri)
+                    except Exception:
+                        pass
+
                     fn = getattr(p, "function_call", None)
                     if not fn:
                         continue
@@ -132,7 +186,6 @@ def process_google_chunk(ctx, core, state, chunk) -> Optional[str]:
             pass
 
     # Interactions API / Deep Research: collect streaming deltas and metadata
-    # Handles event_type, event_id, interaction.start/complete/status_update, and content.delta variants
     try:
         event_type = _get(chunk, "event_type", None)
         if event_type:
@@ -215,10 +268,8 @@ def process_google_chunk(ctx, core, state, chunk) -> Optional[str]:
                     content_obj = _get(delta, "content", None)
                     thought_txt = None
                     if content_obj is not None:
-                        # TextContent path
                         thought_txt = _get(content_obj, "text", None)
                     if thought_txt is None:
-                        # Some SDKs expose 'thought' or 'content.text' differently
                         thought_txt = _get(delta, "thought", None)
                     if thought_txt:
                         _ensure_list_attr(state, "google_thought_summaries")
@@ -252,7 +303,6 @@ def process_google_chunk(ctx, core, state, chunk) -> Optional[str]:
 
                 # Function result delta (optional store)
                 elif delta_type == "function_result":
-                    # Can be used to log tool results; not altering UI text
                     _ensure_list_attr(state, "google_function_results")
                     try:
                         state.google_function_results.append(_to_plain_dict(delta))
@@ -269,7 +319,6 @@ def process_google_chunk(ctx, core, state, chunk) -> Optional[str]:
                     else:
                         response_parts.append(str(code_txt))
                 elif delta_type == "code_execution_result":
-                    # Close code block; keep output logging internal if needed
                     if state.is_code:
                         response_parts.append("\n\n```\n-----------\n")
                         state.is_code = False
@@ -282,7 +331,7 @@ def process_google_chunk(ctx, core, state, chunk) -> Optional[str]:
                 # Images in stream
                 elif delta_type == "image":
                     # ImageDelta may contain base64 data or uri
-                    mime = (_get(delta, "mime_type", "") or "").lower()
+                    mime = _get(delta, "mime_type", None)
                     data_b64 = _get(delta, "data", None)
                     uri = _get(delta, "uri", None)
                     if data_b64:
@@ -299,12 +348,17 @@ def process_google_chunk(ctx, core, state, chunk) -> Optional[str]:
                         except Exception:
                             pass
                     elif uri:
-                        try:
-                            if not hasattr(ctx, "urls") or ctx.urls is None:
-                                ctx.urls = []
-                            ctx.urls.append(uri)
-                        except Exception:
-                            pass
+                        # Try to download Files API content when URI is a file ref
+                        save = _try_download_uri(uri)
+                        if save:
+                            _append_downloaded([save])
+                        else:
+                            try:
+                                if not hasattr(ctx, "urls") or ctx.urls is None:
+                                    ctx.urls = []
+                                ctx.urls.append(uri)
+                            except Exception:
+                                pass
 
                 # URL context call/result (Deep Research tool)
                 elif delta_type == "url_context_call":
@@ -368,7 +422,6 @@ def process_google_chunk(ctx, core, state, chunk) -> Optional[str]:
                     except Exception:
                         pass
 
-                # Thought signature delta (optional, store)
                 elif delta_type == "thought_signature":
                     _ensure_list_attr(state, "google_thought_signatures")
                     try:
@@ -380,12 +433,16 @@ def process_google_chunk(ctx, core, state, chunk) -> Optional[str]:
                 elif delta_type in ("audio", "video", "document"):
                     uri = _get(delta, "uri", None)
                     if uri:
-                        try:
-                            if not hasattr(ctx, "urls") or ctx.urls is None:
-                                ctx.urls = []
-                            ctx.urls.append(uri)
-                        except Exception:
-                            pass
+                        save = _try_download_uri(uri)
+                        if save:
+                            _append_downloaded([save])
+                        else:
+                            try:
+                                if not hasattr(ctx, "urls") or ctx.urls is None:
+                                    ctx.urls = []
+                                ctx.urls.append(uri)
+                            except Exception:
+                                pass
 
     except Exception:
         pass
@@ -459,11 +516,21 @@ def process_google_chunk(ctx, core, state, chunk) -> Optional[str]:
                 fdata = getattr(p, "file_data", None)
                 if fdata:
                     uri = getattr(fdata, "file_uri", None) or getattr(fdata, "uri", None)
-                    mime = (getattr(fdata, "mime_type", "") or "").lower()
-                    if uri and mime.startswith("image/") and (uri.startswith("http://") or uri.startswith("https://")):
-                        if ctx.urls is None:
-                            ctx.urls = []
-                        ctx.urls.append(uri)
+                    prefer = getattr(fdata, "file_name", None) or getattr(fdata, "display_name", None)
+                    if uri:
+                        if not hasattr(state, "google_downloaded_uris"):
+                            state.google_downloaded_uris = set()
+                        if uri not in state.google_downloaded_uris:
+                            save = _try_download_uri(uri, prefer)
+                            if save:
+                                _append_downloaded([save])
+                                state.google_downloaded_uris.add(uri)
+                        # keep original behavior for image http links
+                        mime = (getattr(fdata, "mime_type", "") or "").lower()
+                        if uri.startswith(("http://", "https://")) and mime.startswith("image/"):
+                            if ctx.urls is None:
+                                ctx.urls = []
+                            ctx.urls.append(uri)
 
         collect_google_citations(ctx, state, chunk)
 

pygpt_net/provider/api/google/worker/importer.py

@@ -6,7 +6,7 @@
 # GitHub:  https://github.com/szczyglis-dev/py-gpt   #
 # MIT License                                        #
 # Created By  : Marcin Szczygliński                  #
-# Updated Date: 2026.01.02 20:00:00                  #
+# Updated Date: 2026.01.06 06:00:00                  #
 # ================================================== #
 
 import os
@@ -33,18 +33,19 @@ class Importer(QObject):
         :param mode: mode
         :param err: error message
         """
+        batch = self.window.controller.remote_store.batch
         if mode == "import_files":
-            self.window.controller.remote_store.google.batch.handle_imported_files_failed(err)
+            batch.handle_imported_files_failed(err)
         elif mode == "truncate_files":
-            self.window.controller.remote_store.google.batch.handle_truncated_files_failed(err)
+            batch.handle_truncated_files_failed(err)
         elif mode == "upload_files":
-            self.window.controller.remote_store.google.batch.handle_uploaded_files_failed(err)
+            batch.handle_uploaded_files_failed(err)
         elif mode in "vector_stores":
-            self.window.controller.remote_store.google.batch.handle_imported_stores_failed(err)
+            batch.handle_imported_stores_failed(err)
         elif mode in "truncate_vector_stores":
-            self.window.controller.remote_store.google.batch.handle_truncated_stores_failed(err)
+            batch.handle_truncated_stores_failed(err)
         elif mode in "refresh_vector_stores":
-            self.window.controller.remote_store.google.batch.handle_refreshed_stores_failed(err)
+            batch.handle_refreshed_stores_failed(err)
 
     @Slot(str, str, int)
     def handle_finished(self, mode: str, store_id: str = None, num: int = 0):
@@ -55,18 +56,19 @@ class Importer(QObject):
         :param store_id: store ID
         :param num: number of affected items
         """
+        batch = self.window.controller.remote_store.batch
         if mode == "import_files":
-            self.window.controller.remote_store.google.batch.handle_imported_files(num)
+            batch.handle_imported_files(num)
         elif mode == "truncate_files":
-            self.window.controller.remote_store.google.batch.handle_truncated_files(store_id, num)
+            batch.handle_truncated_files(store_id, num)
         elif mode == "upload_files":
-            self.window.controller.remote_store.google.batch.handle_uploaded_files(num)
+            batch.handle_uploaded_files(num)
         elif mode == "vector_stores":
-            self.window.controller.remote_store.google.batch.handle_imported_stores(num)
+            batch.handle_imported_stores(num)
         elif mode == "truncate_vector_stores":
-            self.window.controller.remote_store.google.batch.handle_truncated_stores(num)
+            batch.handle_truncated_stores(num)
         elif mode == "refresh_vector_stores":
-            self.window.controller.remote_store.google.batch.handle_refreshed_stores(num)
+            batch.handle_refreshed_stores(num)
 
     @Slot(str, str)
     def handle_status(self, mode: str, msg: str):
@@ -216,20 +218,6 @@ class ImportWorker(QRunnable):
         finally:
             self.cleanup()
 
-    def import_assistants(self, silent: bool = False) -> bool:
-        """
-        Import assistants (not used for Google by default; kept for parity)
-
-        :param silent: silent mode
-        """
-        try:
-            if not silent:
-                self.signals.finished.emit("assistants", self.store_id, 0)
-            return True
-        except Exception as e:
-            self.signals.error.emit("assistants", e)
-            return False
-
     def import_vector_stores(self, silent: bool = False) -> bool:
         """
         Import File Search stores
@@ -282,7 +270,7 @@ class ImportWorker(QRunnable):
             for id in stores:
                 store = stores[id]
                 try:
-                    self.window.controller.remote_store.google.refresh_store(store, update=False)
+                    self.window.controller.remote_store.refresh_store(store, update=False, provider="google")
                     num += 1
                 except Exception as e:
                     self.log("Failed to refresh store: {}".format(id))

pygpt_net/provider/api/openai/assistants.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: 2026.01.05 17:00:00                  #
 # ================================================== #
 
 import json
@@ -16,7 +16,7 @@ from pygpt_net.item.assistant import AssistantItem
 from pygpt_net.item.ctx import CtxItem
 
 from .worker.assistants import AssistantsWorker, EventHandler
-from .worker.importer import Importer
+from .worker.importer_assistants import Importer
 
 
 class Assistants:

pygpt_net/provider/api/openai/store.py

@@ -6,7 +6,7 @@
 # GitHub:  https://github.com/szczyglis-dev/py-gpt   #
 # MIT License                                        #
 # Created By  : Marcin Szczygliński                  #
-# Updated Date: 2026.01.02 20:00:00                  #
+# Updated Date: 2026.01.05 17:00:00                  #
 # ================================================== #
 
 import os
@@ -14,6 +14,8 @@ from typing import Optional, List
 
 from pygpt_net.item.store import RemoteStoreItem
 
+from .worker.importer import Importer
+
 
 class Store:
     def __init__(self, window=None):
@@ -23,6 +25,7 @@ class Store:
         :param window: Window instance
         """
         self.window = window
+        self.importer = Importer(window)
 
     def get_client(self):
         """