pygpt-net 2.6.64__py3-none-any.whl → 2.6.66__py3-none-any.whl

pygpt_net/provider/api/google/__init__.py

@@ -6,7 +6,7 @@
 # GitHub:  https://github.com/szczyglis-dev/py-gpt   #
 # MIT License                                        #
 # Created By  : Marcin Szczygliński                  #
-# Updated Date: 2025.09.14 00:00:00                  #
+# Updated Date: 2025.12.25 20:00:00                  #
 # ================================================== #
 
 import os
@@ -89,7 +89,14 @@ class ApiGoogle:
             filtered["location"] = os.environ.get("GOOGLE_CLOUD_LOCATION", "us-central1")
             # filtered["http_options"] = gtypes.HttpOptions(api_version="v1")
 
-        return genai.Client(**filtered)
+        # use previous client if args are the same
+        if self.client and self.last_client_args == filtered:
+            return self.client
+
+        self.last_client_args = filtered
+        self.client = genai.Client(**filtered)
+
+        return self.client
 
     def call(
             self,
@@ -138,13 +145,17 @@ class ApiGoogle:
 
         elif mode == MODE_IMAGE:
             # Route to video / music / image based on selected model.
-            if context.model.is_video_output():
-                return self.video.generate(context=context, extra=extra)  # veo, etc.
-            # Lyria / music models
-            if self.music.is_music_model(model.id if model else ""):
-                return self.music.generate(context=context, extra=extra)   # lyria, etc.
-            # Default: image
-            return self.image.generate(context=context, extra=extra)       # imagen, etc.
+            media_mode = self.window.controller.media.get_mode()
+            if media_mode == "video":
+                if context.model.is_video_output():
+                    return self.video.generate(context=context, extra=extra)  # veo, etc.
+            elif media_mode == "music":
+                # Lyria / music models
+                if self.music.is_music_model(model.id if model else ""):
+                    return self.music.generate(context=context, extra=extra)   # lyria, etc.
+            elif media_mode == "image":
+                # Default: image
+                return self.image.generate(context=context, extra=extra)       # imagen, etc.
 
         elif mode == MODE_ASSISTANT:
             return False  # not implemented for Google

pygpt_net/provider/api/google/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.14 00:00:00                  #
+# Updated Date: 2025.12.25 20:00:00                  #
 # ================================================== #
 
 import mimetypes
@@ -39,14 +39,8 @@ class Image:
     ) -> bool:
         """
         Generate or edit image(s) using Google GenAI API (Developer API or Vertex AI).
-
-        :param context: BridgeContext with prompt, model, attachments
-        :param extra: extra parameters (num, inline)
-        :param sync: run synchronously (blocking) if True
-        :return: True if started
         """
         # Music fast-path: delegate to Music flow if a music model is selected (e.g., Lyria).
-        # This keeps image flow unchanged while enabling music in the same "image" mode.
         try:
             model_id = (context.model.id if context and context.model else "") or ""
             if self.window and hasattr(self.window.core.api.google, "music"):
@@ -65,9 +59,6 @@ class Image:
         # decide sub-mode based on attachments
         sub_mode = self.MODE_GENERATE
         attachments = context.attachments
-        if attachments and len(attachments) > 0:
-            pass # TODO: implement edit!
-            # sub_mode = self.MODE_EDIT
 
         # model used to improve the prompt (not image model)
         prompt_model = self.window.core.models.from_defaults()
@@ -89,6 +80,11 @@ class Image:
         worker.num = num
         worker.inline = inline
 
+        if attachments and len(attachments) > 0:
+            mid = str(model.id).lower()
+            if "imagen" in mid:
+                worker.mode = self.MODE_EDIT
+
         if self.window.core.config.has('img_resolution'):
             worker.resolution = self.window.core.config.get('img_resolution') or "1024x1024"
 
@@ -132,13 +128,28 @@ class ImageWorker(QRunnable):
         self.inline = False
         self.raw = False
         self.num = 1
-        self.resolution = "1024x1024"  # used to derive aspect ratio for Imagen
+        self.resolution = "1024x1024"  # used to derive aspect ratio or image_size
 
         # limits
         self.imagen_max_num = 4  # Imagen returns up to 4 images
 
         # fallbacks
-        self.DEFAULT_GEMINI_IMAGE_MODEL = "gemini-2.0-flash-preview-image-generation"
+        self.DEFAULT_GEMINI_IMAGE_MODEL = "gemini-2.5-flash-image"
+
+        # Canonical 1K dimensions for Nano Banana Pro (Gemini 3 Pro Image Preview).
+        # Used to infer 2K/4K by 2x/4x multiples and to normalize UI inputs.
+        self._NB_PRO_1K = {
+            "1024x1024",  # 1:1
+            "848x1264",   # 2:3
+            "1264x848",   # 3:2
+            "896x1200",   # 3:4
+            "1200x896",   # 4:3
+            "928x1152",   # 4:5
+            "1152x928",   # 5:4
+            "768x1376",   # 9:16
+            "1376x768",   # 16:9
+            "1584x672",   # 21:9
+        }
 
     @Slot()
     def run(self):
@@ -179,7 +190,7 @@ class ImageWorker(QRunnable):
                         if p:
                             paths.append(p)
                 else:
-                    # Developer API fallback via Gemini image model; force v1 to avoid 404
+                    # Gemini Developer API via Gemini image models (Nano Banana / Nano Banana Pro)
                     resp = self._gemini_edit(self.input_prompt, self.attachments, self.num)
                     saved = 0
                     for cand in getattr(resp, "candidates", []) or []:
@@ -208,14 +219,8 @@ class ImageWorker(QRunnable):
                         if p:
                             paths.append(p)
                 else:
-                    # Gemini Developer API image generation (needs response_modalities)
-                    resp = self.client.models.generate_content(
-                        model=self.model,
-                        contents=[self.input_prompt],
-                        config=gtypes.GenerateContentConfig(
-                            response_modalities=[gtypes.Modality.TEXT, gtypes.Modality.IMAGE],
-                        ),
-                    )
+                    # Gemini Developer API image generation (Nano Banana / Nano Banana Pro) with robust sizing + optional reference images
+                    resp = self._gemini_generate_image(self.input_prompt, self.model, self.resolution)
                     saved = 0
                     for cand in getattr(resp, "candidates", []) or []:
                         parts = getattr(getattr(cand, "content", None), "parts", None) or []
@@ -316,10 +321,114 @@ class ImageWorker(QRunnable):
             config=cfg,
         )
 
+    def _is_gemini_pro_image_model(self, model_id: str) -> bool:
+        """
+        Detect Gemini 3 Pro Image (Nano Banana Pro) by id or UI alias.
+        """
+        mid = (model_id or "").lower()
+        return mid.startswith("gemini-") or mid.startswith("nano-banana") or mid.startswith("nb-")
+
+    def _infer_nb_pro_size_for_dims(self, w: int, h: int) -> Optional[str]:
+        """
+        Infer '1K' | '2K' | '4K' for Nano Banana Pro from WxH.
+        """
+        dims = f"{w}x{h}"
+        if dims in self._NB_PRO_1K:
+            return "1K"
+        if (w % 2 == 0) and (h % 2 == 0):
+            if f"{w // 2}x{h // 2}" in self._NB_PRO_1K:
+                return "2K"
+        if (w % 4 == 0) and (h % 4 == 0):
+            if f"{w // 4}x{h // 4}" in self._NB_PRO_1K:
+                return "4K"
+        mx = max(w, h)
+        if mx >= 4000:
+            return "4K"
+        if mx >= 2000:
+            return "2K"
+        return "1K"
+
+    def _build_gemini_image_config(self, model_id: str, resolution: str) -> Optional[gtypes.ImageConfig]:
+        """
+        Build ImageConfig for Gemini image models.
+        """
+        try:
+            aspect = self._aspect_from_resolution(resolution)
+            cfg = gtypes.ImageConfig()
+            if aspect:
+                cfg.aspect_ratio = aspect
+
+            # Only Pro supports image_size; detect by id/alias and set 1K/2K/4K from WxH.
+            if self._is_gemini_pro_image_model(model_id):
+                w_str, h_str = resolution.lower().replace("×", "x").split("x")
+                w, h = int(w_str.strip()), int(h_str.strip())
+                k = self._infer_nb_pro_size_for_dims(w, h)
+                if k:
+                    cfg.image_size = k
+            return cfg
+        except Exception:
+            return None
+
+    def _attachment_image_parts(self) -> List[gtypes.Part]:
+        """
+        Build image Parts from current attachments for Gemini models.
+        """
+        parts: List[gtypes.Part] = []
+        paths = self._collect_attachment_paths(self.attachments)
+        for p in paths:
+            try:
+                mime = self._guess_mime(p)
+                if not mime or not mime.startswith("image/"):
+                    continue
+                with open(p, "rb") as f:
+                    data = f.read()
+                parts.append(gtypes.Part.from_bytes(data=data, mime_type=mime))
+            except Exception:
+                continue
+        return parts
+
+    def _gemini_generate_image(self, prompt: str, model_id: str, resolution: str):
+        """
+        Call Gemini generate_content with robust fallback for image_size.
+        Supports optional reference images uploaded as attachments.
+        """
+        cfg = self._build_gemini_image_config(model_id, resolution)
+        image_parts = self._attachment_image_parts()
+
+        def _do_call(icfg: Optional[gtypes.ImageConfig]):
+            contents: List[Any] = []
+            # Always include the textual prompt (can be empty string).
+            contents.append(prompt or "")
+            # Append reference images, if any.
+            if image_parts:
+                contents.extend(image_parts)
+            return self.client.models.generate_content(
+                model=model_id or self.DEFAULT_GEMINI_IMAGE_MODEL,
+                contents=contents,
+                config=gtypes.GenerateContentConfig(
+                    response_modalities=[gtypes.Modality.TEXT, gtypes.Modality.IMAGE],
+                    image_config=icfg,
+                ),
+            )
+
+        try:
+            return _do_call(cfg)
+        except Exception as e:
+            msg = str(e)
+            if "imageSize" in msg or "image_size" in msg or "Unrecognized" in msg or "unsupported" in msg:
+                try:
+                    if cfg and getattr(cfg, "image_size", None):
+                        cfg2 = gtypes.ImageConfig()
+                        cfg2.aspect_ratio = getattr(cfg, "aspect_ratio", None)
+                        return _do_call(cfg2)
+                except Exception:
+                    pass
+            raise
+
     def _gemini_edit(self, prompt: str, attachments: Dict[str, Any], num: int):
         """
-        Gemini image-to-image editing via generate_content (Developer/Vertex depending on client).
-        The first attachment is used as the input image.
+        Gemini image-to-image editing via generate_content.
+        The first attachment is used as the input image. Honors aspect_ratio and (for Pro) image_size.
         """
         paths = self._collect_attachment_paths(attachments)
         if len(paths) == 0:
@@ -330,10 +439,27 @@ class ImageWorker(QRunnable):
             img_bytes = f.read()
         mime = self._guess_mime(img_path)
 
-        return self.client.models.generate_content(
-            model=self.model,
-            contents=[prompt, gtypes.Part.from_bytes(data=img_bytes, mime_type=mime)],
-        )
+        cfg = self._build_gemini_image_config(self.model, self.resolution)
+
+        def _do_call(icfg: Optional[gtypes.ImageConfig]):
+            return self.client.models.generate_content(
+                model=self.model or self.DEFAULT_GEMINI_IMAGE_MODEL,
+                contents=[prompt, gtypes.Part.from_bytes(data=img_bytes, mime_type=mime)],
+                config=gtypes.GenerateContentConfig(
+                    image_config=icfg,
+                ),
+            )
+
+        try:
+            return _do_call(cfg)
+        except Exception as e:
+            msg = str(e)
+            if "imageSize" in msg or "image_size" in msg or "Unrecognized" in msg or "unsupported" in msg:
+                if cfg and getattr(cfg, "image_size", None):
+                    cfg2 = gtypes.ImageConfig()
+                    cfg2.aspect_ratio = getattr(cfg, "aspect_ratio", None)
+                    return _do_call(cfg2)
+            raise
 
     def _collect_attachment_paths(self, attachments: Dict[str, Any]) -> List[str]:
         """Extract file paths from attachments dict."""
