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

pygpt_net/provider/api/anthropic/store.py

@@ -0,0 +1,307 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# ================================================== #
+# This file is a part of PYGPT package               #
+# Website: https://pygpt.net                         #
+# GitHub:  https://github.com/szczyglis-dev/py-gpt   #
+# MIT License                                        #
+# Created By  : Marcin Szczygliński                  #
+# Updated Date: 2026.01.05 20:00:00                  #
+# ================================================== #
+
+import os
+import mimetypes
+import time
+from typing import Optional, List, Dict, Any
+
+from .worker.importer import Importer
+
+
+class Store:
+    """
+    Anthropic Files API wrapper.
+    """
+
+    # Files API is in beta and requires this header, per official docs
+    # https://docs.anthropic.com/en/docs/build-with-claude/files
+    BETA_HEADER = ["files-api-2025-04-14"]
+
+    def __init__(self, window=None):
+        """
+        Anthropic Files API store wrapper
+
+        :param window: Window instance
+        """
+        self.window = window
+        self.importer = Importer(window)
+
+    def get_client(self):
+        """
+        Get Anthropic client
+
+        :return: anthropic.Anthropic
+        """
+        return self.window.core.api.anthropic.get_client()
+
+    def log(self, msg: str, callback: Optional[callable] = None):
+        """
+        Log message
+
+        :param msg: message to log
+        :param callback: callback log function
+        """
+        if callback is not None:
+            callback(msg)
+        else:
+            print(msg)
+
+    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
+
+    # -----------------------------
+    # Files service
+    # -----------------------------
+
+    def get_file(self, file_id: str):
+        """
+        Retrieve file metadata by ID using the SDK method names present in the installed version.
+        Prefer 'retrieve', fallback to 'get' only if available to avoid attribute errors.
+        """
+        client = self.get_client()
+        files_api = client.beta.files
+        if hasattr(files_api, "retrieve"):
+            return files_api.retrieve(file_id, betas=self.BETA_HEADER)
+        if hasattr(files_api, "get"):
+            return files_api.get(file_id, betas=self.BETA_HEADER)
+        raise AttributeError("Anthropic Files API client does not expose 'retrieve' or 'get' for file metadata.")
+
+    def upload(self, path: str):
+        """
+        Upload file to Anthropic Files API.
+
+        Per SDK guidance, the Python client supports passing a PathLike, raw bytes,
+        or a (filename, contents, media_type) tuple. Using the tuple form ensures the
+        correct filename and MIME type are sent in multipart/form-data.
+
+        :param path: file path
+        :return: file object or None
+        """
+        client = self.get_client()
+        if not os.path.exists(path):
+            return None
+
+        filename = os.path.basename(path)
+        mime_type = mimetypes.guess_type(path)[0] or "application/octet-stream"
+        with open(path, "rb") as f:
+            data = f.read()
+        file_part = (filename, data, mime_type)
+
+        files_api = client.beta.files
+
+        try:
+            return files_api.upload(file=file_part, betas=self.BETA_HEADER)
+        except Exception:
+            if hasattr(files_api, "create"):
+                return files_api.create(file=file_part, betas=self.BETA_HEADER)
+            raise
+
+    def delete_file(self, file_id: str) -> Optional[str]:
+        """
+        Delete a file by ID. Returns the file_id on success.
+        """
+        client = self.get_client()
+        res = client.beta.files.delete(file_id, betas=self.BETA_HEADER)
+        if res is not None:
+            return file_id
+
+    def download(self, file_id: str, path: str) -> bool:
+        """
+        Download a file content to a local path.
+
+        :param file_id: Anthropic Files API file id
+        :param path: target file path
+        :return: True on success
+        """
+        client = self.get_client()
+        try:
+            # SDK returns raw bytes for file content
+            data = client.beta.files.content(file_id, betas=self.BETA_HEADER)
+        except Exception:
+            data = None
+
+        if data is None:
+            return False
+
+        try:
+            if hasattr(data, "read"):
+                content = data.read()
+            else:
+                content = data if isinstance(data, (bytes, bytearray)) else bytes(data)
+            with open(path, "wb") as f:
+                f.write(content)
+            return True
+        except Exception:
+            return False
+
+    def download_to_dir(self, file_id: str, prefer_name: Optional[str] = None) -> Optional[str]:
+        """
+        Download a file by ID into configured download directory.
+
+        :param file_id: Anthropic Files API file id
+        :param prefer_name: optional filename preference
+        :return: saved file path or None
+        """
+        dir_path = self._download_dir()
+        filename = None
+
+        if prefer_name:
+            filename = os.path.basename(prefer_name)
+
+        if not filename:
+            try:
+                meta = self.get_file(file_id)
+            except Exception:
+                meta = None
+            if meta is not None:
+                for attr in ("filename", "name", "id"):
+                    try:
+                        val = getattr(meta, attr, None)
+                        if isinstance(val, str) and val:
+                            filename = os.path.basename(val)
+                            break
+                    except Exception:
+                        pass
+                if not filename:
+                    filename = file_id
+            else:
+                filename = file_id
+
+        if not os.path.splitext(filename)[1] and meta is not None:
+            try:
+                mime = getattr(meta, "mime_type", None)
+                ext = mimetypes.guess_extension(mime or "") or ""
+                if ext and not filename.endswith(ext):
+                    filename = filename + ext
+            except Exception:
+                pass
+
+        path = self._ensure_unique_path(dir_path, filename)
+        if self.download(file_id, path):
+            return path
+        return None
+
+    def get_files_ids(self, limit: int = 1000) -> List[str]:
+        """
+        Return a list of file IDs. Falls back to filename only if id is missing.
+        """
+        client = self.get_client()
+        items: List[str] = []
+        pager = client.beta.files.list(limit=limit, betas=self.BETA_HEADER)
+
+        data = getattr(pager, "data", None)
+        if data is None:
+            data = pager
+
+        for f in data:
+            fid = getattr(f, "id", None) or getattr(f, "filename", None)
+            if fid and fid not in items:
+                items.append(fid)
+        return items
+
+    def remove_files(self, callback: Optional[callable] = None) -> int:
+        """
+        Remove all files from remote storage. Returns number of successfully removed files.
+        """
+        num = 0
+        files = self.get_files_ids()
+        for file_id in files:
+            self.log("Removing file: " + file_id, callback)
+            try:
+                res = self.delete_file(file_id)
+                if res:
+                    num += 1
+            except Exception as e:
+                msg = "Error removing file {}: {}".format(file_id, str(e))
+                self.log(msg, callback)
+        return num
+
+    def remove_file(self, file_id: str, callback: Optional[callable] = None) -> bool:
+        """
+        Remove a single file by ID. Raises on errors to allow upstream handling.
+        """
+        self.log("Removing file: " + file_id, callback)
+        try:
+            res = self.delete_file(file_id)
+            return res is not None
+        except Exception as e:
+            msg = "Error removing file {}: {}".format(file_id, str(e))
+            self.log(msg, callback)
+            raise
+
+    def import_files(self, callback: Optional[callable] = None) -> int:
+        """
+        Import all files from Anthropic Files API into local DB.
+
+        :param callback: log callback
+        :return: number of imported files
+        """
+        client = self.get_client()
+        total = 0
+        pager = client.beta.files.list(limit=1000, betas=self.BETA_HEADER)
+
+        data = getattr(pager, "data", None)
+        if data is None:
+            data = pager
+
+        for f in data:
+            try:
+                self.window.core.remote_store.anthropic.files.insert("files", f)
+                total += 1
+            except Exception as e:
+                self.log("Error importing file {}: {}".format(getattr(f, "id", "?"), e), callback)
+        return total
+
+    def get_files_stats(self) -> Dict[str, Any]:
+        """
+        Compute files stats (count + total bytes).
+        """
+        client = self.get_client()
+        count = 0
+        total_bytes = 0
+        pager = client.beta.files.list(limit=1000, betas=self.BETA_HEADER)
+
+        data = getattr(pager, "data", None)
+        if data is None:
+            data = pager
+
+        for f in data:
+            count += 1
+            try:
+                size = getattr(f, "size_bytes", None)
+                if size is None and hasattr(f, "size"):
+                    size = getattr(f, "size")
+                total_bytes += int(size or 0)
+            except Exception:
+                pass
+        return {"count": count, "total_bytes": total_bytes}

