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

pygpt_net/provider/api/openai/image.py

@@ -6,13 +6,13 @@
 # GitHub:  https://github.com/szczyglis-dev/py-gpt   #
 # MIT License                                        #
 # Created By  : Marcin Szczygliński                  #
-# Updated Date: 2025.08.11 14:00:00                  #
+# Updated Date: 2025.12.31 16:00:00                  #
 # ================================================== #
 
 import base64
 import datetime
 import os
-from typing import Optional, Dict, Any
+from typing import Optional, Dict, Any, List
 
 import requests
 
@@ -51,12 +51,15 @@ class Image:
         :param extra: Extra arguments
         :param sync: Synchronous mode
         """
+        extra = extra or {}
         prompt = context.prompt
         ctx = context.ctx
         model = context.model
         num = extra.get("num", 1)
         inline = extra.get("inline", False)
         sub_mode = self.MODE_GENERATE
+        image_id = extra.get("image_id")  # previous image reference for remix
+        extra_prompt = extra.get("extra_prompt", "")
 
         # if attachments then switch mode to EDIT
         attachments = context.attachments
@@ -72,27 +75,29 @@ class Image:
             prompt_model = self.window.core.models.get(tmp_model)
 
         # worker
-        self.worker = ImageWorker()
-        self.worker.window = self.window
-        self.worker.client = self.window.core.api.openai.get_client()
-        self.worker.ctx = ctx
-        self.worker.mode = sub_mode  # mode can be "generate" or "edit"
-        self.worker.attachments = attachments  # attachments for edit mode
-        self.worker.raw = self.window.core.config.get('img_raw')
-        self.worker.model = model.id  # model ID for generate image, e.g. "dall-e-3"
-        self.worker.model_prompt = prompt_model  # model for generate prompt, not image!
-        self.worker.input_prompt = prompt
-        self.worker.system_prompt = self.window.core.prompt.get('img')
-        self.worker.num = num
-        self.worker.inline = inline
+        worker = ImageWorker()
+        worker.window = self.window
+        worker.client = self.window.core.api.openai.get_client()
+        worker.ctx = ctx
+        worker.mode = sub_mode  # mode can be "generate" or "edit"
+        worker.attachments = attachments  # attachments for edit mode
+        worker.raw = self.window.core.config.get('img_raw')
+        worker.model = model.id  # model ID for generate image, e.g. "dall-e-3"
+        worker.model_prompt = prompt_model  # model for generate prompt, not image!
+        worker.input_prompt = prompt
+        worker.system_prompt = self.window.core.prompt.get('img')
+        worker.num = num
+        worker.inline = inline
+        worker.extra_prompt = extra_prompt
+        worker.image_id = image_id  # remix: previous image path/identifier
 
         # config
         if self.window.core.config.has('img_quality'):
-            self.worker.quality = self.window.core.config.get('img_quality')
+            worker.quality = self.window.core.config.get('img_quality')
         if self.window.core.config.has('img_resolution'):
-            self.worker.resolution = self.window.core.config.get('img_resolution')
+            worker.resolution = self.window.core.config.get('img_resolution')
 
-        # signals
+        self.worker = worker
         self.worker.signals.finished.connect(self.window.core.image.handle_finished)
         self.worker.signals.finished_inline.connect(self.window.core.image.handle_finished_inline)
         self.worker.signals.status.connect(self.window.core.image.handle_status)
@@ -131,22 +136,25 @@ class ImageWorker(QRunnable):
         self.kwargs = kwargs
         self.window = None
         self.client = None
-        self.ctx = None
+        self.ctx: Optional[CtxItem] = None
         self.raw = False
         self.mode = Image.MODE_GENERATE  # default mode is generate
         self.model = "dall-e-3"
         self.quality = "standard"
         self.resolution = "1792x1024"
-        self.attachments = {}  # attachments for edit mode
+        self.attachments: Dict[str, Any] = {}  # attachments for edit mode
         self.model_prompt = None
-        self.input_prompt = None
+        self.input_prompt: Optional[str] = None
         self.system_prompt = None
         self.inline = False
+        self.extra_prompt: Optional[str] = None
         self.num = 1
+        self.image_id: Optional[str] = None  # previous image reference for remix
+
+        # legacy maps kept for backwards compatibility (dall-e-2 / dall-e-3 exact ids)
         self.allowed_max_num = {
             "dall-e-2": 4,
             "dall-e-3": 1,
-            "gpt-image-1": 1,
         }
         self.allowed_resolutions = {
             "dall-e-2": [
@@ -159,29 +167,60 @@ class ImageWorker(QRunnable):
                 "1024x1792",
                 "1024x1024",
             ],
-            "gpt-image-1": [
-                "1536x1024",
-                "1024x1536",
-                "1024x1024",
-                "auto",
-            ],
         }
         self.allowed_quality = {
-            "dall-e-2": [
-                "standard",
-            ],
-            "dall-e-3": [
-                "standard",
-                "hd",
-            ],
-            "gpt-image-1": [
-                "auto",
-                "high",
-                "medium",
-                "low",
-            ],
+            "dall-e-2": ["standard"],
+            "dall-e-3": ["standard", "hd"],
         }
 
+    # ---------- model helpers ----------
+
+    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")
+
+    def _is_dalle2(self, model_id: Optional[str] = None) -> bool:
+        mid = (model_id or self.model or "").lower()
+        return mid == "dall-e-2"
+
+    def _is_dalle3(self, model_id: Optional[str] = None) -> bool:
+        mid = (model_id or self.model or "").lower()
+        return mid == "dall-e-3"
+
+    def _max_num_for_model(self) -> int:
+        if self._is_gpt_image_model():
+            return 1
+        if self._is_dalle2():
+            return self.allowed_max_num["dall-e-2"]
+        if self._is_dalle3():
+            return self.allowed_max_num["dall-e-3"]
+        return 1
+
+    def _normalize_resolution_for_model(self, resolution: Optional[str]) -> str:
+        res = (resolution or "").strip() or "1024x1024"
+        if self._is_gpt_image_model():
+            allowed = {"1024x1024", "1536x1024", "1024x1536", "auto"}
+            return res if res in allowed else "auto"
+        if self._is_dalle2():
+            allowed = set(self.allowed_resolutions["dall-e-2"])
+            return res if res in allowed else "1024x1024"
+        if self._is_dalle3():
+            allowed = set(self.allowed_resolutions["dall-e-3"])
+            return res if res in allowed else "1024x1024"
+        return res
+
+    def _normalize_quality_for_model(self, quality: Optional[str]) -> Optional[str]:
+        q = (quality or "").strip().lower()
+        if self._is_gpt_image_model():
+            allowed = {"auto", "high", "medium", "low"}
+            return q if q in allowed else "auto"
+        if self._is_dalle2():
+            return "standard"
+        if self._is_dalle3():
+            allowed = {"standard", "hd"}
+            return q if q in allowed else "standard"
+        return None
+
     @Slot()
     def run(self):
         """Run worker"""
@@ -209,55 +248,102 @@ class ImageWorker(QRunnable):
                 self.signals.error.emit(e)
                 self.signals.status.emit(trans('img.status.prompt.error') + ": " + str(e))
 
+        # Fallback negative prompt injection (OpenAI Images API has no native negative_prompt field)
+        if self.extra_prompt and str(self.extra_prompt).strip():
+            try:
+                self.input_prompt = self._merge_negative_prompt(self.input_prompt or "", self.extra_prompt)
+            except Exception:
+                pass
+
         self.signals.status.emit(trans('img.status.generating') + ": {}...".format(self.input_prompt))
 
-        paths = []  # downloaded images paths
+        paths: List[str] = []  # downloaded images paths
         try:
-            # check if number of images is supported
-            if self.model in self.allowed_max_num:
-                if self.num > self.allowed_max_num[self.model]:
-                    self.num = self.allowed_max_num[self.model]
-
-            # check if resolution is supported
-            resolution = self.resolution
-            if self.model in self.allowed_resolutions:
-                if resolution not in self.allowed_resolutions[self.model]:
-                    resolution = self.allowed_resolutions[self.model][0]
-
-            quality = self.quality
-            if self.model in self.allowed_quality:
-                if quality not in self.allowed_quality[self.model]:
-                    quality = self.allowed_quality[self.model][0]
-
-            # send to API
+            # enforce model-specific limits/options
+            self.num = min(max(1, int(self.num or 1)), self._max_num_for_model())
+            resolution = self._normalize_resolution_for_model(self.resolution)
+            quality = self._normalize_quality_for_model(self.quality)
+
             response = None
-            if self.mode == Image.MODE_GENERATE:
-                if self.model == "dall-e-2":
-                    response = self.client.images.generate(
-                        model=self.model,
-                        prompt=self.input_prompt,
-                        n=self.num,
-                        size=resolution,
-                    )
-                elif self.model == "dall-e-3" or self.model == "gpt-image-1":
-                    response = self.client.images.generate(
-                        model=self.model,
-                        prompt=self.input_prompt,
-                        n=self.num,
-                        quality=quality,
-                        size=resolution,
-                    )
-            elif self.mode == Image.MODE_EDIT:
-                images = []
-                for uuid in self.attachments:
-                    attachment = self.attachments[uuid]
-                    if attachment.path and os.path.exists(attachment.path):
-                        images.append(open(attachment.path, "rb"))
-                response = self.client.images.edit(
-                    model=self.model,
-                    image=images,
-                    prompt=self.input_prompt,
-                )
+
+            # Remix path: if image_id provided, prefer editing with previous image reference
+            if self.image_id:
+                if self._is_dalle3():
+                    try:
+                        self.signals.status.emit("Remix is not supported for this model; generating a new image.")
+                    except Exception:
+                        pass
+                else:
+                    remix_images = []
+                    try:
+                        if isinstance(self.image_id, str) and os.path.exists(self.image_id):
+                            remix_images.append(open(self.image_id, "rb"))
+                    except Exception:
+                        remix_images = []
+
+                    if len(remix_images) > 0:
+                        try:
+                            edit_kwargs = {
+                                "model": self.model,
+                                "image": remix_images,
+                                "prompt": self.input_prompt,
+                                "n": self.num,
+                                "size": resolution,
+                            }
+                            if self._is_gpt_image_model() or self._is_dalle3():
+                                if quality:
+                                    edit_kwargs["quality"] = quality
+                            response = self.client.images.edit(**edit_kwargs)
+                        finally:
+                            for f in remix_images:
+                                try:
+                                    f.close()
+                                except Exception:
+                                    pass
+
+            # Normal API paths when remix not executed or unsupported
+            if response is None:
+                if self.mode == Image.MODE_GENERATE:
+                    if self._is_dalle2():
+                        response = self.client.images.generate(
+                            model=self.model,
+                            prompt=self.input_prompt,
+                            n=self.num,
+                            size=resolution,
+                        )
+                    else:
+                        gen_kwargs = {
+                            "model": self.model,
+                            "prompt": self.input_prompt,
+                            "n": self.num,
+                            "size": resolution,
+                        }
+                        if (self._is_gpt_image_model() or self._is_dalle3()) and quality:
+                            gen_kwargs["quality"] = quality
+                        response = self.client.images.generate(**gen_kwargs)
+                elif self.mode == Image.MODE_EDIT:
+                    images = []
+                    for uuid in self.attachments or {}:
+                        attachment = self.attachments[uuid]
+                        if attachment.path and os.path.exists(attachment.path):
+                            images.append(open(attachment.path, "rb"))
+                    try:
+                        edit_kwargs = {
+                            "model": self.model,
+                            "image": images,
+                            "prompt": self.input_prompt,
+                            "n": self.num,
+                            "size": resolution,
+                        }
+                        if (self._is_gpt_image_model() or self._is_dalle3()) and quality:
+                            edit_kwargs["quality"] = quality
+                        response = self.client.images.edit(**edit_kwargs)
+                    finally:
+                        for f in images:
+                            try:
+                                f.close()
+                            except Exception:
+                                pass
 
             # check response
             if response is None:
@@ -278,14 +364,13 @@ class ImageWorker(QRunnable):
                 msg = trans('img.status.downloading') + " (" + str(i + 1) + " / " + str(self.num) + ") -> " + str(path)
                 self.signals.status.emit(msg)
 
-                if response.data[i] is None:
-                    self.signals.error.emit("API Error: empty image data")
-                    return
-                if response.data[i].url:  # dall-e 2 and 3 returns URL
-                    res = requests.get(response.data[i].url)
+                item = response.data[i]
+                data = None
+                if getattr(item, "url", None):
+                    res = requests.get(item.url)
                     data = res.content
-                else:  # gpt-image-1 returns base64 encoded image
-                    data = base64.b64decode(response.data[i].b64_json)
+                elif getattr(item, "b64_json", None):
+                    data = base64.b64decode(item.b64_json)
 
                 # save image
                 if data and self.window.core.image.save_image(path, data):
@@ -293,6 +378,16 @@ class ImageWorker(QRunnable):
                 else:
                     self.signals.error.emit("Error saving image")
 
+            # store image_id for future remix (use first saved path as reference)
+            if paths:
+                try:
+                    if not isinstance(self.ctx.extra, dict):
+                        self.ctx.extra = {}
+                    self.ctx.extra["image_id"] = paths[0]
+                    self.window.core.ctx.update_item(self.ctx)
+                except Exception:
+                    pass
+
             # send finished signal
             if self.inline:
                 self.signals.finished_inline.emit(  # separated signal for inline mode
@@ -323,3 +418,16 @@ class ImageWorker(QRunnable):
                 sig.deleteLater()
             except RuntimeError:
                 pass
+
+    # ---------- prompt utilities ----------
+
+    @staticmethod
+    def _merge_negative_prompt(prompt: str, negative: Optional[str]) -> str:
+        """
+        Append a negative prompt to the main text prompt for providers without a native negative_prompt field.
+        """
+        base = (prompt or "").strip()
+        neg = (negative or "").strip()
+        if not neg:
+            return base
+        return (base + ("\n" if base else "") + f"Negative prompt: {neg}").strip()

pygpt_net/provider/api/openai/video.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 12:00:00                  #
+# Updated Date: 2025.12.31 16:00:00                  #
 # ================================================== #
 
 import datetime
@@ -59,6 +59,8 @@ class Video:
         prompt = context.prompt
         num = int(extra.get("num", 1))
         inline = bool(extra.get("inline", False))
+        video_id = extra.get("video_id")
+        extra_prompt = extra.get("extra_prompt", "")
 
         # decide sub-mode based on attachments (image-to-video when image is attached)
         sub_mode = self.MODE_GENERATE
@@ -85,6 +87,8 @@ class Video:
         worker.raw = self.window.core.config.get('img_raw')
         worker.num = num
         worker.inline = inline
+        worker.extra_prompt = extra_prompt
+        worker.video_id = video_id
 
         # optional params (app-level options)
         worker.aspect_ratio = str(extra.get("aspect_ratio") or self.window.core.config.get('video.aspect_ratio') or "16:9")
@@ -155,6 +159,8 @@ class VideoWorker(QRunnable):
         self.input_prompt = ""
         self.system_prompt = ""
         self.inline = False
+        self.extra_prompt: Optional[str] = None
+        self.video_id = None
         self.raw = False
         self.num = 1
 
@@ -169,6 +175,7 @@ class VideoWorker(QRunnable):
     @Slot()
     def run(self):
         try:
+            kernel = self.window.controller.kernel
             # Optional prompt enhancement via app default LLM
             if not self.raw and not self.inline and self.input_prompt:
                 try:
@@ -189,6 +196,14 @@ class VideoWorker(QRunnable):
                     self.signals.error.emit(e)
                     self.signals.status.emit(trans('vid.status.prompt.error') + ": " + str(e))
 
+            # Negative prompt fallback: inject constraints into the text prompt (Sora has no native negative_prompt field)
+            if self.extra_prompt and str(self.extra_prompt).strip():
+                try:
+                    self.input_prompt = self._merge_negative_prompt(self.input_prompt, self.extra_prompt)
+                except Exception:
+                    # do not fail generation if merge fails
+                    pass
+
             # Sora API accepts a single video per create call; honor app's num but cap to 1 per job
             _ = max(1, min(self.num, self.max_per_job))
 
@@ -199,42 +214,88 @@ class VideoWorker(QRunnable):
             # Image-to-video: first image attachment as input_reference, must match "size"
             image_path = self._first_image_attachment(self.attachments) if self.mode == Video.MODE_IMAGE_TO_VIDEO else None
 
-            self.signals.status.emit(trans('vid.status.generating') + f": {self.input_prompt}...")
+            # If remix requested, ignore any image input_reference
+            is_remix = bool(self.video_id)
+            if is_remix:
+                image_path = None  # enforce remix over image-to-video
+
+            label = trans('vid.status.generating')
+            if is_remix:
+                label += " (remix)"
+            self.signals.status.emit(label + f": {self.input_prompt}...")
 
             # Create job
-            create_kwargs: Dict[str, Any] = {
-                "model": self.model or "sora-2",
-                "prompt": self.input_prompt or "",
-                "seconds": str(seconds),
-                "size": size,
-            }
-
-            # Attach image as input_reference; auto-resize to match requested size if needed
+            job = None
             file_handle = None
-            if image_path:
-                prepared = self._prepare_input_reference(image_path, size)
-                if prepared is not None:
-                    # tuple (filename, bytes, mime) supported by OpenAI Python SDK
-                    create_kwargs["input_reference"] = prepared
-                else:
-                    # Fallback: use original file (may fail if size/mime mismatch)
+
+            if is_remix:
+                # Primary path: dedicated remix endpoint, inherits the original's length and size
+                last_exc = None
+                try:
+                    job = self.client.videos.remix(
+                        video_id=str(self.video_id),
+                        prompt=self.input_prompt or "",
+                    )
+                except Exception as e1:
+                    # Fallbacks for older SDKs: pass remix id via create()
+                    last_exc = e1
                     try:
-                        file_handle = open(image_path, "rb")
-                        create_kwargs["input_reference"] = file_handle
-                    except Exception as e:
-                        self.signals.error.emit(e)
+                        job = self.client.videos.create(
+                            model=self.model or "sora-2",
+                            prompt=self.input_prompt or "",
+                            remix_id=str(self.video_id),
+                        )
+                    except Exception as e2:
+                        last_exc = e2
+                        try:
+                            job = self.client.videos.create(
+                                model=self.model or "sora-2",
+                                prompt=self.input_prompt or "",
+                                remix_video_id=str(self.video_id),
+                            )
+                        except Exception as e3:
+                            last_exc = e3
+                if job is None:
+                    raise last_exc or RuntimeError("Unable to start remix job.")
+            else:
+                create_kwargs: Dict[str, Any] = {
+                    "model": self.model or "sora-2",
+                    "prompt": self.input_prompt or "",
+                    "seconds": str(seconds),
+                    "size": size,
+                }
+
+                # Attach image as input_reference; auto-resize to match requested size if needed
+                if image_path:
+                    prepared = self._prepare_input_reference(image_path, size)
+                    if prepared is not None:
+                        create_kwargs["input_reference"] = prepared
+                    else:
+                        try:
+                            file_handle = open(image_path, "rb")
+                            create_kwargs["input_reference"] = file_handle
+                        except Exception as e:
+                            self.signals.error.emit(e)
+
+                job = self.client.videos.create(**create_kwargs)
 
-            job = self.client.videos.create(**create_kwargs)
             video_id = self._safe_get(job, "id")
             if not video_id:
-                # include raw payload for debugging
                 raise RuntimeError("Video job ID missing in create response.")
 
             # Poll until completed (or failed/canceled)
+            if not isinstance(self.ctx.extra, dict):
+                self.ctx.extra = {}
+            self.ctx.extra['video_id'] = video_id  # store video_id in ctx extra
+            self.window.core.ctx.update_item(self.ctx)
             last_progress = None
             last_status = None
             while True:
+                if kernel.stopped():
+                    break
                 time.sleep(5)
+                if kernel.stopped():
+                    break
                 job = self.client.videos.retrieve(video_id)
                 status = self._safe_get(job, "status") or ""
                 progress = self._safe_get(job, "progress")
@@ -559,4 +620,18 @@ class VideoWorker(QRunnable):
             except Exception:
                 pass
 
-        return " ".join(parts).strip()
+        return " ".join(parts).strip()
+
+    # ---------- prompt utilities ----------
+
+    @staticmethod
+    def _merge_negative_prompt(prompt: str, negative: Optional[str]) -> str:
+        """
+        Append a negative prompt to the main text prompt for providers without a native negative_prompt field.
+        """
+        base = (prompt or "").strip()
+        neg = (negative or "").strip()
+        if not neg:
+            return base
+        # Keep the user's original prompt intact and add clear constraint instructions.
+        return (base + ("\n" if base else "") + f"Negative prompt: {neg}").strip()

pygpt_net/provider/api/x_ai/image.py

@@ -6,7 +6,7 @@
 # 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: 2025.12.31 16:00:00                  #
 # ================================================== #
 
 import base64
@@ -49,6 +49,7 @@ class Image:
         prompt = context.prompt
         num = int(extra.get("num", 1))
         inline = bool(extra.get("inline", False))
+        extra_prompt = extra.get("extra_prompt", "")
 
         # Optional prompt enhancement model (same as in your Google path)
         prompt_model = self.window.core.models.from_defaults()
@@ -66,6 +67,7 @@ class Image:
         worker.raw = self.window.core.config.get('img_raw')
         worker.num = num
         worker.inline = inline
+        worker.extra_prompt = extra_prompt
 
         self.worker = worker
         self.worker.signals.finished.connect(self.window.core.image.handle_finished)
@@ -102,6 +104,7 @@ class ImageWorker(QRunnable):
         self.input_prompt = ""
         self.system_prompt = ""
         self.inline = False
+        self.extra_prompt: Optional[str] = None
         self.raw = False
         self.num = 1
 
@@ -131,6 +134,13 @@ class ImageWorker(QRunnable):
                     self.signals.error.emit(e)
                     self.signals.status.emit(trans('img.status.prompt.error') + ": " + str(e))
 
+            # Negative prompt fallback: append as textual instruction (xAI has no native field for it)
+            if self.extra_prompt and str(self.extra_prompt).strip():
+                try:
+                    self.input_prompt = self._merge_negative_prompt(self.input_prompt or "", self.extra_prompt)
+                except Exception:
+                    pass
+
             self.signals.status.emit(trans('img.status.generating') + f": {self.input_prompt}...")
 
             cfg = self.window.core.config
@@ -205,4 +215,17 @@ class ImageWorker(QRunnable):
             try:
                 sig.deleteLater()
             except RuntimeError:
-                pass
+                pass
+
+    # ---------- prompt utilities ----------
+
+    @staticmethod
+    def _merge_negative_prompt(prompt: str, negative: Optional[str]) -> str:
+        """
+        Append a negative prompt to the main text prompt for providers without a native negative_prompt field.
+        """
+        base = (prompt or "").strip()
+        neg = (negative or "").strip()
+        if not neg:
+            return base
+        return (base + ("\n" if base else "") + f"Negative prompt: {neg}").strip()

pygpt_net/provider/core/config/patch.py

@@ -6,7 +6,7 @@
 # GitHub:  https://github.com/szczyglis-dev/py-gpt   #
 # MIT License                                        #
 # Created By  : Marcin Szczygliński                  #
-# Updated Date: 2025.12.27 02:00:00                  #
+# Updated Date: 2025.12.30 22:00:00                  #
 # ================================================== #
 
 import copy
@@ -207,6 +207,22 @@ class Patch:
                 patch_css('style.dark.css', True)
                 updated = True
 
+            # < 2.7.3
+            if old < parse_version("2.7.3"):
+                print("Migrating config from < 2.7.3...")
+                if "video.remix" not in data:
+                    data["video.remix"] = False
+                if "img.remix" not in data:
+                    data["img.remix"] = False
+                updated = True
+
+            # < 2.7.4
+            if old < parse_version("2.7.4"):
+                print("Migrating config from < 2.7.4...")
+                patch_css('web-chatgpt.css', True)
+                patch_css('web-blocks.css', True)
+                updated = True
+
         # update file
         migrated = False
         if updated: