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

pygpt_net/provider/api/openai/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 19:00:00                  #
+# Updated Date: 2026.01.05 17:00:00                  #
 # ================================================== #
 
 import os
@@ -33,20 +33,19 @@ class Importer(QObject):
         :param mode: mode
         :param err: error message
         """
-        if mode == "assistants":
-            self.window.controller.assistant.batch.handle_imported_assistants_failed(err)
-        elif mode == "import_files":
-            self.window.controller.remote_store.openai.batch.handle_imported_files_failed(err)
+        batch = self.window.controller.remote_store.batch
+        if mode == "import_files":
+            batch.handle_imported_files_failed(err)
         elif mode == "truncate_files":
-            self.window.controller.remote_store.openai.batch.handle_truncated_files_failed(err)
+            batch.handle_truncated_files_failed(err)
         elif mode == "upload_files":
-            self.window.controller.remote_store.openai.batch.handle_uploaded_files_failed(err)
+            batch.handle_uploaded_files_failed(err)
         elif mode in "vector_stores":
-            self.window.controller.remote_store.openai.batch.handle_imported_stores_failed(err)
+            batch.handle_imported_stores_failed(err)
         elif mode in "truncate_vector_stores":
-            self.window.controller.remote_store.openai.batch.handle_truncated_stores_failed(err)
+            batch.handle_truncated_stores_failed(err)
         elif mode in "refresh_vector_stores":
-            self.window.controller.remote_store.openai.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):
@@ -57,20 +56,19 @@ class Importer(QObject):
         :param store_id: store ID
         :param num: number of affected items
         """
-        if mode == "assistants":
-            self.window.controller.assistant.batch.handle_imported_assistants(num)
-        elif mode == "import_files":
-            self.window.controller.remote_store.openai.batch.handle_imported_files(num)
+        batch = self.window.controller.remote_store.batch
+        if mode == "import_files":
+            batch.handle_imported_files(num)
         elif mode == "truncate_files":
-            self.window.controller.remote_store.openai.batch.handle_truncated_files(store_id, num)
+            batch.handle_truncated_files(store_id, num)
         elif mode == "upload_files":
-            self.window.controller.remote_store.openai.batch.handle_uploaded_files(num)
+            batch.handle_uploaded_files(num)
         elif mode == "vector_stores":
-            self.window.controller.remote_store.openai.batch.handle_imported_stores(num)
+            batch.handle_imported_stores(num)
         elif mode == "truncate_vector_stores":
-            self.window.controller.remote_store.openai.batch.handle_truncated_stores(num)
+            batch.handle_truncated_stores(num)
         elif mode == "refresh_vector_stores":
-            self.window.controller.remote_store.openai.batch.handle_refreshed_stores(num)
+            batch.handle_refreshed_stores(num)
 
     @Slot(str, str)
     def handle_status(self, mode: str, msg: str):
@@ -92,14 +90,6 @@ class Importer(QObject):
         """
         self.window.controller.assistant.threads.log(mode + ": " + msg)
 
-    def import_assistants(self):
-        """Import assistants"""
-        self.worker = ImportWorker()
-        self.worker.window = self.window
-        self.worker.mode = "assistants"
-        self.connect_signals(self.worker)
-        self.window.threadpool.start(self.worker)
-
     def import_vector_stores(self):
         """Import vector stores"""
         self.worker = ImportWorker()
@@ -203,9 +193,7 @@ class ImportWorker(QRunnable):
         """Importer thread"""
         try:
             # import data
-            if self.mode == "assistants":
-                self.import_assistants()
-            elif self.mode == "vector_stores":
+            if self.mode == "vector_stores":
                 if self.import_vector_stores():
                     self.import_files()
             elif self.mode == "truncate_vector_stores":
@@ -225,36 +213,6 @@ class ImportWorker(QRunnable):
         finally:
             self.cleanup()
 
-    def import_assistants(self, silent: bool = False) -> bool:
-        """
-        Import assistants from API
-
-        :param silent: silent mode (no signals)
-        :return: result
-        """
-        try:
-            # import assistants
-            self.log("Importing assistants...")
-            self.window.core.assistants.clear()
-            items = self.window.core.assistants.get_all()
-            self.window.core.api.openai.assistants.import_all(items, callback=self.callback)
-            self.window.core.assistants.items = items
-            self.window.core.assistants.save()
-
-            # import vector stores
-            self.import_vector_stores(True)
-
-            # import files
-            self.import_files(True)
-
-            if not silent:
-                self.signals.finished.emit("assistants", self.store_id, len(items))
-            return True
-        except Exception as e:
-            self.log("API error: {}".format(e))
-            self.signals.error.emit("assistants", e)
-            return False
-
     def import_vector_stores(self, silent: bool = False) -> bool:
         """
         Import vector stores from API
