pygpt-net 2.7.4__py3-none-any.whl → 2.7.5__py3-none-any.whl

pygpt_net/core/remote_store/google/files.py

@@ -0,0 +1,224 @@
+#!/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.02 20:00:00                  #
+# ================================================== #
+
+from typing import Optional, List, Dict, Union
+
+from packaging.version import Version
+
+from pygpt_net.item.assistant import AssistantItem
+from pygpt_net.item.store import RemoteFileItem
+from pygpt_net.provider.core.remote_file.db_sqlite import DbSqliteProvider
+
+
+class Files:
+
+    PROVIDER_NAME = "google"
+
+    def __init__(self, window=None):
+        """
+        Google remote files core (File Search documents)
+
+        :param window: Window instance
+        """
+        self.window = window
+        self.provider = DbSqliteProvider(window)
+        self.items = {}
+
+    def install(self):
+        self.provider.install()
+
+    def patch(self, app_version: Version) -> bool:
+        return self.provider.patch(app_version)
+
+    def get(self, id: str) -> Optional[RemoteFileItem]:
+        if id in self.items:
+            return self.items[id]
+        return None
+
+    def get_ids(self) -> List[str]:
+        return list(self.items.keys())
+
+    def get_all(self) -> Dict[str, RemoteFileItem]:
+        return self.items
+
+    def get_id_by_idx_all(self, idx: int) -> str:
+        return list(self.items.keys())[idx]
+
+    def get_by_idx(self, idx: int) -> str:
+        items = self.items
+        return list(items.keys())[idx]
+
+    def has(self, id: str) -> bool:
+        return id in self.items
+
+    def create(
+            self,
+            assistant: AssistantItem,
+            thread_id: str,
+            file_id: str,
+            name: str,
+            path: str,
+            size: int) -> Optional[RemoteFileItem]:
+        """
+        Not used in Google path (kept for parity). Use insert() instead.
+        """
+        file = RemoteFileItem()
+        file.id = file_id
+        file.file_id = file_id
+        file.thread_id = thread_id
+        file.provider = self.PROVIDER_NAME
+        file.name = name
+        file.path = path
+        file.size = size
+        if assistant.vector_store is not None and assistant.vector_store != "":
+            file.store_id = assistant.vector_store
+        file.record_id = self.provider.create(file)
+        self.items[file.id] = file
+        return file
+
+    def update(self, file: RemoteFileItem) -> Optional[RemoteFileItem]:
+        self.items[file.id] = file
+        self.provider.save(file)
+        return file
+
+    def get_names(self) -> Dict[str, str]:
+        names = {}
+        for id in self.items:
+            file = self.items[id]
+            names[id] = file.name
+        return names
+
+    def get_by_store_or_thread(self, store_id: str, thread_id: str) -> Dict[str, RemoteFileItem]:
+        return self.provider.get_by_store_or_thread(store_id, thread_id)
+
+    def count_by_store_or_thread(self, store_id: str, thread_id: str) -> int:
+        return self.provider.count_by_store_or_thread(store_id, thread_id)
+
+    def get_file_by_idx(self, idx: int, store_id: str, thread_id: str) -> Optional[RemoteFileItem]:
+        files = self.get_by_store_or_thread(store_id, thread_id)
+        if idx >= len(files):
+            return None
+        return list(files.values())[idx]
+
+    def get_file_id_by_idx(self, idx: int, store_id: str, thread_id: str) -> Optional[str]:
+        file = self.get_file_by_idx(idx, store_id, thread_id)
+        if file is None:
+            return None
+        return file.file_id
+
+    def get_all_by_file_id(self, file_id: str) -> dict:
+        return self.provider.get_all_by_file_id(file_id)
+
+    def delete(self, file: Union[RemoteFileItem, list]) -> bool:
+        files = file if isinstance(file, list) else [file]
+        for f in files:
+            file_id = f.file_id  # document name (fileSearchStores/.../documents/..)
+            items = self.get_all_by_file_id(file_id)
+            for id in items:
+                store_id = items[id].store_id
+                if store_id is None or store_id == "":
+                    continue
+                try:
+                    self.window.core.api.google.store.delete_store_file(store_id, file_id)
+                except Exception as e:
+                    self.window.core.debug.log("Failed to delete document from store: " + str(e))
+            self.provider.delete_by_id(f.record_id)
+            try:
+                # There is no Files API deletion here; this is store document
+                pass
+            except Exception as e:
+                self.window.core.debug.log("Failed to delete remote document: " + str(e))
+            if f.record_id in self.items:
+                del self.items[f.record_id]
+        return True
+
+    def delete_by_file_id(self, file_id: str) -> bool:
+        res = self.provider.delete_by_file_id(file_id)
+        if res:
+            to_delete = []
+            for id in self.items:
+                if self.items[id].file_id == file_id:
+                    to_delete.append(id)
+            for id in to_delete:
+                del self.items[id]
+        return res
+
+    def on_store_deleted(self, store_id: str):
+        self.provider.clear_store_from_files(store_id)
+
+    def on_all_stores_deleted(self):
+        self.provider.clear_all_stores_from_files(self.PROVIDER_NAME)
+
+    def rename(self, record_id: int, name: str) -> bool:
+        self.provider.rename_file(record_id, name)
+        if record_id in self.items:
+            self.items[record_id].name = name
+        return True
+
+    def truncate(self, store_id: Optional[str] = None) -> bool:
+        if store_id is not None:
+            self.window.core.api.google.store.remove_from_store(store_id)
+        else:
+            self.window.core.api.google.store.remove_from_stores()
+        return self.truncate_local(store_id)
+
+    def truncate_local(self, store_id: Optional[str] = None) -> bool:
+        if store_id is not None:
+            self.provider.truncate_by_store(store_id)
+        else:
+            self.provider.truncate_all(self.PROVIDER_NAME)
+            self.items = {}
+        return True
+
+    def import_from_store(self, store_id: str) -> bool:
+        files = self.window.core.api.google.store.import_store_files(store_id)
+        for file in files:
+            # Not used in this path
+            pass
+        return True
+
+    def insert(self, store_id: str, data) -> RemoteFileItem:
+        """
+        Insert a Document into local DB
+
+        :param store_id: store name ('fileSearchStores/...').
+        :param data: document object from API
+        """
+        file = RemoteFileItem()
+        # Use document name as unique id and file_id
+        file.id = getattr(data, "name", None)
+        file.file_id = getattr(data, "name", None)
+        file.thread_id = ""
+        file.name = getattr(data, "display_name", None) or getattr(data, "name", "")
+        file.provider = self.PROVIDER_NAME
+        file.path = getattr(data, "display_name", None) or getattr(data, "name", "")
+        # sizeBytes is a string (int64), convert if possible
+        try:
+            file.size = int(getattr(data, "size_bytes", 0) or 0)
+        except Exception:
+            file.size = 0
+        file.store_id = store_id
+        file.record_id = self.provider.create(file)
+        self.items[file.id] = file
+        return file
+
+    def load(self):
+        self.items = self.provider.load_all(self.PROVIDER_NAME)
+        self.sort_items()
+
+    def sort_items(self):
+        return
+
+    def save(self):
+        self.provider.save_all(self.items)
+
+    def get_version(self) -> str:
+        return self.provider.get_version()

