pygpt-net 2.7.1__py3-none-any.whl → 2.7.3__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.30 22: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,14 @@ 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
 
         # if attachments then switch mode to EDIT
         attachments = context.attachments
@@ -85,6 +87,7 @@ class Image:
         self.worker.system_prompt = self.window.core.prompt.get('img')
         self.worker.num = num
         self.worker.inline = inline
+        self.worker.image_id = image_id  # remix: previous image path/identifier
 
         # config
         if self.window.core.config.has('img_quality'):
@@ -131,22 +134,24 @@ 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.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 +164,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"""
@@ -211,53 +247,93 @@ class ImageWorker(QRunnable):
 
         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 +354,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 +368,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
@@ -322,4 +407,4 @@ class ImageWorker(QRunnable):
             try:
                 sig.deleteLater()
             except RuntimeError:
-                pass
+                pass

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.30 22:00:00                  #
 # ================================================== #
 
 import datetime
@@ -59,6 +59,7 @@ class Video:
         prompt = context.prompt
         num = int(extra.get("num", 1))
         inline = bool(extra.get("inline", False))
+        video_id = extra.get("video_id")
 
         # decide sub-mode based on attachments (image-to-video when image is attached)
         sub_mode = self.MODE_GENERATE
@@ -85,6 +86,7 @@ class Video:
         worker.raw = self.window.core.config.get('img_raw')
         worker.num = num
         worker.inline = inline
+        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 +157,7 @@ class VideoWorker(QRunnable):
         self.input_prompt = ""
         self.system_prompt = ""
         self.inline = False
+        self.video_id = None
         self.raw = False
         self.num = 1
 
@@ -169,6 +172,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:
@@ -199,42 +203,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")

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
@@ -199,6 +199,23 @@ class Patch:
                 patch_css('style.dark.css', True)
                 updated = True
 
+            # < 2.7.2
+            if old < parse_version("2.7.2"):
+                print("Migrating config from < 2.7.2...")
+                # fix: combo boxes css width
+                patch_css('style.light.css', True)
+                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
+
         # update file
         migrated = False
         if updated:

pygpt_net/ui/layout/toolbox/image.py

@@ -6,13 +6,15 @@
 # GitHub:  https://github.com/szczyglis-dev/py-gpt   #
 # MIT License                                        #
 # Created By  : Marcin Szczygliński                  #
-# Updated Date: 2025.12.28 18:00:00                  #
+# Updated Date: 2025.12.30 22:00:00                  #
 # ================================================== #
 
-from PySide6.QtWidgets import QVBoxLayout, QWidget
+from PySide6.QtWidgets import QVBoxLayout, QWidget, QCheckBox, QHBoxLayout
 
 from pygpt_net.ui.widget.option.combo import OptionCombo
+from pygpt_net.ui.widget.option.input import OptionInput
 from pygpt_net.ui.widget.option.slider import OptionSlider
+from pygpt_net.utils import trans
 
 
 class Image:
@@ -33,33 +35,41 @@ class Image:
         """
         option = {
             "type": "int",
-            "slider": True,
             "label": "img_variants",
             "min": 1,
             "max": 4,
-            "step": 1,
             "value": 1,
-            "multiplier": 1,
         }
 
         ui = self.window.ui
         conf_global = ui.config['global']
 
-        container = QWidget()
+        container = QWidget(parent=self.window)
         ui.nodes['dalle.options'] = container
 
-        conf_global['img_variants'] = OptionSlider(self.window, 'global', 'img_variants', option)
+        conf_global['img_variants'] = OptionInput(self.window, 'global', 'img_variants', option)
+        conf_global['img_variants'].setToolTip(trans("toolbox.img_variants.label"))
 
         option_resolutions = self.window.core.image.get_resolution_option()
         conf_global['img_resolution'] = OptionCombo(self.window, 'global', 'img_resolution', option_resolutions)
         conf_global['img_resolution'].setMinimumWidth(160)
 
+        conf_global['img.remix'] = QCheckBox(trans("img.remix"), parent=container)
+        conf_global['img.remix'].setToolTip(trans("img.remix.tooltip"))
+        conf_global['img.remix'].toggled.connect(self.window.controller.media.toggle_remix_image)
+
+        cols = QHBoxLayout()
+        cols.addWidget(conf_global['img_resolution'], 3)
+        cols.addWidget(conf_global['img_variants'], 1)
+        cols.setContentsMargins(2, 5, 5, 5)
+
         rows = QVBoxLayout()