pygpt_net/provider/api/anthropic/stream.py

@@ -40,6 +40,70 @@ def process_anthropic_chunk(ctx, core, state, chunk) -> Optional[str]:
     except Exception:
         pass
 
+    def _to_plain(obj):
+        try:
+            if hasattr(obj, "model_dump"):
+                return obj.model_dump()
+            if hasattr(obj, "to_dict"):
+                return obj.to_dict()
+        except Exception:
+            pass
+        if isinstance(obj, dict):
+            return {k: _to_plain(v) for k, v in obj.items()}
+        if isinstance(obj, (list, tuple)):
+            return [_to_plain(x) for x in obj]
+        return obj
+
+    def _walk_for_file_ids(o, acc: set):
+        if o is None:
+            return
+        if isinstance(o, dict):
+            for k, v in o.items():
+                if k == "file_id" and isinstance(v, str) and v.startswith("file_"):
+                    acc.add(v)
+                else:
+                    _walk_for_file_ids(v, acc)
+        elif isinstance(o, (list, tuple)):
+            for it in o:
+                _walk_for_file_ids(it, acc)
+
+    def _download_files(ids: set):
+        if not ids:
+            return
+        if not hasattr(state, "anthropic_downloaded_ids"):
+            state.anthropic_downloaded_ids = set()
+        saved = []
+        for fid in ids:
+            if fid in state.anthropic_downloaded_ids:
+                continue
+            try:
+                path = core.api.anthropic.store.download_to_dir(fid)
+            except Exception:
+                path = None
+            if path:
+                saved.append(path)
+                state.anthropic_downloaded_ids.add(fid)
+        if saved:
+            try:
+                loc = core.filesystem.make_local_list(saved)
+            except Exception:
+                loc = saved
+            if not isinstance(ctx.files, list):
+                ctx.files = []
+            for p in loc:
+                if p not in ctx.files:
+                    ctx.files.append(p)
+            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)
 
     # --- Top-level delta objects (when SDK yields deltas directly) ---
     if etype == "text_delta":