pygpt_net/core/remote_store/google/store.py

@@ -0,0 +1,248 @@
+#!/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.02 20:00:00                  #
+# ================================================== #
+
+import datetime
+from typing import Optional, List, Dict, Any
+
+from packaging.version import Version
+
+from pygpt_net.item.store import RemoteStoreItem
+from pygpt_net.provider.core.remote_store.db_sqlite import DbSqliteProvider
+
+from .files import Files
+
+
+class Store:
+
+    PROVIDER_NAME = "google"
+
+    def __init__(self, window=None):
+        """
+        Google File Search store core
+
+        :param window: Window instance
+        """
+        self.window = window
+        self.provider = DbSqliteProvider(window)
+        self.files = Files(window)
+        self.items = {}
+
+    def install(self):
+        """Install provider data"""
+        self.provider.install()
+        self.files.install()
+
+    def patch(self, app_version: Version) -> bool:
+        """Patch provider data"""
+        res1 = self.files.patch(app_version)
+        res2 = self.provider.patch(app_version)
+        return res1 or res2
+
+    def get(self, id: str) -> RemoteStoreItem:
+        if id in self.items:
+            return self.items[id]
+
+    def get_ids(self) -> List[str]:
+        return list(self.items.keys())
+
+    def get_all(self) -> Dict[str, RemoteStoreItem]:
+        return self.items
+
+    def get_id_by_idx_all(self, idx: int) -> str:
+        return list(self.items.keys())[idx]
+
+    def get_by_idx(self, idx: int) -> str:
+        items = self.items
+        return list(items.keys())[idx]
+
+    def has(self, id: str) -> bool:
+        return id in self.items
+
+    def create(self, name: Optional[str] = None) -> Optional[RemoteStoreItem]:
+        """
+        Create new File Search store
+
+        :param name: display name for the store (also used as local alias)
+        :return: store item
+        """
+        # Use provided name or fallback
+        display_name = name or "New file search store"
+
+        # Create remote store with a display name
+        vector_store = self.window.core.api.google.store.create_store(display_name, 0)
+        if vector_store is None:
+            return None
+
+        # Build local item; set local alias to the provided name
+        store = RemoteStoreItem()
+        store.id = getattr(vector_store, "name", None)  # 'fileSearchStores/...'
+        # Keep local alias as the passed name; fallback to remote display_name if missing
+        store.name = display_name or (getattr(vector_store, "display_name", None) or "")
+        store.provider = self.PROVIDER_NAME
+        store.is_thread = False
+        store.record_id = self.provider.create(store)
+        self.items[store.id] = store
+        return store
+
+    def update(self, store: RemoteStoreItem) -> Optional[RemoteStoreItem]:
+        """
+        Update store (local persist; remote update is not supported by Google)
+        """
+        vector_store = self.window.core.api.google.store.update_store(store.id, store.name, store.expire_days)
+        # Always persist local metadata (alias)
+        self.items[store.id] = store
+        self.provider.save(store)
+        return store
+
+    def get_status_data(self, id: str):
+        """
+        Get store status data
+
+        :param id: store id
+        :return: status data, store data
+        """
+        status = {}
+        data = self.window.core.api.google.store.get_store(id)
+        if data is not None:
+            status = self.parse_status(data)
+        return status, data
+
+    def parse_status(self, store) -> Dict[str, Any]:
+        """
+        Map Google File Search store status to local fields
+        """
+        def _to_int(x):
+            try:
+                return int(x or 0)
+            except Exception:
+                return 0
+
+        active = _to_int(getattr(store, "active_documents_count", 0))
+        pending = _to_int(getattr(store, "pending_documents_count", 0))
+        failed = _to_int(getattr(store, "failed_documents_count", 0))
+        size_bytes = _to_int(getattr(store, "size_bytes", 0))
+        update_time = getattr(store, "update_time", None)
+        display_name = getattr(store, "display_name", None) or ""
+
+        status_str = "ready"
+        if pending > 0:
+            status_str = "indexing"
+        if failed > 0 and active == 0 and pending == 0:
+            status_str = "failed"
+
+        status = {
+            "status": status_str,
+            "usage_bytes": size_bytes,
+            "expires_at": None,
+            "last_active_at": self._parse_rfc3339_to_epoch(update_time) if update_time else None,
+            "file_counts": {
+                "in_progress": pending,
+                "completed": active,
+                "cancelled": 0,
+                "failed": failed,
+                "total": active + pending + failed,
+            },
+            "expires_after": None,
+            "remote_display_name": display_name,
+        }
+        return status
+
+    def _parse_rfc3339_to_epoch(self, s: str) -> int:
+        """Convert RFC3339 to epoch seconds if possible"""
+        try:
+            s2 = s.replace('Z', '+00:00')
+            ts = datetime.datetime.fromisoformat(s2)
+            return int(ts.timestamp())
+        except Exception:
+            return int(datetime.datetime.now().timestamp())
+
+    def update_status(self, id: str):
+        """
+        Update store status and keep local alias if set
+        """
+        store = self.items[id]
+        status, data = self.get_status_data(id)
+        remote_name = getattr(data, "display_name", None) if data else None
+        # Keep local alias if user set it; otherwise adopt remote display name
+        if not store.name or store.name.strip() == "":
+            store.name = remote_name or ""
+        store.provider = self.PROVIDER_NAME
+        self.append_status(store, status)
+        self.update(store)
+
+    def append_status(self, store: RemoteStoreItem, status: Dict[str, Any]):
+        now = datetime.datetime.now()
+        ts = int(now.timestamp())
+        status["__last_refresh__"] = now.strftime("%Y-%m-%d %H:%M:%S")
+        store.status = status
+        store.last_sync = ts
+        if "status" in status:
+            store.last_status = status["status"]
+        if "usage_bytes" in status:
+            store.usage_bytes = status["usage_bytes"]
+        if "file_counts" in status:
+            store.num_files = status["file_counts"]["total"]
+        if "last_active_at" in status and status["last_active_at"]:
+            store.last_active = int(status["last_active_at"])
+
+    def get_names(self) -> Dict[str, str]:
+        names = {}
+        for id in self.items:
+            store = self.items[id]
+            names[id] = store.name
+        return names
+
+    def delete(self, id: str) -> bool:
+        if id in self.items:
+            store = self.items[id]
+            self.provider.delete_by_id(store.record_id)
+            self.window.core.api.google.store.remove_store(id)
+            del self.items[id]
+            return True
+        return False
+
+    def import_items(self, items: Dict[str, RemoteStoreItem]):
+        self.items = items
+        for item in items.values():
+            item.provider = self.PROVIDER_NAME
+            item.record_id = self.provider.create(item)
+
+    def clear(self):
+        self.truncate()
+
+    def is_hidden(self, id: str) -> bool:
+        if id in self.items:
+            if (self.window.core.config.get("remote_store.google.hide_threads")
+                    and (self.items[id].name is None or self.items[id].name == "")):
+                return True
+        return False
+
+    def truncate(self) -> bool:
+        self.provider.truncate(self.PROVIDER_NAME)
+        self.items = {}
+        return True
+
+    def load(self):
+        self.items = self.provider.load_all(self.PROVIDER_NAME)
+        self.sort_items()
+
+    def load_all(self):
+        self.load()
+        self.files.load()
+
+    def sort_items(self):
+        pass
+
+    def save(self):
+        self.provider.save_all(self.items)
+
+    def get_version(self) -> str:
+        return self.provider.get_version()

