pygpt-net 2.6.28__py3-none-any.whl → 2.6.30__py3-none-any.whl

pygpt_net/provider/api/google/image.py

@@ -0,0 +1,287 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# ================================================== #
+# This file is a part of PYGPT package               #
+# Website: https://pygpt.net                         #
+# GitHub:  https://github.com/szczyglis-dev/py-gpt   #
+# MIT License                                        #
+# Created By  : Marcin Szczygliński                  #
+# Updated Date: 2025.08.28 20:00:00                  #
+# ================================================== #
+
+from typing import Optional, Dict, Any, List
+from google import genai
+from google.genai import types as gtypes
+from PySide6.QtCore import QObject, Signal, QRunnable, Slot
+import base64, datetime, os, requests
+
+from pygpt_net.core.events import KernelEvent
+from pygpt_net.core.bridge.context import BridgeContext
+from pygpt_net.item.ctx import CtxItem
+from pygpt_net.utils import trans
+
+
+class Image:
+
+    MODE_GENERATE = "generate"
+    MODE_EDIT = "edit"
+
+    def __init__(self, window=None):
+        self.window = window
+        self.worker = None
+
+    def generate(
+            self,
+            context: BridgeContext,
+            extra: Optional[Dict[str, Any]] = None,
+            sync: bool = True
+    ) -> bool:
+        """
+        Generate image(s) using Google GenAI API
+
+        :param context: BridgeContext
+        :param extra: Extra parameters (num, inline)
+        :param sync: Run synchronously if True
+        :return: bool
+        """
+        extra = extra or {}
+        ctx = context.ctx or CtxItem()
+        model = context.model
+        prompt = context.prompt
+        num = int(extra.get("num", 1))
+        inline = bool(extra.get("inline", False))
+
+        prompt_model = self.window.core.models.from_defaults()
+        tmp = self.window.core.config.get('img_prompt_model')
+        if self.window.core.models.has(tmp):
+            prompt_model = self.window.core.models.get(tmp)
+
+        worker = ImageWorker()
+        worker.window = self.window
+        worker.client = self.window.core.api.google.get_client()
+        worker.ctx = ctx
+        worker.model = model.id
+        worker.input_prompt = prompt
+        worker.model_prompt = prompt_model
+        worker.system_prompt = self.window.core.prompt.get('img')
+        worker.raw = self.window.core.config.get('img_raw')
+        worker.num = num
+        worker.inline = inline
+
+        if self.window.core.config.has('img_resolution'):
+            worker.resolution = self.window.core.config.get('img_resolution') or "1024x1024"
+
+        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)
+        self.worker.signals.error.connect(self.window.core.image.handle_error)
+
+        if sync or not self.window.controller.kernel.async_allowed(ctx):
+            self.worker.run()
+            return True
+
+        self.window.dispatch(KernelEvent(KernelEvent.STATE_BUSY, {"id": "img"}))
+        self.window.threadpool.start(self.worker)
+        return True
+
+
+class ImageSignals(QObject):
+    finished = Signal(object, list, str)  # ctx, paths, prompt
+    finished_inline = Signal(object, list, str)  # ctx, paths, prompt
+    status = Signal(object) # message
+    error = Signal(object) # exception
+
+
+class ImageWorker(QRunnable):
+    def __init__(self, *args, **kwargs):
+        super().__init__()
+        self.signals = ImageSignals()
+        self.window = None
+        self.client: Optional[genai.Client] = None
+        self.ctx: Optional[CtxItem] = None
+        self.model = "imagen-4.0-generate-001"
+        self.model_prompt = None
+        self.input_prompt = ""
+        self.system_prompt = ""
+        self.inline = False
+        self.raw = False
+        self.num = 1
+        self.resolution = "1024x1024"  # used to derive aspect ratio for Imagen
+
+    @Slot()
+    def run(self):
+        try:
+            # Optional prompt enhancement
+            if not self.raw and not not self.inline:
+                try:
+                    self.signals.status.emit(trans('img.status.prompt.wait'))
+                    bridge_context = BridgeContext(
+                        prompt=self.input_prompt,
+                        system_prompt=self.system_prompt,
+                        model=self.model_prompt,
+                        max_tokens=200,
+                        temperature=1.0,
+                    )
+                    ev = KernelEvent(KernelEvent.CALL, {'context': bridge_context, 'extra': {}})
+                    self.window.dispatch(ev)
+                    resp = ev.data.get('response')
+                    if resp:
+                        self.input_prompt = resp
+                except Exception as e:
+                    self.signals.error.emit(e)
+                    self.signals.status.emit(trans('img.status.prompt.error') + ": " + str(e))
+
+            self.signals.status.emit(trans('img.status.generating') + f": {self.input_prompt}...")
+
+            paths: List[str] = []
+            if self._is_imagen(self.model):
+                # Imagen: generate_images
+                resp = self._imagen_generate(self.input_prompt, self.num, self.resolution)
+                imgs = getattr(resp, "generated_images", None) or []
+                for idx, gi in enumerate(imgs[: self.num]):
+                    data = self._extract_imagen_bytes(gi)
+                    p = self._save(idx, data)
+                    if p:
+                        paths.append(p)
+            else:
+                # Gemini image preview: generate_content -> parts[].inline_data.data
+                resp = self.client.models.generate_content(
+                    model=self.model,
+                    contents=[self.input_prompt],
+                )
+                from PIL import Image as PILImage
+                from io import BytesIO
+                cands = getattr(resp, "candidates", None) or []
+                saved = 0
+                for cand in cands:
+                    parts = getattr(getattr(cand, "content", None), "parts", None) or []
+                    for part in parts:
+                        inline = getattr(part, "inline_data", None)
+                        if inline and getattr(inline, "data", None):
+                            data = inline.data
+                            p = self._save(saved, data)
+                            if p:
+                                paths.append(p)
+                                saved += 1
+                                if saved >= self.num:
+                                    break
+                    if saved >= self.num:
+                        break
+
+            if self.inline:
+                self.signals.finished_inline.emit(self.ctx, paths, self.input_prompt)
+            else:
+                self.signals.finished.emit(self.ctx, paths, self.input_prompt)
+        except Exception as e:
+            self.signals.error.emit(e)
+        finally:
+            self._cleanup()
+
+    def _is_imagen(self, model_id: str) -> bool:
+        """
+        Check if model_id is an Imagen model
+
+        :param model_id: Model ID
+        :return: True if Imagen model
+        """
+        return "imagen" in str(model_id).lower()
+
+    def _imagen_generate(self, prompt: str, num: int, resolution: str):
+        """
+        Call Imagen generate_images with config (number_of_images, optional aspect_ratio).
+
+        :param prompt: Prompt text
+        :param num: Number of images to generate
+        :param resolution: Resolution string, e.g. "1024x1024"
+        :return: GenerateImagesResponse
+        """
+        aspect = self._aspect_from_resolution(resolution)  # "1:1", "3:4", …
+        cfg = gtypes.GenerateImagesConfig(number_of_images=num)
+        if aspect:
+            cfg.aspect_ratio = aspect
+        return self.client.models.generate_images(
+            model=self.model,
+            prompt=prompt,
+            config=cfg,
+        )
+
+    def _aspect_from_resolution(self, resolution: str) -> Optional[str]:
+        """
+        Derive aspect ratio string from resolution.
+
+        :param resolution: Resolution string, e.g. "1024x1024"
+        :return: Aspect ratio string, e.g. "1:1", "3:4", or None if unknown
+        """
+        try:
+            w, h = [int(x) for x in resolution.lower().split("x")]
+            # Reduce to small set supported in docs
+            ratios = {(1, 1): "1:1", (3, 4): "3:4", (4, 3): "4:3", (9, 16): "9:16", (16, 9): "16:9"}
+            # Find nearest
+            from math import gcd
+            g = gcd(w, h)
+            key = (w // g, h // g)
+            return ratios.get(key)
+        except Exception:
+            return None
+
+    def _extract_imagen_bytes(self, generated_image) -> Optional[bytes]:
+        """
+        Extract bytes from Imagen generated image object.
+
+        :param generated_image: GeneratedImage object
+        :return: Image bytes or None
+        """
+        img = getattr(generated_image, "image", None)
+        if not img:
+            return None
+        data = getattr(img, "image_bytes", None)
+        if isinstance(data, (bytes, bytearray)):
+            return bytes(data)
+        if isinstance(data, str):
+            try:
+                return base64.b64decode(data)
+            except Exception:
+                return None
+        # fallback: url/uri if present
+        url = getattr(img, "url", None) or getattr(img, "uri", None)
+        if url:
+            try:
+                r = requests.get(url, timeout=30)
+                if r.status_code == 200:
+                    return r.content
+            except Exception:
+                pass
+        return None
+
+    def _save(self, idx: int, data: Optional[bytes]) -> Optional[str]:
+        """
+        Save image bytes to file and return path.
+
+        :param idx: Image index (for filename)
+        :param data: Image bytes
+        :return: Path string or None
+        """
+        if not data:
+            return None
+        name = (
+            datetime.date.today().strftime("%Y-%m-%d") + "_" +
+            datetime.datetime.now().strftime("%H-%M-%S") + "-" +
+            self.window.core.image.make_safe_filename(self.input_prompt) + "-" +
+            str(idx + 1) + ".png"
+        )
+        path = os.path.join(self.window.core.config.get_user_dir("img"), name)
+        self.signals.status.emit(trans('img.status.downloading') + f" ({idx + 1} / {self.num}) -> {path}")
+        if self.window.core.image.save_image(path, data):
+            return path
+        return None
+
+    def _cleanup(self):
+        """Cleanup resources"""
+        sig = self.signals
+        self.signals = None
+        if sig is not None:
+            try:
+                sig.deleteLater()
+            except RuntimeError:
+                pass

pygpt_net/provider/api/google/tools.py

@@ -0,0 +1,222 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# ================================================== #
+# This file is a part of PYGPT package               #
+# Website: https://pygpt.net                         #
+# GitHub:  https://github.com/szczyglis-dev/py-gpt   #
+# MIT License                                        #
+# Created By  : Marcin Szczygliński                  #
+# Updated Date: 2025.08.28 20:00:00                  #
+# ================================================== #
+
+import json
+from typing import List, Any, Dict, Optional
+
+from google.genai import types as gtypes
+from pygpt_net.item.model import ModelItem
+
+
+class Tools:
+    def __init__(self, window=None):
+        """
+        Tools mapper for Google GenAI
+
+        :param window: Window instance
+        """
+        self.window = window
+
+    # -------- SANITIZER --------
+    def _sanitize_schema(self, schema: Any) -> Any:
+        """
+        Sanitize JSON Schema dict by removing unsupported keywords and normalizing types.
+
+        1. Remove unsupported keywords like additionalProperties, patternProperties,
+           dependencies, oneOf, anyOf, allOf, $ref, $defs, examples, readOnly, writeOnly.
+        2. Normalize 'type' to a single value (e.g., if it's a list, take the first non-null type).
+        3. Ensure 'enum' is only present for string types.
+        4. Recursively sanitize nested schemas in 'properties' and 'items'.
+        5. Handle arrays by ensuring 'items' is a single schema.
+        6. Handle objects by ensuring 'properties' is a dict and 'required' is a list of strings.
+
+        :param schema: Any JSON Schema as dict or list
+        :return: Sanitized schema dict
+        """
+        if isinstance(schema, list):
+            return self._sanitize_schema(schema[0]) if schema else {}
+
+        if not isinstance(schema, dict):
+            return schema
+
+        banned = {
+            "additionalProperties",
+            "additional_properties",
+            "unevaluatedProperties",
+            "patternProperties",
+            "dependencies",
+            "dependentSchemas",
+            "dependentRequired",
+            "oneOf",
+            "anyOf",
+            "allOf",
+            "$defs",
+            "$ref",
+            "$schema",
+            "$id",
+            "examples",
+            "readOnly",
+            "writeOnly",
+            "nullable",
+        }
+        for k in list(schema.keys()):
+            if k in banned:
+                schema.pop(k, None)
+
+        # Union -> first non-null type
+        t = schema.get("type")
+        if isinstance(t, list):
+            t_no_null = [x for x in t if x != "null"]
+            schema["type"] = t_no_null[0] if t_no_null else "string"
+
+        # enum only for string
+        if "enum" in schema and schema.get("type") not in ("string", "STRING"):
+            schema.pop("enum", None)
+
+        # object
+        if (schema.get("type") or "").lower() == "object":
+            props = schema.get("properties")
+            if not isinstance(props, dict):
+                props = {}
+            clean_props: Dict[str, Any] = {}
+            for pname, pval in props.items():
+                clean_props[pname] = self._sanitize_schema(pval)
+            schema["properties"] = clean_props
+
+            req = schema.get("required")
+            if not isinstance(req, list) or not all(isinstance(x, str) for x in req):
+                schema.pop("required", None)
+            elif len(req) == 0:
+                schema.pop("required", None)
+
+        # array
+        if (schema.get("type") or "").lower() == "array":
+            items = schema.get("items")
+            if isinstance(items, list) and items:
+                items = items[0]
+            if not isinstance(items, dict):
+                items = {"type": "string"}
+            schema["items"] = self._sanitize_schema(items)
+
+        # recursive sanitize
+        for k, v in list(schema.items()):
+            if isinstance(v, dict):
+                schema[k] = self._sanitize_schema(v)
+            elif isinstance(v, list):
+                schema[k] = [self._sanitize_schema(x) for x in v]
+
+        return schema
+
+    # -------- CONVERTER to gtypes.Schema (UPPERCASE) --------
+    def _to_gschema(self, schema: Any) -> gtypes.Schema:
+        """
+        Convert sanitized dict -> google.genai.types.Schema.
+        Enforces UPPERCASE type names (OBJECT, ARRAY, STRING, NUMBER, INTEGER, BOOLEAN).
+
+        :param schema: Sanitized JSON Schema as dict
+        :return: gtypes.Schema
+        """
+        TYPE_MAP = {
+            "enum": "STRING",
+            "ENUM": "STRING",
+            "object": "OBJECT",
+            "dict": "OBJECT",
+            "array": "ARRAY",
+            "list": "ARRAY",
+            "string": "STRING",
+            "number": "NUMBER",
+            "float": "NUMBER",
+            "integer": "INTEGER",
+            "boolean": "BOOLEAN",
+            "int": "INTEGER",
+            "bool": "BOOLEAN",
+            "OBJECT": "OBJECT",
+            "DICT": "OBJECT",
+            "ARRAY": "ARRAY",
+            "LIST": "ARRAY",
+            "STRING": "STRING",
+            "NUMBER": "NUMBER",
+            "FLOAT": "NUMBER",
+            "INTEGER": "INTEGER",
+            "BOOLEAN": "BOOLEAN",
+            "INT": "INTEGER",
+            "BOOL": "BOOLEAN",
+        }
+
+        if isinstance(schema, gtypes.Schema):
+            return schema
+
+        if not isinstance(schema, dict):
+            return gtypes.Schema(type="STRING")
+
+        t = TYPE_MAP.get(str(schema.get("type", "OBJECT")).upper(), "OBJECT")
+        desc = schema.get("description")
+        fmt = schema.get("format")
+        enum = schema.get("enum") if isinstance(schema.get("enum"), list) else None
+        req = schema.get("required") if isinstance(schema.get("required"), list) else None
+
+        gs = gtypes.Schema(
+            type=t,
+            description=desc,
+            format=fmt,
+            enum=enum,
+            required=[x for x in (req or []) if isinstance(x, str)] or None,
+        )
+
+        props = schema.get("properties")
+        if isinstance(props, dict):
+            gs.properties = {k: self._to_gschema(v) for k, v in props.items()}
+
+        items = schema.get("items")
+        if isinstance(items, dict):
+            gs.items = self._to_gschema(items)
+
+        return gs
+
+    def prepare(self, model: ModelItem, functions: list) -> List[gtypes.Tool]:
+        """
+        Prepare Google Function Declarations (types.Tool) for google-genai.
+
+        :param model: ModelItem
+        :param functions: List of function definitions as dicts with 'name', 'desc', 'params' (JSON Schema)
+        :return: List of gtypes.Tool
+        """
+        if not functions or not isinstance(functions, list):
+            return []
+
+        fds: List[gtypes.FunctionDeclaration] = []
+        for function in functions:
+            name = str(function.get("name") or "").strip()
+            if not name:
+                continue
+
+            desc = function.get("desc") or ""
+            params: Optional[dict] = {}
+            if function.get("params"):
+                try:
+                    params = json.loads(function["params"])
+                except Exception:
+                    params = {}
+
+                params = self._sanitize_schema(params or {})
+                if not params.get("type"):
+                    params["type"] = "object"
+
+            gschema = self._to_gschema(params or {"type": "object"})
+
+            fd = gtypes.FunctionDeclaration(
+                name=name,
+                description=desc,
+                parameters=gschema,
+            )
+            fds.append(fd)
+
+        return [gtypes.Tool(function_declarations=fds)] if fds else []

pygpt_net/provider/api/google/vision.py

@@ -0,0 +1,129 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# ================================================== #
+# This file is a part of PYGPT package               #
+# Website: https://pygpt.net                         #
+# GitHub:  https://github.com/szczyglis-dev/py-gpt   #
+# MIT License                                        #
+# Created By  : Marcin Szczygliński                  #
+# Updated Date: 2025.08.28 20:00:00                  #
+# ================================================== #
+
+import os
+from typing import Optional, Dict, List, Union
+
+from google.genai.types import Part
+
+from pygpt_net.item.attachment import AttachmentItem
+from pygpt_net.item.ctx import CtxItem
+
+
+class Vision:
+    def __init__(self, window=None):
+        """
+        Vision helpers for Google GenAI
+
+        :param window: Window instance
+        """
+        self.window = window
+        self.attachments: Dict[str, str] = {}
+        self.urls: List[str] = []
+        self.input_tokens = 0
+
+    def build_parts(
+        self,
+        content: Union[str, list],
+        attachments: Optional[Dict[str, AttachmentItem]] = None,
+    ) -> List[Part]:
+        """
+        Build image parts from local attachments (inline bytes)
+
+        :param content: Message content (str or list)
+        :param attachments: Attachments dict (id -> AttachmentItem)
+        :return: List of Parts
+        """
+        parts: List[Part] = []
+        self.attachments = {}
+        self.urls = []
+
+        if attachments:
+            for id_, attachment in attachments.items():
+                if attachment.path and os.path.exists(attachment.path):
+                    if self.is_image(attachment.path):
+                        mime = self._guess_mime(attachment.path)
+                        with open(attachment.path, "rb") as f:
+                            data = f.read()
+                        parts.append(Part.from_bytes(data=data, mime_type=mime))
+                        self.attachments[id_] = attachment.path
+                        attachment.consumed = True
+
+        return parts
+
+    def is_image(self, path: str) -> bool:
+        """
+        Check if path looks like an image
+
+        :param path: File path
+        :return: True if image, False otherwise
+        """
+        return path.lower().endswith(('.png', '.jpg', '.jpeg', '.tiff', '.bmp', '.gif', '.webp'))
+
+    def _guess_mime(self, path: str) -> str:
+        """
+        Guess mime type from file extension
+
+        :param path: File path
+        :return: Mime type string
+        """
+        ext = os.path.splitext(path)[1].lower().lstrip(".")
+        if ext in ("jpg", "jpeg"):
+            return "image/jpeg"
+        if ext == "png":
+            return "image/png"
+        if ext == "gif":
+            return "image/gif"
+        if ext == "bmp":
+            return "image/bmp"
+        if ext == "webp":
+            return "image/webp"
+        if ext == "tiff":
+            return "image/tiff"
+        return "image/jpeg"
+
+    def append_images(self, ctx: CtxItem):
+        """
+        Append sent images paths to context for UI/history
+
+        :param ctx: CtxItem
+        """
+        images = self.get_attachments()
+        if len(images) > 0:
+            ctx.images = self.window.core.filesystem.make_local_list(list(images.values()))
+
+    def get_attachments(self) -> Dict[str, str]:
+        """
+        Return attachments dict (id -> path)
+
+        :return: Dict of attachments
+        """
+        return self.attachments
+
+    def get_urls(self) -> List[str]:
+        """
+        Return image urls (unused here)
+
+        :return: List of URLs
+        """
+        return self.urls
+
+    def reset_tokens(self):
+        """Reset input tokens counter"""
+        self.input_tokens = 0
+
+    def get_used_tokens(self) -> int:
+        """
+        Return input tokens counter
+
+        :return: Number of input tokens
+        """
+        return self.input_tokens

pygpt_net/provider/{gpt → api/openai}/__init__.py

@@ -39,7 +39,7 @@ from .tools import Tools
 from .vision import Vision
 
 
-class Gpt:
+class ApiOpenAI:
 
     def __init__(self, window=None):
         """
@@ -281,7 +281,7 @@ class Gpt:
             # additional_kwargs["max_tokens"] = max_tokens
 
         # tools / functions
-        tools = self.window.core.gpt.tools.prepare(model, 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
         

pygpt_net/provider/{gpt → api/openai}/agents/computer.py

@@ -48,7 +48,7 @@ class LocalComputer(Computer):
 
         :return: Environment of the computer, such as "mac", "windows", "ubuntu", or "browser".
         """
-        return self.window.core.gpt.computer.get_current_env()
+        return self.window.core.api.openai.computer.get_current_env()
 
     @property
     def dimensions(self) -> tuple[int, int]:

pygpt_net/provider/{gpt → api/openai}/agents/experts.py

@@ -13,7 +13,7 @@ from agents import (
 from pygpt_net.item.model import ModelItem
 from pygpt_net.item.preset import PresetItem
 
-from pygpt_net.provider.gpt.agents.remote_tools import append_tools
+from pygpt_net.provider.api.openai.agents.remote_tools import append_tools
 
 
 def get_experts(

pygpt_net/provider/{gpt → api/openai}/agents/response.py

@@ -169,7 +169,7 @@ class StreamHandler:
             self.files_handled = True
             self.window.core.debug.info("[chat] Container files found, downloading...")
             try:
-                self.window.core.gpt.container.download_files(ctx, self.files)
+                self.window.core.api.openai.container.download_files(ctx, self.files)
             except Exception as e:
                 self.window.core.debug.error(f"[chat] Error downloading container files: {e}")
 

pygpt_net/provider/{gpt → api/openai}/assistants.py

@@ -36,7 +36,7 @@ class Assistants:
 
         :return: OpenAI client
         """
-        return self.window.core.gpt.get_client()
+        return self.window.core.api.openai.get_client()
 
     def log(
             self,