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

pygpt_net/provider/api/__init__.py

@@ -0,0 +1,27 @@
+#!/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 .anthropic import ApiAnthropic
+from .google import ApiGoogle
+from .openai import ApiOpenAI
+
+class Api:
+
+    def __init__(self, window=None):
+        """
+        API wrappers core
+
+        :param window: Window instance
+        """
+        self.window = window
+        self.anthropic = ApiAnthropic(window)
+        self.google = ApiGoogle(window)
+        self.openai = ApiOpenAI(window)

pygpt_net/provider/api/anthropic/__init__.py

@@ -0,0 +1,68 @@
+#!/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 09:00:00                  #
+# ================================================== #
+
+from anthropic import Anthropic
+
+from pygpt_net.core.types import (
+    MODE_CHAT,
+)
+from pygpt_net.item.model import ModelItem
+
+class ApiAnthropic:
+
+    def __init__(self, window=None):
+        """
+        Anthropic API wrapper core
+
+        :param window: Window instance
+        """
+        self.window = window
+        self.client = None
+        self.locked = False
+
+    def get_client(
+            self,
+            mode: str = MODE_CHAT,
+            model: ModelItem = None
+    ) -> Anthropic:
+        """
+        Return Anthropic client
+
+        :param mode: Mode
+        :param model: Model
+        :return: Anthropic client
+        """
+        if self.client is not None:
+            try:
+                self.client.close()  # close previous client if exists
+            except Exception as e:
+                self.window.core.debug.log(e)
+                print("Error closing previous Anthropic client:", e)
+        self.client = Anthropic(
+            api_key=self.window.core.config.get('api_key_anthropic', "")
+        )
+        return self.client
+
+    def stop(self):
+        """On global event stop"""
+        pass
+
+    def close(self):
+        """Close Anthropic client"""
+        if self.locked:
+            return
+        if self.client is not None:
+            try:
+                pass
+                # self.client.close()
+            except Exception as e:
+                self.window.core.debug.log(e)
+                print("Error closing Anthropic client:", e)

pygpt_net/provider/api/google/__init__.py