-        rows.addWidget(conf_global['img_variants'])
-        rows.addWidget(conf_global['img_resolution'])
+        rows.addLayout(cols)
+        rows.addWidget(conf_global['img.remix'])
         rows.setContentsMargins(2, 5, 5, 5)
 
         container.setLayout(rows)
-        container.setContentsMargins(2, 0, 0, 0)
+        container.setContentsMargins(2, 0, 0, 10)
+        container.setFixedHeight(100)
 
         return container

pygpt_net/ui/layout/toolbox/raw.py

@@ -6,7 +6,7 @@
 # GitHub:  https://github.com/szczyglis-dev/py-gpt   #
 # MIT License                                        #
 # Created By  : Marcin Szczygliński                  #
-# Updated Date: 2025.12.25 20:00:00                  #
+# Updated Date: 2025.12.30 22:00:00                  #
 # ================================================== #
 
 from PySide6.QtWidgets import QVBoxLayout, QHBoxLayout, QWidget, QCheckBox
@@ -34,7 +34,7 @@ class Raw:
         ui = self.window.ui
         conf_global = ui.config['global']
 
-        container = QWidget()
+        container = QWidget(parent=self.window)
         ui.nodes['media.raw'] = container
 
         conf_global['img_raw'] = QCheckBox(trans("img.raw"), parent=container)

pygpt_net/ui/layout/toolbox/video.py

@@ -6,13 +6,14 @@
 # GitHub:  https://github.com/szczyglis-dev/py-gpt   #
 # MIT License                                        #
 # Created By  : Marcin Szczygliński                  #
-# Updated Date: 2025.12.28 18:00:00                  #
+# Updated Date: 2025.12.30 22:00:00                  #
 # ================================================== #
 
-from PySide6.QtWidgets import QWidget, QHBoxLayout
+from PySide6.QtWidgets import QWidget, QHBoxLayout, QVBoxLayout, QCheckBox
 
 from pygpt_net.ui.widget.option.combo import OptionCombo
 from pygpt_net.ui.widget.option.input import OptionInput
+from pygpt_net.utils import trans
 
 
 class Video:
@@ -34,7 +35,7 @@ class Video:
         ui = self.window.ui
         conf_global = ui.config['global']
 
-        container = QWidget()
+        container = QWidget(parent=self.window)
         ui.nodes['video.options'] = container
 
         option_ratio = self.window.core.video.get_aspect_ratio_option()
@@ -44,18 +45,29 @@ class Video:
         conf_global['video.aspect_ratio'] = OptionCombo(self.window, 'global', 'video.aspect_ratio', option_ratio)
         conf_global['video.resolution'] = OptionCombo(self.window, 'global', 'video.resolution', option_resolution)
         conf_global['video.duration'] = OptionInput(self.window, 'global', 'video.duration', option_duration)
+        conf_global['video.duration'].setToolTip(trans('settings.video.duration.desc'))
 
         conf_global['video.aspect_ratio'].setMinimumWidth(120)
         conf_global['video.resolution'].setMinimumWidth(120)
         conf_global['video.duration'].setMinimumWidth(50)
 
-        rows = QHBoxLayout()
-        rows.addWidget(conf_global['video.resolution'], 2)
-        rows.addWidget(conf_global['video.aspect_ratio'], 2)
-        rows.addWidget(conf_global['video.duration'], 1)
-        rows.setContentsMargins(2, 5, 5, 5)
+        conf_global['video.remix'] = QCheckBox(trans("video.remix"), parent=container)
+        conf_global['video.remix'].setToolTip(trans("video.remix.tooltip"))
+        conf_global['video.remix'].toggled.connect(self.window.controller.media.toggle_remix_video)
+
+        cols = QHBoxLayout()
+        cols.addWidget(conf_global['video.resolution'], 2)
+        cols.addWidget(conf_global['video.aspect_ratio'], 2)
+        cols.addWidget(conf_global['video.duration'], 1)
+        cols.setContentsMargins(2, 5, 5, 5)
+
+        rows = QVBoxLayout()
+        rows.addLayout(cols)
+        rows.addWidget(conf_global['video.remix'])
+        rows.setContentsMargins(0, 0, 0, 0)
 
         container.setLayout(rows)
-        container.setContentsMargins(2, 0, 0, 0)
+        container.setContentsMargins(2, 0, 0, 10)
+        container.setFixedHeight(90)
 
         return container