pygpt_net/core/remote_store/openai/__init__.py

@@ -0,0 +1,11 @@
+#!/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.02 20:00:00                  #
+# ================================================== #
+from .store import *

pygpt_net/core/{assistants → remote_store/openai}/files.py

@@ -6,21 +6,25 @@
 # GitHub:  https://github.com/szczyglis-dev/py-gpt   #
 # MIT License                                        #
 # Created By  : Marcin Szczygliński                  #
-# Updated Date: 2025.12.27 00:00:00                  #
+# Updated Date: 2026.01.02 19:00:00                  #
 # ================================================== #
 
 from typing import Optional, List, Dict, Union
 
 from packaging.version import Version
 
-from pygpt_net.item.assistant import AssistantFileItem, AssistantItem
-from pygpt_net.provider.core.assistant_file.db_sqlite import DbSqliteProvider
+from pygpt_net.item.assistant import AssistantItem
+from pygpt_net.item.store import RemoteFileItem
+from pygpt_net.provider.core.remote_file.db_sqlite import DbSqliteProvider
 
 
 class Files:
+
+    PROVIDER_NAME = "openai"
+
     def __init__(self, window=None):
         """
-        Assistant files core
+        OpenAI remote files core
 
         :param window: Window instance
         """
@@ -41,7 +45,7 @@ class Files:
         """
         return self.provider.patch(app_version)
 
-    def get(self, id: str) -> AssistantFileItem:
+    def get(self, id: str) -> Optional[RemoteFileItem]:
         """
         Get file item by file_id
 