@@ -310,7 +268,7 @@ class ImportWorker(QRunnable):
             for id in stores:
                 store = stores[id]
                 try:
-                    self.window.controller.remote_store.openai.refresh_store(store, update=False)
+                    self.window.controller.remote_store.refresh_store(store, update=False, provider="openai")
                     num += 1
                 except Exception as e:
                     self.log("Failed to refresh store: {}".format(id))

pygpt_net/provider/api/openai/worker/importer_assistants.py

@@ -0,0 +1,230 @@
+#!/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
+
+        :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):
+        """
+        Handle thread error signal
+
+        :param mode: mode
+        :param err: error message
+        """
+        batch = self.window.controller.remote_store.batch
+        if mode == "assistants":
+            self.window.controller.assistant.batch.handle_imported_assistants_failed(err)
+
+    @Slot(str, str, int)
+    def handle_finished(self, mode: str, store_id: str = None, num: int = 0):
+        """
+        Handle thread finished signal
+
+        :param mode: mode
+        :param store_id: store ID
+        :param num: number of affected items
+        """
+        batch = self.window.controller.remote_store.batch
+        if mode == "assistants":
+            self.window.controller.assistant.batch.handle_imported_assistants(num)
+
+    @Slot(str, str)
+    def handle_status(self, mode: str, msg: str):
+        """
+        Handle thread status change signal
+
+        :param mode: mode
+        :param msg: message
+        """
+        self.window.controller.assistant.batch.handle_status_change(mode, msg)
+
+    @Slot(str, str)
+    def handle_log(self, mode: str, msg: str):
+        """
+        Handle thread log message signal
+
+        :param mode: mode
+        :param msg: message
+        """
+        self.window.controller.assistant.threads.log(mode + ": " + msg)
+
+    def import_assistants(self):
+        """Import assistants"""
+        self.worker = ImportWorker()
+        self.worker.window = self.window
+        self.worker.mode = "assistants"
+        self.connect_signals(self.worker)
+        self.window.threadpool.start(self.worker)
+
+    def connect_signals(self, worker):
+        """
+        Connect signals
+
+        :param worker: worker instance
+        """
+        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):
+    """Import worker signals"""
+    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"""
+    def __init__(self, *args, **kwargs):
+        super().__init__()
+        self.signals = ImportWorkerSignals()
+        self.window = None
+        self.mode = "assistants"
+        self.assistant = None
+        self.store_id = None
+        self.files = []
+
+    @Slot()
+    def run(self):
+        """Importer thread"""
+        try:
+            # import data
+            if self.mode == "assistants":
+                self.import_assistants()
+
+        except Exception as e:
+            self.signals.error.emit(self.mode, e)
+
+        finally:
+            self.cleanup()
+
+    def import_assistants(self, silent: bool = False) -> bool:
+        """
+        Import assistants from API
+
+        :param silent: silent mode (no signals)
+        :return: result
+        """
+        try:
+            # import assistants
+            self.log("Importing assistants...")
+            self.window.core.assistants.clear()
+            items = self.window.core.assistants.get_all()
+            self.window.core.api.openai.assistants.import_all(items, callback=self.callback)
+            self.window.core.assistants.items = items
+            self.window.core.assistants.save()
+
+            # import vector stores
+            self.import_vector_stores(True)
+
+            # import files
+            self.import_files(True)
+
+            if not silent:
+                self.signals.finished.emit("assistants", self.store_id, len(items))
+            return True
+        except Exception as e:
+            self.log("API error: {}".format(e))
+            self.signals.error.emit("assistants", e)
+            return False
+
+    def import_vector_stores(self, silent: bool = False) -> bool:
+        """
+        Import vector stores from API
+
+        :param silent: silent mode (no signals emit)
+        :return: result
+        """
+        try:
+            self.log("Importing vector stores...")
+            self.window.core.remote_store.openai.clear()
+            items = {}
+            self.window.core.api.openai.store.import_stores(items, callback=self.callback)
+            self.window.core.remote_store.openai.import_items(items)
+            if not silent:
+                self.signals.finished.emit("vector_stores", self.store_id, len(items))
+            return True
+        except Exception as e:
+            self.log("API error: {}".format(e))
+            self.signals.error.emit("vector_stores", e)
+            return False
+
+    def import_files(self, silent: bool = False) -> bool:
+        """
+        Import assistant files from API
+
+        :param silent: silent mode (no signals emit)
+        :return: result
+        """
+        try:
+            if self.store_id is None:
+                self.log("Importing all files...")
+                self.window.core.remote_store.openai.files.truncate_local()  # clear local DB (all)
+                num = self.window.core.api.openai.store.import_stores_files(self.callback)  # import all files
+            else:
+                self.log("Importing files for store: {}".format(self.store_id))
+                self.window.core.remote_store.openai.files.truncate_local(self.store_id)  # clear local DB (all)
+                items = self.window.core.api.openai.store.import_store_files(
+                    self.store_id,
+                    [],
+                    callback=self.callback,
+                )  # import store files
+                num = len(items)
+            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):
+        """
+        Log callback
+
+        :param msg: message
+        """
+        self.log(msg)
+
+    def log(self, msg: str):
+        """
+        Log message
+
+        :param msg: message
+        """
+        self.signals.log.emit(self.mode, msg)
+
+    def cleanup(self):
+        """Cleanup resources after worker execution."""
+        sig = self.signals
+        self.signals = None
+        if sig is not None:
+            try:
+                sig.deleteLater()
+            except RuntimeError:
+                pass

pygpt_net/provider/api/x_ai/__init__.py

@@ -6,7 +6,7 @@
 # GitHub:  https://github.com/szczyglis-dev/py-gpt   #
 # MIT License                                        #
 # Created By  : Marcin Szczygliński                  #
-# Updated Date: 2026.01.04 19:00:00                  #
+# Updated Date: 2026.01.06 20:00:00                  #
 # ================================================== #
 
 from typing import Optional, Dict, Any
@@ -35,6 +35,8 @@ from .audio import Audio
 from .image import Image
 from .remote_tools import Remote
 from .responses import Responses
+from .store import Store
+from .realtime import Realtime
 
 
 class ApiXAI:
@@ -52,6 +54,8 @@ class ApiXAI:
         self.image = Image(window)
         self.remote = Remote(window)
         self.responses = Responses(window)
+        self.store = Store(window)
+        self.realtime = Realtime(window)
         self.client: Optional[xai_sdk.Client] = None
         self.locked = False
         self.last_client_args: Optional[Dict[str, Any]] = None
@@ -59,7 +63,8 @@ class ApiXAI:
     def get_client(
             self,
             mode: str = MODE_CHAT,
-            model: ModelItem = None
+            model: ModelItem = None,
+            management_api_key = None
     ) -> xai_sdk.Client:
         """
         Get or create xAI client.