@@ -0,0 +1,262 @@
+#!/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
+
+from google.genai import types as gtypes
+from google import genai
+from pygpt_net.core.types import (
+    MODE_ASSISTANT,
+    MODE_AUDIO,
+    MODE_CHAT,
+    MODE_COMPLETION,
+    MODE_IMAGE,
+    MODE_RESEARCH,
+)
+from pygpt_net.core.bridge.context import BridgeContext
+from pygpt_net.item.model import ModelItem
+
+from .chat import Chat
+from .vision import Vision
+from .tools import Tools
+from .audio import Audio
+from .image import Image
+
+
+class ApiGoogle:
+    def __init__(self, window=None):
+        """
+        Google GenAI API SDK wrapper
+
+        :param window: Window instance
+        """
+        self.window = window
+        self.chat = Chat(window)
+        self.vision = Vision(window)
+        self.tools = Tools(window)
+        self.audio = Audio(window)
+        self.image = Image(window)
+        self.client: Optional[genai.Client] = None
+        self.locked = False
+        self.last_client_args: Optional[Dict[str, Any]] = None
+
+    def get_client(
+            self,
+            mode: str = MODE_CHAT,
+            model: ModelItem = None
+    ) -> genai.Client:
+        """
+        Get or create Google GenAI client
+
+        :param mode: Mode (chat, completion, image, etc.)
+        :param model: ModelItem
+        :return: genai.Client instance
+        """
+        if not model:
+            model = ModelItem()
+            model.provider = "google"
+        args = self.window.core.models.prepare_client_args(mode, model)
+        filtered = {}
+        if args.get("api_key"):
+            filtered["api_key"] = args["api_key"]
+        if self.client is None or self.last_client_args != filtered:
+            self.client = genai.Client(**filtered)
+        self.last_client_args = filtered
+        return self.client
+
+    def call(self, context: BridgeContext, extra: dict = None) -> bool:
+        """
+        Make an API call to Google GenAI
+
+        :param context: BridgeContext
+        :param extra: Extra parameters
+        :return: True if successful, False otherwise
+        """
+        mode = context.mode
+        model = context.model
+        stream = context.stream
+        ctx = context.ctx
+        ai_name = ctx.output_name if ctx else "assistant"
+
+        # No Responses API in google-genai
+        if ctx:
+            ctx.use_responses_api = False
+
+        used_tokens = 0
+        response = None
+
+        if mode in [MODE_COMPLETION, MODE_CHAT, MODE_AUDIO, MODE_RESEARCH]:
+            response = self.chat.send(context=context, extra=extra)
+            used_tokens = self.chat.get_used_tokens()
+            if ctx:
+                self.vision.append_images(ctx)
+
+        elif mode == MODE_IMAGE:
+            return self.image.generate(context=context, extra=extra)
+
+        elif mode == MODE_ASSISTANT:
+            return False  # not implemented for Google
+
+        if stream:
+            if ctx:
+                ctx.stream = response
+                ctx.set_output("", ai_name)
+                ctx.input_tokens = used_tokens
+            return True
+
+        if response is None:
+            return False
+
+        if isinstance(response, dict) and "error" in response:
+            return False
+
+        if ctx:
+            ctx.ai_name = ai_name
+            self.chat.unpack_response(mode, response, ctx)
+            try:
+                import json
+                for tc in getattr(ctx, "tool_calls", []) or []:
+                    fn = tc.get("function") or {}
+                    args = fn.get("arguments")
+                    if isinstance(args, str):
+                        try:
+                            fn["arguments"] = json.loads(args)
+                        except Exception:
+                            fn["arguments"] = {}
+            except Exception:
+                pass
+        return True
+
+    def quick_call(self, context: BridgeContext, extra: dict = None) -> str:
+        """
+        Make a quick API call to Google GenAI and return the output text
+
+        :param context: BridgeContext
+        :param extra: Extra parameters
+        :return: Output text
+        """
+        if context.request:
+            context.stream = False
+            context.mode = MODE_CHAT
+            self.locked = True
+            self.call(context, extra)
+            self.locked = False
+            return context.ctx.output
+
+        self.locked = True
+        try:
+            ctx = context.ctx
+            prompt = context.prompt
+            system_prompt = context.system_prompt
+            temperature = context.temperature
+            history = context.history
+            functions = context.external_functions
+            model = context.model or self.window.core.models.from_defaults()
+
+            client = self.get_client(MODE_CHAT, model)
+            tools = self.tools.prepare(model, functions)
+
+            """
+            # with remote tools
+            base_tools = self.tools.prepare(model, functions)
+            remote_tools = self.build_remote_tools(model)
+            tools = (base_tools or []) + (remote_tools or [])
+            """
+
+            inputs = self.chat.build_input(
+                prompt=prompt,
+                system_prompt=system_prompt,
+                model=model,
+                history=history,
+                attachments=context.attachments,
+                multimodal_ctx=context.multimodal_ctx,
+            )
+            cfg = genai.types.GenerateContentConfig(
+                temperature=temperature if temperature is not None else self.window.core.config.get('temperature'),
+                top_p=self.window.core.config.get('top_p'),
+                max_output_tokens=context.max_tokens if context.max_tokens else None,
+                system_instruction=system_prompt if system_prompt else None,
+                tools=tools if tools else None,
+            )
+            resp = client.models.generate_content(
+                model=model.id,
+                contents=inputs,
+                config=cfg,
+            )
+
+            if ctx:
+                calls = self.chat.extract_tool_calls(resp)
+                if calls:
+                    ctx.tool_calls = calls
+            return self.chat.extract_text(resp)
+        except Exception as e:
+            self.window.core.debug.log(e)
+            return ""
+        finally:
+            self.locked = False
+
+    def build_remote_tools(self, model: ModelItem = None) -> list:
+        """
+        Build Google GenAI remote tools based on config flags.
+        - google_tool_search: enables grounding via Google Search (Gemini 2.x)
+          or GoogleSearchRetrieval (Gemini 1.5 fallback).
+        - google_tool_code_execution: enables code execution tool.
+
+        Returns a list of gtypes.Tool objects (can be empty).
+
+        :param model: ModelItem
+        :return: list of gtypes.Tool
+        """
+        tools: list = []
+        cfg = self.window.core.config
+        model_id = (model.id if model and getattr(model, "id", None) else "").lower()
+
+        # Google Search tool
+        if cfg.get("remote_tools.google.web_search") and "image" not in model.id:
+            try:
+                if not model_id.startswith("gemini-1.5") and not model_id.startswith("models/gemini-1.5"):
+                    # Gemini 2.x uses GoogleSearch
+                    tools.append(gtypes.Tool(google_search=gtypes.GoogleSearch()))
+                else:
+                    # Gemini 1.5 fallback uses GoogleSearchRetrieval
+                    # Note: Supported only for 1.5 models.
+                    tools.append(gtypes.Tool(
+                        google_search_retrieval=gtypes.GoogleSearchRetrieval()
+                    ))
+            except Exception as e:
+                # Do not break the request if tool construction fails
+                self.window.core.debug.log(e)
+
+        # Code Execution tool
+        if cfg.get("remote_tools.google.code_interpreter") and "image" not in model.id:
+            try:
+                tools.append(gtypes.Tool(code_execution=gtypes.ToolCodeExecution))
+            except Exception as e:
+                self.window.core.debug.log(e)
+
+        return tools
+
+
+    def stop(self):
+        """On global event stop"""
+        pass
+
+    def close(self):
+        """Close Google client"""
+        if self.locked:
+            return
+        if self.client is not None:
+            try:
+                pass
+                # self.client.close()
+            except Exception as e:
+                self.window.core.debug.log(e)
+                print("Error closing Google client:", e)

