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

pygpt_net/provider/api/openai/image.py

@@ -6,7 +6,7 @@
 # GitHub:  https://github.com/szczyglis-dev/py-gpt   #
 # MIT License                                        #
 # Created By  : Marcin Szczygliński                  #
-# Updated Date: 2025.12.31 16:00:00                  #
+# Updated Date: 2026.01.05 20:00:00                  #
 # ================================================== #
 
 import base64
@@ -177,7 +177,7 @@ class ImageWorker(QRunnable):
 
     def _is_gpt_image_model(self, model_id: Optional[str] = None) -> bool:
         mid = (model_id or self.model or "").lower()
-        return mid.startswith("gpt-image-1")
+        return mid.startswith("gpt-image-1") or mid.startswith("chatgpt-image")
 
     def _is_dalle2(self, model_id: Optional[str] = None) -> bool:
         mid = (model_id or self.model or "").lower()

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):
         """

pygpt_net/{controller/chat/handler/openai_stream.py → provider/api/openai/stream.py}

@@ -6,7 +6,7 @@
 # GitHub:  https://github.com/szczyglis-dev/py-gpt   #
 # MIT License                                        #
 # Created By  : Marcin Szczygliński                  #
-# Updated Date: 2025.12.26 00:00:00                  #
+# Updated Date: 2026.01.05 20:00:00                  #
 # ================================================== #
 
 import base64

pygpt_net/provider/api/openai/utils.py

@@ -6,11 +6,11 @@
 # GitHub:  https://github.com/szczyglis-dev/py-gpt   #
 # MIT License                                        #
 # Created By  : Marcin Szczygliński                  #
-# Updated Date: 2024.11.26 19:00:00                  #
+# Updated Date: 2026.01.05 20:00:00                  #
 # ================================================== #
 
 import re
-
+from typing import Optional, Any
 
 def sanitize_name(name: str) -> str:
     """
@@ -24,4 +24,70 @@ def sanitize_name(name: str) -> str:
     # allowed characters: a-z, A-Z, 0-9, _, and -
     name = name.strip().lower()
     sanitized_name = re.sub(r'[^a-z0-9_-]', '_', name)
-    return sanitized_name[:64]  # limit to 64 characters
+    return sanitized_name[:64]  # limit to 64 characters
+
+
+def capture_openai_usage(state, u_obj: Any):
+    """
+    Extract usage for OpenAI/xAI-compatible chunks.
+
+    :param state: Chat state
+    :param u_obj: Usage object/dict
+    """
+    if not u_obj:
+        return
+    state.usage_vendor = "openai"
+    in_tok = as_int(safe_get(u_obj, "input_tokens")) or as_int(safe_get(u_obj, "prompt_tokens"))
+    out_tok = as_int(safe_get(u_obj, "output_tokens")) or as_int(safe_get(u_obj, "completion_tokens"))
+    total = as_int(safe_get(u_obj, "total_tokens"))
+    reasoning = (
+        as_int(safe_get(u_obj, "output_tokens_details.reasoning_tokens")) or
+        as_int(safe_get(u_obj, "completion_tokens_details.reasoning_tokens")) or
+        as_int(safe_get(u_obj, "reasoning_tokens")) or
+        0
+    )
+    out_with_reason = (out_tok or 0) + (reasoning or 0)
+    state.usage_payload = {"in": in_tok, "out": out_with_reason, "reasoning": reasoning or 0, "total": total}
+
+def safe_get(obj: Any, path: str) -> Any:
+    """
+    Dot-path getter for dicts and objects.
+
+    :param obj: Source object or dict
+    :param path: Dot-separated path, e.g. 'a.b.0.c'
+    :return: Value at path or None
+    """
+    cur = obj
+    for seg in path.split("."):
+        if cur is None:
+            return None
+        if isinstance(cur, dict):
+            cur = cur.get(seg)
+        else:
+            if seg.isdigit() and isinstance(cur, (list, tuple)):
+                idx = int(seg)
+                if 0 <= idx < len(cur):
+                    cur = cur[idx]
+                else:
+                    return None
+            else:
+                cur = getattr(cur, seg, None)
+    return cur
+
+
+def as_int(val: Any) -> Optional[int]:
+    """
+    Coerce to int if possible, else None.
+
+    :param val: Input value
+    :return: int or None
+    """
+    if val is None:
+        return None
+    try:
+        return int(val)
+    except Exception:
+        try:
+            return int(float(val))
+        except Exception:
+            return None

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