@@ -69,11 +74,9 @@ class ApiXAI:
 
         :param mode: One of MODE_*
         :param model: ModelItem (optional, not used currently)
+        :param management_api_key: Override API key (for management calls)
         :return: xai_sdk.Client
         """
-        if self.client is not None:
-            return self.client
-
         cfg = self.window.core.config
         api_key = cfg.get("api_key_xai") or os.environ.get("XAI_API_KEY") or ""
         timeout = cfg.get("api_native_xai.timeout")  # optional
@@ -90,7 +93,13 @@ class ApiXAI:
         if proxy:
             kwargs["channel_options"] = []
             kwargs["channel_options"].append(("grpc.http_proxy", proxy))
+        if management_api_key:
+            kwargs["management_api_key"] = management_api_key
+
+        if self.client is not None and self.last_client_args == kwargs:
+            return self.client
 
+        self.last_client_args = kwargs
         self.client = xai_sdk.Client(**kwargs)
         return self.client
 
@@ -129,8 +138,23 @@ class ApiXAI:
                 MODE_COMPLETION,
                 MODE_CHAT,
                 MODE_AUDIO,
-                MODE_RESEARCH
+                MODE_RESEARCH,
+                MODE_AUDIO
         ):
+            if mode == MODE_AUDIO:
+                raise NotImplementedError("Not available. xAI realtime audio streaming coming soon!")
+
+            if mode == MODE_AUDIO and stream:
+                # Realtime API for audio streaming
+                is_realtime = self.realtime.begin(
+                    context=context,
+                    model=model,
+                    extra=extra or {},
+                    rt_signals=rt_signals
+                )
+                if is_realtime:
+                    return True
+
             # Audio TTS is not exposed via public SDK; treat MODE_AUDIO as chat input.
             # NOTE: for grok-3 use Chat completions, for > grok-4 use Chat responses
             if use_responses_api:

pygpt_net/provider/api/x_ai/audio.py

@@ -6,27 +6,59 @@
 # GitHub:  https://github.com/szczyglis-dev/py-gpt   #
 # MIT License                                        #
 # Created By  : Marcin Szczygliński                  #
-# Updated Date: 2025.09.05 01:00:00                  #
+# Updated Date: 2026.01.06 20:00:00                  #
 # ================================================== #
 
-from typing import Tuple
+import base64
+from typing import Optional, Union, List, Dict, Any
+
+from pygpt_net.core.bridge.context import MultimodalContext
 
 
 class Audio:
     def __init__(self, window=None):
         """