pygpt_net/provider/api/google/audio.py

@@ -0,0 +1,114 @@
+#!/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 base64
+import io
+import wave
+from typing import Optional, Tuple
+
+from google.genai.types import Part
+from pygpt_net.core.bridge.context import MultimodalContext
+
+
+class Audio:
+    def __init__(self, window=None):
+        """
+        Audio helpers for Google GenAI.
+        - Build audio input parts for requests
+        - Convert Google PCM output to WAV (base64) for UI compatibility
+        """
+        self.window = window
+
+    # ---------- INPUT (user -> model) ----------
+
+    def build_part(
+            self,
+            multimodal_ctx: Optional[MultimodalContext]
+    ) -> Optional[Part]:
+        """
+        Build audio Part from multimodal context (inline bytes).
+
+        :param multimodal_ctx: MultimodalContext
+        :return: Part or None
+        """
+        if not multimodal_ctx or not multimodal_ctx.is_audio_input or not multimodal_ctx.audio_data:
+            return None
+        audio_format = (multimodal_ctx.audio_format or "wav").lower()
+        mime = f"audio/{audio_format}"
+        return Part.from_bytes(data=multimodal_ctx.audio_data, mime_type=mime)
+
+    # ---------- OUTPUT (model -> UI) ----------
+
+    def extract_first_audio_part(
+            self,
+            response
+    ) -> Tuple[Optional[bytes], Optional[str]]:
+        """
+        Extract first audio inline_data from a non-streaming response.
+
+        :param response: Google response object
+        :return: (audio_bytes, mime_type) or (None, None)
+        """
+        try:
+            candidates = getattr(response, "candidates", None) or []
+            for cand in candidates:
+                content = getattr(cand, "content", None)
+                parts = getattr(content, "parts", None) or []
+                for p in parts:
+                    inline = getattr(p, "inline_data", None)
+                    if not inline:
+                        continue
+                    mime = (getattr(inline, "mime_type", "") or "").lower()
+                    if not mime.startswith("audio/"):
+                        continue
+                    data = getattr(inline, "data", None)
+                    audio_bytes = self._ensure_bytes(data)
+                    if audio_bytes:
+                        return audio_bytes, mime
+        except Exception:
+            pass
+        return None, None
+
+    def pcm16_to_wav_base64(
+            self,
+            pcm_bytes: bytes,
+            rate: int = 24000,
+            channels: int = 1,
+            sample_width: int = 2
+    ) -> str:
+        """
+        Wrap raw PCM16 mono @ 24kHz into WAV and return base64-encoded payload.
+
+        :param pcm_bytes: Raw PCM16 bytes
+        :param rate: Sample rate (Hz), default 24000 for Google TTS
+        :param channels: Channels, default 1
+        :param sample_width: Bytes per sample, default 2 for PCM16
+        :return: Base64-encoded WAV
+        """
+        buf = io.BytesIO()
+        with wave.open(buf, "wb") as wf:
+            wf.setnchannels(channels)
+            wf.setsampwidth(sample_width)
+            wf.setframerate(rate)
+            wf.writeframes(pcm_bytes)
+        return base64.b64encode(buf.getvalue()).decode("utf-8")
+
+    @staticmethod
+    def _ensure_bytes(data) -> Optional[bytes]:
+        """Return raw bytes from inline_data.data (bytes or base64 string)."""
+        try:
+            if isinstance(data, (bytes, bytearray)):
+                return bytes(data)
+            if isinstance(data, str):
+                return base64.b64decode(data)
+        except Exception:
+            return None
+        return None