@@ -347,7 +473,7 @@ class ImageWorker(QRunnable):
         return out
 
     def _aspect_from_resolution(self, resolution: str) -> Optional[str]:
-        """Derive aspect ratio for Imagen."""
+        """Derive aspect ratio from WxH across supported set."""
         try:
             from math import gcd
             tolerance = 0.08
@@ -357,10 +483,15 @@ class ImageWorker(QRunnable):
                 return None
             supported = {
                 "1:1": 1 / 1,
+                "2:3": 2 / 3,
+                "3:2": 3 / 2,
                 "3:4": 3 / 4,
                 "4:3": 4 / 3,
+                "4:5": 4 / 5,
+                "5:4": 5 / 4,
                 "9:16": 9 / 16,
                 "16:9": 16 / 9,
+                "21:9": 21 / 9,
             }
             g = gcd(w, h)
             key = f"{w // g}:{h // g}"
@@ -424,6 +555,8 @@ class ImageWorker(QRunnable):
             return 'image/jpeg'
         if ext == '.webp':
             return 'image/webp'
+        if ext in ('.heic', '.heif'):
+            return 'image/heic'
         return 'image/png'
 
     def _cleanup(self):

pygpt_net/provider/api/google/video.py

@@ -6,7 +6,7 @@
 # GitHub:  https://github.com/szczyglis-dev/py-gpt   #
 # MIT License                                        #
 # Created By  : Marcin Szczygliński                  #
-# Updated Date: 2025.09.01 23:00:00                  #
+# Updated Date: 2025.12.25 20:00:00                  #
 # ================================================== #
 
 import base64, datetime, os, requests
@@ -150,11 +150,10 @@ class VideoWorker(QRunnable):
         self.fps = 24
         self.seed: Optional[int] = None
         self.negative_prompt: Optional[str] = None
-        self.generate_audio: bool = False  # Veo 3 only
-        self.resolution: str = "720p"      # Veo 3 supports 720p/1080p
+        self.generate_audio: bool = False  # generation includes audio by default on Veo 3.x
+        self.resolution: str = "720p"      # Veo supports 720p/1080p depending on variant
 
         # limits / capabilities
-        # self.veo_max_num = 4  # Veo returns up to 4 videos
         self.veo_max_num = 1  # limit to 1 in Gemini API
 
         # fallbacks
@@ -187,42 +186,52 @@ class VideoWorker(QRunnable):
             num = min(self.num, self.veo_max_num)
             cfg_kwargs = {
                 "number_of_videos": num,
-                #"duration_seconds": self._duration_for_model(self.model, self.duration_seconds),
             }
-            if self.aspect_ratio:
-                cfg_kwargs["aspect_ratio"] = self.aspect_ratio
+
+            # normalize and set aspect ratio
+            ar = self._normalize_aspect_ratio(self.aspect_ratio)
+            if ar:
+                cfg_kwargs["aspect_ratio"] = ar
+
+            # normalize and set resolution if supported
+            res = self._normalize_resolution(self.resolution)
+            if res:
+                cfg_kwargs["resolution"] = res
+
+            # set optional controls
             if self.seed is not None:
                 cfg_kwargs["seed"] = int(self.seed)
             if self.negative_prompt:
                 cfg_kwargs["negative_prompt"] = self.negative_prompt