-        Audio helpers for xAI.
-
-        Note: As of now, the public xAI Python SDK does not expose TTS/STT or realtime audio APIs.
-        This class exists to keep provider surface compatible.
+        Audio input wrapper
 
         :param window: Window instance
         """
         self.window = window
 
-    # Placeholders to keep interface parity
-    def build_part(self, multimodal_ctx) -> None:
-        return None
+    def build_content(
+            self,
+            content: Optional[Union[str, list]] = None,
+            multimodal_ctx: Optional[MultimodalContext] = None,
+    ) -> List[Dict[str, Any]]:
+        """
+        Build audio content from multimodal context
+
+        :param content: previous content or input prompt
+        :param multimodal_ctx: multimodal context
+        :return: List of contents
+        """
+        if not isinstance(content, list):
+            if content:
+                content = [
+                    {
+                        "type": "text",
+                        "text": str(content),
+                    }
+                ]
+            else:
+                content = []  # if empty input return empty list
+
+        # abort if no audio input provided
+        if not multimodal_ctx.is_audio_input:
+            return content
 
-    def extract_first_audio_part(self, response) -> Tuple[None, None]:
-        return None, None
+        encoded = base64.b64encode(multimodal_ctx.audio_data).decode('utf-8')
+        audio_format = multimodal_ctx.audio_format  # wav by default
+        audio_data = {
+            "type": "input_audio",
+            "input_audio": {
+                "data": encoded,
+                "format": audio_format,
+            }
+        }
+        content.append(audio_data)
+        return content

pygpt_net/provider/api/x_ai/chat.py

@@ -6,7 +6,7 @@
 # GitHub:  https://github.com/szczyglis-dev/py-gpt   #
 # MIT License                                        #
 # Created By  : Marcin Szczygliński                  #
-# Updated Date: 2026.01.03 17:00:00                  #
+# Updated Date: 2026.01.05 20:00:00                  #
 # ================================================== #
 
 from __future__ import annotations
@@ -34,7 +34,6 @@ class Chat:
         """
         self.window = window
         self.input_tokens = 0