@@ -50,6 +54,7 @@ class Files:
         """
         if id in self.items:
             return self.items[id]
+        return None
 
     def get_ids(self) -> List[str]:
         """
@@ -60,7 +65,7 @@ class Files:
         return list(self.items.keys())
 
 
-    def get_all(self) -> Dict[str, AssistantFileItem]:
+    def get_all(self) -> Dict[str, RemoteFileItem]:
         """
         Return all files
 
@@ -105,7 +110,7 @@ class Files:
             file_id: str,
             name: str,
             path: str,
-            size: int) -> Optional[AssistantFileItem]:
+            size: int) -> Optional[RemoteFileItem]:
         """
         Create new file
 
@@ -117,10 +122,11 @@ class Files:
         :param size: file size
         :return: file item
         """
-        file = AssistantFileItem()
+        file = RemoteFileItem()
         file.id = file_id
         file.file_id = file_id
         file.thread_id = thread_id
+        file.provider = self.PROVIDER_NAME
         file.name = name
         file.path = path
         file.size = size
@@ -132,8 +138,8 @@ class Files:
 
     def update(
             self,
-            file: AssistantFileItem
-    ) -> Optional[AssistantFileItem]:
+            file: RemoteFileItem
+    ) -> Optional[RemoteFileItem]:
         """
         Update file
 