-            if self._is_veo3(self.model):
-                # Veo 3 supports audio and resolution
-                # WARN: but not Gemini API:
-                pass
-                """             
-                cfg_kwargs["generate_audio"] = bool(self.generate_audio)   
-                if self.resolution:
-                    cfg_kwargs["resolution"] = self.resolution
-                """
-
-            config = gtypes.GenerateVideosConfig(**cfg_kwargs)
-
-            # build request
-            req_kwargs = {
-                "model": self.model or self.DEFAULT_VEO_MODEL,
-                "prompt": self.input_prompt or "",
-                "config": config,
-            }
 
-            # image-to-video if an image attachment is present and supported
-            base_img = self._first_image_attachment(self.attachments)
-            if self.mode == Video.MODE_IMAGE_TO_VIDEO and base_img is not None and self._supports_image_to_video(self.model):
-                req_kwargs["image"] = gtypes.Image.from_file(location=base_img)
+            # set durationSeconds when supported; fall back gracefully if rejected by model
+            cfg_try = dict(cfg_kwargs)
+            cfg_try["duration_seconds"] = int(self._duration_for_model(self.model, self.duration_seconds))
 
             self.signals.status.emit(trans('vid.status.generating') + f": {self.input_prompt}...")
 
-            # start long-running operation
-            operation = self.client.models.generate_videos(**req_kwargs)
+            try:
+                config = gtypes.GenerateVideosConfig(**cfg_try)
+                operation = self.client.models.generate_videos(
+                    model=self.model or self.DEFAULT_VEO_MODEL,
+                    prompt=self.input_prompt or "",
+                    config=config,
+                    image=self._image_part_if_needed(),
+                    video=None,
+                )
+            except Exception as e:
+                if "durationSeconds isn't supported" in str(e) or "Unrecognized" in str(e):
+                    # retry without duration_seconds
+                    config = gtypes.GenerateVideosConfig(**cfg_kwargs)
+                    operation = self.client.models.generate_videos(
+                        model=self.model or self.DEFAULT_VEO_MODEL,
+                        prompt=self.input_prompt or "",
+                        config=config,
+                        image=self._image_part_if_needed(),
+                        video=None,
+                    )
+                else:
+                    raise
 
             # poll until done
             while not getattr(operation, "done", False):
@@ -258,6 +267,22 @@ class VideoWorker(QRunnable):
 
     # ---------- helpers ----------
 
+    def _normalize_aspect_ratio(self, ar: str) -> str:
+        """Normalize aspect ratio to Veo-supported values."""
+        val = (ar or "").strip()
+        return val if val in ("16:9", "9:16") else "16:9"
+
+    def _normalize_resolution(self, res: str) -> Optional[str]:
+        """Normalize resolution to '720p' or '1080p'."""
+        val = (res or "").lower().replace(" ", "")
+        if val in ("720p", "1080p"):
+            return val
+        if val in ("1280x720", "720x1280"):
+            return "720p"
+        if val in ("1920x1080", "1080x1920"):
+            return "1080p"
+        return None
+
     def _is_veo3(self, model_id: str) -> bool:
         mid = str(model_id or "").lower()
         return mid.startswith("veo-3.")
@@ -265,20 +290,32 @@ class VideoWorker(QRunnable):
     def _supports_image_to_video(self, model_id: str) -> bool:
         """Return True if the model supports image->video."""
         mid = str(model_id or "").lower()
-        # Official support for image-to-video on veo-2 and veo-3 preview; keep extendable.
-        return ("veo-2.0" in mid) or ("veo-3.0-generate-preview" in mid) or ("veo-3.0-fast-generate-preview" in mid)
+        return any(p in mid for p in (
+            "veo-2.0",
+            "veo-3.0-generate",
+            "veo-3.0-fast-generate",
+            "veo-3.1-generate",
+            "veo-3.1-fast-generate",
+        ))
 
     def _duration_for_model(self, model_id: str, requested: int) -> int:
         """Adjust duration constraints to model-specific limits."""
         mid = str(model_id or "").lower()
         if "veo-2.0" in mid:
