pygpt-net 2.6.36__py3-none-any.whl → 2.6.38__py3-none-any.whl

pygpt_net/provider/api/x_ai/image.py

@@ -0,0 +1,208 @@
+#!/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.09.05 01:00:00                  #
+# ================================================== #
+
+import base64
+import datetime
+import os
+from typing import Optional, Dict, Any, List
+
+import requests
+from PySide6.QtCore import QObject, Signal, QRunnable, Slot
+
+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:
+    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) via xAI REST API /v1/images/generations (OpenAI-compatible).
+        Model: grok-2-image (or -1212 variants).
+
+        :param context: BridgeContext with prompt, model, ctx
+        :param extra: Extra parameters (num: int, inline: bool, etc.)
+        :param sync: Run synchronously (blocking) if True
+        :return: True if started
+        """
+        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))
+
+        # Optional prompt enhancement model (same as in your Google path)
+        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.ctx = ctx
+        worker.model = model.id or "grok-2-image"
+        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
+
+        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.ctx: Optional[CtxItem] = None
+
+        # params
+        self.model = "grok-2-image"
+        self.model_prompt = None
+        self.input_prompt = ""
+        self.system_prompt = ""
+        self.inline = False
+        self.raw = False
+        self.num = 1
+
+        # API
+        self.api_url = "https://api.x.ai/v1/images/generations"  # OpenAI-compatible endpoint
+
+    @Slot()
+    def run(self):
+        try:
+            # optional prompt enhancement
+            if not self.raw and not self.inline and self.input_prompt:
+                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}...")
+
+            cfg = self.window.core.config
+            api_key = cfg.get("api_key_xai") or os.environ.get("XAI_API_KEY") or ""
+            self.api_url = cfg.get("api_endpoint_xai") + "/images/generations"
+            if not api_key:
+                raise RuntimeError("Missing xAI API key. Set `api_key_xai` in config or XAI_API_KEY in env.")
+
+            headers = {
+                "Authorization": f"Bearer {api_key}",
+                "Content-Type": "application/json",
+            }
+            payload = {
+                "model": self.model or "grok-2-image",
+                "prompt": self.input_prompt or "",
+                "n": max(1, min(int(self.num), 10)),
+                "response_format": "b64_json",  # get base64 so we can save locally
+            }
+
+            r = requests.post(self.api_url, headers=headers, json=payload, timeout=180)
+            r.raise_for_status()
+            data = r.json()
+
+            images = []
+            for idx, img in enumerate((data.get("data") or [])[: self.num]):
+                b64 = img.get("b64_json")
+                if not b64:
+                    # fallback: url download
+                    url = img.get("url")
+                    if url:
+                        try:
+                            rr = requests.get(url, timeout=60)
+                            if rr.status_code == 200:
+                                images.append(rr.content)
+                        except Exception:
+                            pass
+                    continue
+                try:
+                    images.append(base64.b64decode(b64))
+                except Exception:
+                    continue
+
+            paths: List[str] = []
+            for i, content in enumerate(images):
+                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(i + 1) + ".jpg"
+                )
+                path = os.path.join(self.window.core.config.get_user_dir("img"), name)
+                self.signals.status.emit(trans('img.status.downloading') + f" ({i + 1} / {self.num}) -> {path}")
+
+                if self.window.core.image.save_image(path, content):
+                    paths.append(path)
+
+            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 _cleanup(self):
+        """Cleanup signals to avoid multiple calls."""
+        sig = self.signals
+        self.signals = None
+        if sig is not None:
+            try:
+                sig.deleteLater()
+            except RuntimeError:
+                pass

pygpt_net/provider/api/x_ai/remote.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.09.05 01:00:00                  #
+# ================================================== #
+
+from __future__ import annotations
+from typing import Optional, Dict, Any, List
+
+from pygpt_net.item.model import ModelItem
+
+
+class Remote:
+    def __init__(self, window=None):
+        """
+        Live Search builder for xAI:
+        - Returns a dict with 'sdk' (X-only toggle) and 'http' (full search_parameters).
+        - SDK path: native streaming (xai_sdk.chat.stream()) works only for basic X search (no advanced filters).
+        - HTTP path: full Live Search (web/news/rss/X with filters), streaming via SSE.
+
+        :param window: Window instance
+        """
+        self.window = window
+
+    def build_remote_tools(self, model: ModelItem = None) -> Dict[str, Any]:
+        """
+        Return live-search config for xAI:
+        {
+          "mode": ...,
+          "sdk": {"enabled": bool},
+          "http": Optional[dict],
+          "reason": Optional[str],
+        }
+
+        :param model: ModelItem (optional, not used now)
+        :return: Dict with 'sdk' and 'http' keys
+        """
+        return self.build(model)
+
+    def build(self, model=None) -> Dict[str, Any]:
+        """
+        Build both SDK-capable toggle and HTTP search_parameters.
+        Returns:
+            {
+              "mode": "auto"|"on"|"off",
+              "sdk": {"enabled": bool},           # True if we can use native SDK stream (X-only no filters)
+              "http": Optional[dict],             # search_parameters for Chat Completions (or None)
+              "reason": Optional[str],            # diagnostic: why http is needed
+            }
+
+        :param model: ModelItem (not used now)
+        :return: Dict with 'sdk' and 'http' keys
+        """
+        cfg = self.window.core.config
+
+        mode = str(cfg.get("remote_tools.xai.mode") or "auto").lower()
+        if mode not in ("auto", "on", "off"):
+            mode = "auto"
+
+        # sources toggles
+        s_web = bool(cfg.get("remote_tools.xai.sources.web", True))
+        s_x   = bool(cfg.get("remote_tools.xai.sources.x", True))
+        s_news = bool(cfg.get("remote_tools.xai.sources.news", False))
+        s_rss  = bool(cfg.get("remote_tools.xai.sources.rss", False))
+
+        # advanced flags
+        adv_web_allowed   = self._has_list(cfg.get("remote_tools.xai.web.allowed_websites"))
+        adv_web_excluded  = self._has_list(cfg.get("remote_tools.xai.web.excluded_websites"))
+        adv_web_country   = self._has_str(cfg.get("remote_tools.xai.web.country"))
+        adv_web_safe      = cfg.get("remote_tools.xai.web.safe_search", None)
+
+        adv_news_excl     = self._has_list(cfg.get("remote_tools.xai.news.excluded_websites"))
+        adv_news_country  = self._has_str(cfg.get("remote_tools.xai.news.country"))
+        adv_news_safe     = cfg.get("remote_tools.xai.news.safe_search", None)
+
+        adv_x_incl        = self._has_list(cfg.get("remote_tools.xai.x.included_handles"))
+        adv_x_excl        = self._has_list(cfg.get("remote_tools.xai.x.excluded_handles"))
+        adv_x_favs        = self._has_int(cfg.get("remote_tools.xai.x.min_favs"))
+        adv_x_views       = self._has_int(cfg.get("remote_tools.xai.x.min_views"))
+
+        adv_rss_link      = self._has_str(cfg.get("remote_tools.xai.rss.link"))
+
+        adv_from          = self._has_str(cfg.get("remote_tools.xai.from_date"))
+        adv_to            = self._has_str(cfg.get("remote_tools.xai.to_date"))
+
+        adv_max_results   = self._has_int(cfg.get("remote_tools.xai.max_results"))
+        adv_return_cits   = cfg.get("remote_tools.xai.return_citations", True) is not True  # different than default?
+
+        # SDK-capable if: mode!=off and ONLY X is enabled and no X filters/date/max_results customizations
+        x_only = s_x and not s_web and not s_news and not s_rss
+        x_filters = any([adv_x_incl, adv_x_excl, adv_x_favs, adv_x_views])
+        sdk_enabled = (mode != "off") and x_only and not any([
+            x_filters, adv_from, adv_to, adv_max_results, adv_return_cits
+        ])
+
+        # Build HTTP search_parameters only when needed beyond X-only basic,
+        # or when mode explicitly on/auto but SDK cannot represent flags.
+        http_params: Optional[dict] = None
+        http_reason: Optional[str] = None
+
+        need_http = (mode != "off") and (
+            not sdk_enabled or                # advanced X filters or other sources/date/results/citations
+            s_web or s_news or s_rss
+        )
+        if need_http:
+            http_params = self._build_http_params(cfg, mode, s_web, s_x, s_news, s_rss)
+            http_reason = "advanced_sources_or_filters"
+
+        return {
+            "mode": mode,
+            "sdk": {"enabled": sdk_enabled},
+            "http": http_params,
+            "reason": http_reason,
+        }
+
+    # ---------- helpers ----------
+
+    def _build_http_params(
+            self,
+            cfg,
+            mode: str,
+            s_web: bool,
+            s_x: bool,
+            s_news: bool,
+            s_rss: bool
+    ) -> dict:
+        """
+        Build search_parameters for Chat Completions (HTTP).
+
+        :param cfg: Config dict
+        :param mode: "auto"|"on"|"off"
+        :param s_web: Include web search
+        :param s_x: Include X search
+        :param s_news: Include news search
+        :param s_rss: Include RSS search
+        :return: search_parameters dict
+        """
+        params: Dict[str, Any] = {"mode": mode}
+
+        rc = cfg.get("remote_tools.xai.return_citations")
+        if rc is None:
+            rc = True
+        params["return_citations"] = bool(rc)
+
+        msr = cfg.get("remote_tools.xai.max_results")
+        if isinstance(msr, int) and msr > 0:
+            params["max_search_results"] = int(msr)
+
+        for k_cfg, k_out in (("remote_tools.xai.from_date", "from_date"),
+                             ("remote_tools.xai.to_date", "to_date")):
+            val = cfg.get(k_cfg)
+            if isinstance(val, str) and val.strip():
+                params[k_out] = val.strip()
+
+        sources: List[Dict[str, Any]] = []
+
+        if s_web:
+            web: Dict[str, Any] = {"type": "web"}
+            country = cfg.get("remote_tools.xai.web.country")
+            if isinstance(country, str) and len(country.strip()) == 2:
+                web["country"] = country.strip().upper()
+            allowed = self._as_list(cfg.get("remote_tools.xai.web.allowed_websites"), 5)
+            excluded = self._as_list(cfg.get("remote_tools.xai.web.excluded_websites"), 5)
+            if allowed:
+                web["allowed_websites"] = allowed
+            elif excluded:
+                web["excluded_websites"] = excluded
+            safe = cfg.get("remote_tools.xai.web.safe_search")
+            if safe is not None:
+                web["safe_search"] = bool(safe)
+            sources.append(web)
+
+        if s_x:
+            xsrc: Dict[str, Any] = {"type": "x"}
+            inc = self._as_list(cfg.get("remote_tools.xai.x.included_handles"), 10)
+            exc = self._as_list(cfg.get("remote_tools.xai.x.excluded_handles"), 10)
+            if inc and not exc:
+                xsrc["included_x_handles"] = inc
+            elif exc and not inc:
+                xsrc["excluded_x_handles"] = exc
+            favs = cfg.get("remote_tools.xai.x.min_favs")
+            views = cfg.get("remote_tools.xai.x.min_views")
+            if isinstance(favs, int) and favs > 0:
+                xsrc["post_favorite_count"] = int(favs)
+            if isinstance(views, int) and views > 0:
+                xsrc["post_view_count"] = int(views)
+            sources.append(xsrc)
+
+        if s_news:
+            news: Dict[str, Any] = {"type": "news"}
+            country = cfg.get("remote_tools.xai.news.country")
+            if isinstance(country, str) and len(country.strip()) == 2:
+                news["country"] = country.strip().upper()
+            excluded = self._as_list(cfg.get("remote_tools.xai.news.excluded_websites"), 5)
+            if excluded:
+                news["excluded_websites"] = excluded
+            safe = cfg.get("remote_tools.xai.news.safe_search")
+            if safe is not None:
+                news["safe_search"] = bool(safe)
+            sources.append(news)
+
+        if s_rss:
+            link = cfg.get("remote_tools.xai.rss.link")
+            if isinstance(link, str) and link.strip():
+                sources.append({"type": "rss", "links": [link.strip()]})
+
+        if sources:
+            params["sources"] = sources
+
+        return params
+
+    def _has_list(self, v) -> bool:
+        """
+        Return True if v is a non-empty list/tuple or a non-empty comma-separated string.
+
+        :param v: Any
+        :return: bool
+        """
+        if v is None:
+            return False
+        if isinstance(v, (list, tuple)):
+            return len([x for x in v if str(x).strip()]) > 0
+        return len([x for x in str(v).split(",") if x.strip()]) > 0
+
+    def _has_str(self, v) -> bool:
+        """
+        Return True if v is a non-empty string.
+
+        :param v: Any
+        :return: bool
+        """
+        return isinstance(v, str) and bool(v.strip())
+
+    def _has_int(self, v) -> bool:
+        """
+        Return True if v is a positive integer.
+
+        :param v: Any
+        :return: true if v is a positive integer
+        """
+        return isinstance(v, int) and v > 0
+
+    def _as_list(self, v, limit: int) -> List[str]:
+        """
+        Convert v to a list of strings, limited to 'limit' items.
+
+        :param v: Any
+        :param limit: limit number of items
+        :return: List of strings
+        """
+        if v is None:
+            return []
+        if isinstance(v, (list, tuple)):
+            arr = [str(x).strip() for x in v if str(x).strip()]
+        else:
+            arr = [s.strip() for s in str(v).split(",") if s.strip()]
+        return arr[:limit]

pygpt_net/provider/api/x_ai/tools.py

@@ -0,0 +1,120 @@
+#!/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.09.05 01:00:00                  #
+# ================================================== #
+
+import json
+from typing import List, Any, Optional
+
+
+class Tools:
+    def __init__(self, window=None):
+        """
+        Tools mapper for xAI Chat Completions-compatible schema.
+
+        Input: app 'functions' list with keys: name, desc, params (JSON Schema string).
+        Output: list of dicts with keys: name, description, parameters.
+
+        :param window: Window instance
+        """
+        self.window = window
+
+    def _sanitize_schema(self, schema: Any) -> Any:
+        """
+        Sanitize JSON Schema for tool parameters:
+        - Remove unsupported or risky keywords.
+        - Normalize 'type'.
+        - Ensure properties/items recursively valid.
+
+        :param schema: JSON Schema (dict or list)
+        :return: Sanitized JSON Schema (dict)
+        """
+        if isinstance(schema, list):
+            return self._sanitize_schema(schema[0]) if schema else {}
+
+        if not isinstance(schema, dict):
+            return schema
+
+        banned = {
+            "$defs", "$ref", "$schema", "$id",
+            "oneOf", "anyOf", "allOf",
+            "patternProperties", "dependentSchemas", "dependentRequired",
+            "unevaluatedProperties", "nullable", "readOnly", "writeOnly",
+            "examples", "additional_properties", "additionalProperties",
+        }
+        for k in list(schema.keys()):
+            if k in banned:
+                schema.pop(k, None)
+
+        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 "object"
+
+        # Recurse
+        if (schema.get("type") or "").lower() == "object":
+            props = schema.get("properties")
+            if not isinstance(props, dict):
+                props = {}
+            clean = {}
+            for k, v in props.items():
+                clean[k] = self._sanitize_schema(v)
+            schema["properties"] = clean
+            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)
+
+        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)
+
+        return schema
+
+    def prepare(self, functions: list) -> List[dict]:
+        """
+        Prepare xAI tools list (OpenAI-compatible schema) from app functions list.
+
+        Returns [] if no functions provided.
+
+        :param functions: List of functions with keys: name (str), desc (str), params (JSON Schema str)
+        :return: List of tools with keys: name (str), description (str), parameters (dict)
+        """
+        if not functions or not isinstance(functions, list):
+            return []
+
+        tools: List[dict] = []
+        for fn in functions:
+            name = str(fn.get("name") or "").strip()
+            if not name:
+                continue
+            desc = fn.get("desc") or ""
+            params: Optional[dict] = {}
+            if fn.get("params"):
+                try:
+                    params = json.loads(fn["params"])
+                except Exception:
+                    params = {}
+                params = self._sanitize_schema(params or {})
+                if not params.get("type"):
+                    params["type"] = "object"
+            else:
+                params = {"type": "object"}
+
+            tools.append({
+                "name": name,
+                "description": desc,
+                "parameters": params,
+            })
+        return tools