@@ -160,7 +166,7 @@ class Files:
             self,
             store_id: str,
             thread_id: str
-    ) -> Dict[str, AssistantFileItem]:
+    ) -> Dict[str, RemoteFileItem]:
         """
         Get files by store or thread
 
@@ -189,7 +195,7 @@ class Files:
             idx: int,
             store_id: str,
             thread_id: str
-    ) -> Optional[AssistantFileItem]:
+    ) -> Optional[RemoteFileItem]:
         """
         Get file by list index
 
@@ -231,7 +237,7 @@ class Files:
         """
         return self.provider.get_all_by_file_id(file_id)
 
-    def delete(self, file: Union[AssistantFileItem, list]) -> bool:
+    def delete(self, file: Union[RemoteFileItem, list]) -> bool:
         """
         Delete file and remove from vector stores if exists
 
@@ -287,7 +293,7 @@ class Files:
 
     def on_all_stores_deleted(self):
         """Clear all deleted stores from files"""
-        self.provider.clear_all_stores_from_files()
+        self.provider.clear_all_stores_from_files(self.PROVIDER_NAME)
 
     def rename(self, record_id: int, name: str) -> bool:
         """
@@ -325,7 +331,7 @@ class Files:
         if store_id is not None:
             self.provider.truncate_by_store(store_id)  # truncate files in DB (by store_id)
         else:
-            self.provider.truncate_all()  # truncate all files in DB
+            self.provider.truncate_all(self.PROVIDER_NAME)  # truncate all files in DB
             self.items = {}  # clear items
         return True
 
@@ -341,18 +347,19 @@ class Files:
             self.create(file.assistant, file.thread_id, file.file_id, file.name, file.path, file.size)
         return True
 
-    def insert(self, store_id: str, data) -> AssistantFileItem:
+    def insert(self, store_id: str, data) -> RemoteFileItem:
         """
         Insert file object
 
         :param store_id: store ID
         :param data: file data from API
         """
-        file = AssistantFileItem()
+        file = RemoteFileItem()
         file.id = data.id
         file.file_id = data.id
         file.thread_id = ""
         file.name = data.filename
+        file.provider = self.PROVIDER_NAME
         file.path = data.filename
         file.size = data.bytes
         file.store_id = store_id
@@ -361,8 +368,8 @@ class Files:
         return file
 
     def load(self):
-        """Load file"""
-        self.items = self.provider.load_all()
+        """Load files"""
+        self.items = self.provider.load_all(self.PROVIDER_NAME)
         self.sort_items()
 
     def sort_items(self):