-            # Veo 2 supports 5–8s, default 8s.
             return max(5, min(8, int(requested or 8)))
+        if "veo-3.1" in mid:
+            return max(4, min(8, int(requested or 8)))
         if "veo-3.0" in mid:
-            # Veo 3 commonly uses 8s clips; honor request if provided, otherwise 8s.
-            return int(requested or 8)
+            return max(4, min(8, int(requested or 8)))
         return int(requested or 8)
 
+    def _image_part_if_needed(self) -> Optional[gtypes.Image]:
+        """Return Image part when in image-to-video mode and supported."""
+        if self.mode != Video.MODE_IMAGE_TO_VIDEO:
+            return None
+        base_img = self._first_image_attachment(self.attachments)
+        return gtypes.Image.from_file(location=base_img) if base_img else None
+
     def _first_image_attachment(self, attachments: Dict[str, Any]) -> Optional[str]:
         """Return path of the first image attachment, if any."""
         for _, att in (attachments or {}).items():

pygpt_net/provider/api/openai/__init__.py

@@ -6,7 +6,7 @@
 # GitHub:  https://github.com/szczyglis-dev/py-gpt   #
 # MIT License                                        #
 # Created By  : Marcin Szczygliński                  #
-# Updated Date: 2025.09.12 20:00:00                  #
+# Updated Date: 2025.12.25 20:00:00                  #
 # ================================================== #
 
 from openai import OpenAI
@@ -38,6 +38,7 @@ from .store import Store
 from .summarizer import Summarizer
 from .tools import Tools
 from .vision import Vision
+from .video import Video
 
 
 class ApiOpenAI:
@@ -63,6 +64,7 @@ class ApiOpenAI:
         self.summarizer = Summarizer(window)
         self.tools = Tools(window)
         self.vision = Vision(window)
+        self.video = Video(window)
         self.client = None
         self.locked = False
         self.last_client_args = None  # last client args used, for debug purposes
@@ -87,7 +89,7 @@ class ApiOpenAI:
             self,
             context: BridgeContext,
             extra: dict = None,
-            rt_signals = None
+            rt_signals=None
     ) -> bool:
         """
         Call OpenAI API
@@ -157,7 +159,7 @@ class ApiOpenAI:
                 if is_realtime:
                     return True
 
-            if fixtures.is_enabled("stream"): # fake stream for testing
+            if fixtures.is_enabled("stream"):  # fake stream for testing
                 use_responses_api = False
                 response = fixtures.get_stream_generator(ctx)
             else:
@@ -181,12 +183,20 @@ class ApiOpenAI:
 
             self.vision.append_images(ctx)  # append images to ctx if provided
 
-        # image
+        # image / video
         elif mode == MODE_IMAGE:
-            return self.image.generate(
-                context=context,
-                extra=extra,
-            )  # return here, async handled
+            media_mode = self.window.controller.media.get_mode()
+            if media_mode == "video":
+                if context.model and context.model.is_video_output():
+                    return self.video.generate(
+                        context=context,
+                        extra=extra,
+                    )  # async handled if allowed
+            elif media_mode == "image":
+                return self.image.generate(
+                    context=context,
+                    extra=extra,
+                )
 
         # vision
         elif mode == MODE_VISION:
@@ -294,13 +304,13 @@ class ApiOpenAI:
         messages.append({"role": "user", "content": prompt})
         additional_kwargs = {}
         # if max_tokens > 0:
-            # additional_kwargs["max_tokens"] = max_tokens
+        # additional_kwargs["max_tokens"] = max_tokens
 
         # tools / functions
         tools = self.window.core.api.openai.tools.prepare(model, functions)
         if len(tools) > 0 and "disable_tools" not in extra:
             additional_kwargs["tools"] = tools
-        
+
         try:
             response = client.chat.completions.create(
                 messages=messages,
@@ -349,4 +359,4 @@ class ApiOpenAI:
                 self.client = None
             except Exception as e:
                 self.window.core.debug.log(e)
-                print("Error closing client:", e)
+                print("Error closing client:", e)