@@ -95,6 +159,17 @@ def process_anthropic_chunk(ctx, core, state, chunk) -> Optional[str]:
         except Exception:
             pass
 
+        try:
+            cb = getattr(chunk, "content_block", None)
+            if cb:
+                btype = getattr(cb, "type", "") or ""
+                if btype.endswith("_tool_result"):
+                    ids = set()
+                    _walk_for_file_ids(_to_plain(getattr(cb, "content", None)), ids)
+                    _download_files(ids)
+        except Exception:
+            pass
+
         try:
             cb = getattr(chunk, "content_block", None)
             if cb and getattr(cb, "type", "") == "web_search_tool_result":

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

@@ -0,0 +1,278 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# ================================================== #
+# This file is a part of PYGPT package               #
+# Website: https://pygpt.net                         #
+# GitHub:  https://github.com/szczyglis-dev/py-gpt   #
+# MIT License                                        #
+# Created By  : Marcin Szczygliński                  #
+# Updated Date: 2026.01.05 17:00:00                  #
+# ================================================== #
+
+import os
+
+from PySide6.QtCore import QObject, Signal, QRunnable, Slot
+
+
+class Importer(QObject):
+    def __init__(self, window=None):
+        """
+        Importer core (Anthropic Files)
+
+        :param window: Window instance
+        """
+        super(Importer, self).__init__()
+        self.window = window
+        self.worker = None
+
+    @Slot(str, object)
+    def handle_error(self, mode: str, err: any):
+        batch = self.window.controller.remote_store.batch
+        if mode == "import_files":
+            batch.handle_imported_files_failed(err)
+        elif mode == "truncate_files":
+            batch.handle_truncated_files_failed(err)
+        elif mode == "upload_files":
+            batch.handle_uploaded_files_failed(err)
+        elif mode in "vector_stores":
+            batch.handle_imported_stores_failed(err)
+        elif mode in "truncate_vector_stores":
+            batch.handle_truncated_stores_failed(err)
+        elif mode in "refresh_vector_stores":
+            batch.handle_refreshed_stores_failed(err)
+
+    @Slot(str, str, int)
+    def handle_finished(self, mode: str, store_id: str = None, num: int = 0):
+        batch = self.window.controller.remote_store.batch
+        if mode == "import_files":
+            batch.handle_imported_files(num)
+        elif mode == "truncate_files":
+            batch.handle_truncated_files(store_id, num)
+        elif mode == "upload_files":
+            batch.handle_uploaded_files(num)
+        elif mode == "vector_stores":
+            batch.handle_imported_stores(num)
+        elif mode == "truncate_vector_stores":
+            batch.handle_truncated_stores(num)
+        elif mode == "refresh_vector_stores":
+            batch.handle_refreshed_stores(num)
+
+    @Slot(str, str)
+    def handle_status(self, mode: str, msg: str):
+        self.window.controller.assistant.batch.handle_status_change(mode, msg)
+
+    @Slot(str, str)
+    def handle_log(self, mode: str, msg: str):
+        self.window.controller.assistant.threads.log(mode + ": " + msg)
+
+    def import_vector_stores(self):
+        """Create/ensure pseudo-store and import files list."""
+        self.worker = ImportWorker()
+        self.worker.window = self.window
+        self.worker.mode = "vector_stores"
+        self.connect_signals(self.worker)
+        self.window.threadpool.start(self.worker)
+
+    def truncate_vector_stores(self):
+        """Clear local pseudo-store metadata (no remote action)."""
+        self.worker = ImportWorker()
+        self.worker.window = self.window
+        self.worker.mode = "truncate_vector_stores"
+        self.connect_signals(self.worker)
+        self.window.threadpool.start(self.worker)
+
+    def truncate_files(self, store_id: str = None):
+        """Remove all files via Files API."""
+        self.worker = ImportWorker()
+        self.worker.window = self.window
+        self.worker.mode = "truncate_files"
+        self.worker.store_id = store_id
+        self.connect_signals(self.worker)
+        self.window.threadpool.start(self.worker)
+
+    def upload_files(self, store_id: str, files: list = None):
+        """Upload files to Files API."""
+        self.worker = ImportWorker()
+        self.worker.window = self.window
+        self.worker.mode = "upload_files"
+        self.worker.store_id = store_id
+        self.worker.files = files or []
+        self.connect_signals(self.worker)
+        self.window.threadpool.start(self.worker)
+
+    def refresh_vector_stores(self):
+        """Refresh pseudo-store status."""
+        self.worker = ImportWorker()
+        self.worker.window = self.window
+        self.worker.mode = "refresh_vector_stores"
+        self.connect_signals(self.worker)
+        self.window.threadpool.start(self.worker)
+
+    def import_files(self, store_id: str = None):
+        """Import files from Files API."""
+        self.worker = ImportWorker()
+        self.worker.window = self.window
+        self.worker.mode = "import_files"
+        self.worker.store_id = store_id
+        self.connect_signals(self.worker)
+        self.window.threadpool.start(self.worker)
+
+    def connect_signals(self, worker):
+        worker.signals.finished.connect(self.handle_finished)
+        worker.signals.error.connect(self.handle_error)
+        worker.signals.status.connect(self.handle_status)
+        worker.signals.log.connect(self.handle_log)
+
+
+class ImportWorkerSignals(QObject):
+    status = Signal(str, str)            # mode, message
+    finished = Signal(str, str, int)     # mode, store_id, num
+    error = Signal(str, object)          # mode, error
+    log = Signal(str, str)               # mode, message
+
+
+class ImportWorker(QRunnable):
+    """Import worker (Anthropic)"""
+    def __init__(self, *args, **kwargs):
+        super().__init__()
+        self.signals = ImportWorkerSignals()
+        self.window = None
+        self.mode = "vector_stores"
+        self.store_id = "files"
+        self.files = []
+
+    @Slot()
+    def run(self):
+        try:
+            if self.mode == "vector_stores":
+                if self.import_vector_stores():
+                    self.import_files()
+            elif self.mode == "truncate_vector_stores":
+                self.truncate_vector_stores()
+            elif self.mode == "refresh_vector_stores":
+                self.refresh_vector_stores()
+            elif self.mode == "truncate_files":
+                self.truncate_files()
+            elif self.mode == "import_files":
+                self.import_files()
+            elif self.mode == "upload_files":
+                self.upload_files()
+        except Exception as e:
+            self.signals.error.emit(self.mode, e)
+        finally:
+            self.cleanup()
+
+    def import_vector_stores(self, silent: bool = False) -> bool:
+        """
+        Ensure pseudo-store exists locally.
+        """
+        try:
+            self.log("Ensuring Anthropic workspace store...")
+            items = {}
+            # Single pseudo-store object
+            store = self.window.core.remote_store.anthropic.create("Files")
+            items[store.id] = store
+            self.window.core.remote_store.anthropic.import_items(items)
+            if not silent:
+                self.signals.finished.emit("vector_stores", self.store_id, 1)
+            return True
+        except Exception as e:
+            self.log("API error: {}".format(e))
+            self.signals.error.emit("vector_stores", e)
+            return False
+
+    def truncate_vector_stores(self, silent: bool = False) -> bool:
+        try:
+            self.log("Truncating local pseudo-store...")
+            self.window.core.remote_store.anthropic.items = {}
+            self.window.core.remote_store.anthropic.save()
+            if not silent:
+                self.signals.finished.emit("truncate_vector_stores", self.store_id, 1)
+            return True
+        except Exception as e:
+            self.log("API error: {}".format(e))
+            self.signals.error.emit("truncate_vector_stores", e)
+            return False
+
+    def refresh_vector_stores(self, silent: bool = False) -> bool:
+        try:
+            self.log("Refreshing workspace status...")
+            # Ensure exists
+            if "files" not in self.window.core.remote_store.anthropic.items:
+                self.import_vector_stores(silent=True)
+            store = self.window.core.remote_store.anthropic.items["files"]
+            self.window.controller.remote_store.refresh_store(store, update=False, provider="anthropic")
+            if not silent:
+                self.signals.finished.emit("refresh_vector_stores", self.store_id, 1)
+            return True
+        except Exception as e:
+            self.log("API error: {}".format(e))
+            self.signals.error.emit("refresh_vector_stores", e)
+            return False
+
+    def truncate_files(self, silent: bool = False) -> bool:
+        try:
+            self.log("Removing all files via Anthropic Files API...")
+            num = self.window.core.api.anthropic.store.remove_files(callback=self.callback)
+            self.window.core.remote_store.anthropic.files.truncate_local()
+            if not silent:
+                self.signals.finished.emit("truncate_files", self.store_id, num)
+            return True
+        except Exception as e:
+            self.log("API error: {}".format(e))
+            self.signals.error.emit("truncate_files", e)
+            return False
+
+    def upload_files(self, silent: bool = False) -> bool:
+        num = 0
+        try:
+            self.log("Uploading files to Anthropic Files API...")
+            for path in self.files:
+                try:
+                    f = self.window.core.api.anthropic.store.upload(path)
+                    if f is not None:
+                        self.window.core.remote_store.anthropic.files.insert("files", f)
+                        num += 1
+                        msg = "Uploaded file: {}/{}".format(num, len(self.files))
+                        self.signals.status.emit("upload_files", msg)
+                        self.log(msg)
+                    else:
+                        self.signals.status.emit("upload_files", "Failed to upload: {}".format(os.path.basename(path)))
+                except Exception as e:
+                    self.window.core.debug.log(e)
+                    self.signals.status.emit("upload_files", "Failed to upload: {}".format(os.path.basename(path)))
+            if not silent:
+                self.signals.finished.emit("upload_files", self.store_id, num)
+            return True
+        except Exception as e:
+            self.log("API error: {}".format(e))
+            self.signals.error.emit("upload_files", e)
+            return False
+
+    def import_files(self, silent: bool = False) -> bool:
+        try:
+            self.log("Importing files from Anthropic Files API...")
+            self.window.core.remote_store.anthropic.files.truncate_local()
+            num = self.window.core.api.anthropic.store.import_files(callback=self.callback)
+            if not silent:
+                self.signals.finished.emit("import_files", self.store_id, num)
+            return True
+        except Exception as e:
+            self.log("API error: {}".format(e))
+            self.signals.error.emit("import_files", e)
+            return False
+
+    def callback(self, msg: str):
+        self.log(msg)
+
+    def log(self, msg: str):
+        self.signals.log.emit(self.mode, msg)
+
+    def cleanup(self):
+        sig = self.signals
+        self.signals = None
+        if sig is not None:
+            try:
+                sig.deleteLater()
+            except RuntimeError:
+                pass