-        # Image constraints (can be overridden by config keys below)
         self.allowed_mimes = {"image/jpeg", "image/png"}
         self.default_image_max_bytes = 10 * 1024 * 1024  # 10 MiB default
 
@@ -319,6 +318,12 @@ class Chat:
         except Exception:
             pass
 
+        try:
+            # Attempt to auto-download file parts or references (file id)
+            self._maybe_download_files_from_response(response, ctx)
+        except Exception:
+            pass
+
         # Usage
         try:
             if isinstance(response, dict) and response.get("usage"):
@@ -1089,7 +1094,7 @@ class Chat:
 
     def _collect_images_from_message_parts(self, parts: List[dict], ctx: CtxItem):
         """
-        Inspect assistant message parts for image_url outputs and store them.
+        Inspect assistant message parts for image_url outputs and URLs.
         For http(s) URLs -> add to ctx.urls; for data URLs -> save to file and add to ctx.images.
         """
         try:
@@ -1098,6 +1103,25 @@ class Chat:
             for p in parts:
                 if not isinstance(p, dict):
                     continue
+                if p.get("type") == "file":
+                    file_id = p.get("id") or p.get("file_id")
+                    if isinstance(file_id, str):
+                        try:
+                            save = self.window.core.api.xai.store.download_to_dir(file_id)
+                            if save:
+                                if not isinstance(ctx.files, list):
+                                    ctx.files = []
+                                if save not in ctx.files:
+                                    ctx.files.append(save)
+                                ext = os.path.splitext(save)[1].lower().lstrip(".")
+                                if ext in ["png", "jpg", "jpeg", "gif", "bmp", "tiff", "webp"]:
+                                    if not isinstance(ctx.images, list):
+                                        ctx.images = []
+                                    if save not in ctx.images:
+                                        ctx.images.append(save)
+                        except Exception:
+                            pass
+                    continue
                 if p.get("type") != "image_url":
                     continue
                 img = p.get("image_url") or {}
@@ -1135,4 +1159,68 @@ class Chat:
         """
         Return the locally estimated input tokens count.
         """
-        return self.input_tokens
+        return self.input_tokens
+
+    def _maybe_download_files_from_response(self, response, ctx: CtxItem) -> None:
+        """
+        Attempt to download any files referenced by id in response payloads (dict/SDK/proto).
+        """
+        def _walk(o, acc: set):
+            if o is None:
+                return
+            if isinstance(o, dict):
+                fid = o.get("file_id") or o.get("id") if o.get("type") == "file" else None
+                if isinstance(fid, str) and fid.startswith("file-"):
+                    acc.add(fid)
+                for v in o.values():
+                    _walk(v, acc)
+            elif isinstance(o, (list, tuple)):
+                for it in o:
+                    _walk(it, acc)
+
+        ids = set()
+        try:
+            if isinstance(response, dict):
+                _walk(response, ids)
+            else:
+                msg = getattr(response, "message", None) or getattr(response, "output_message", None)
+                if msg:
+                    _walk(getattr(msg, "content", None), ids)
+                proto = getattr(response, "proto", None)
+                if proto:
+                    ch = getattr(proto, "choices", None) or []
+                    if ch:
+                        m = getattr(ch[0], "message", None)
+                        if m:
+                            _walk(getattr(m, "content", None), ids)
+        except Exception:
+            pass
+
+        if not ids:
+            return
+        saved = []
+        for fid in ids:
+            try:
+                p = self.window.core.api.xai.store.download_to_dir(fid)
+                if p:
+                    saved.append(p)
+            except Exception:
+                continue
+        if saved:
+            saved = self.window.core.filesystem.make_local_list(saved)
+            if not isinstance(ctx.files, list):
+                ctx.files = []
+            for p in saved:
+                if p not in ctx.files:
+                    ctx.files.append(p)
+            imgs = []
+            for p in saved:
+                ext = os.path.splitext(p)[1].lower().lstrip(".")
+                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)

pygpt_net/provider/api/x_ai/realtime/__init__.py

@@ -0,0 +1,12 @@
+#!/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: 2025.08.31 23:00:00                  #
+# ================================================== #
+
+from .realtime import Realtime