pygpt-net 2.7.5__py3-none-any.whl → 2.7.7__py3-none-any.whl

pygpt_net/provider/api/x_ai/tools.py

@@ -6,20 +6,26 @@
 # GitHub:  https://github.com/szczyglis-dev/py-gpt   #
 # MIT License                                        #
 # Created By  : Marcin Szczygliński                  #
-# Updated Date: 2025.09.05 01:00:00                  #
+# Updated Date: 2026.01.04 19:00:00                  #
 # ================================================== #
 
 import json
 from typing import List, Any, Optional
 
+# xAI SDK client-side tool descriptor
+try:
+    from xai_sdk.chat import tool as x_tool
+except Exception:
+    x_tool = None
+
 
 class Tools:
     def __init__(self, window=None):
         """
-        Tools mapper for xAI Chat Completions-compatible schema.
+        Tools mapper for xAI.
 
-        Input: app 'functions' list with keys: name, desc, params (JSON Schema string).
-        Output: list of dicts with keys: name, description, parameters.
+        - prepare(): legacy OpenAI-compatible dicts (kept for compatibility if needed).
+        - prepare_sdk_tools(): xAI SDK client-side tool descriptors for Chat Responses.
 
         :param window: Window instance
         """
@@ -84,12 +90,10 @@ class Tools:
 
     def prepare(self, functions: list) -> List[dict]:
         """
-        Prepare xAI tools list (OpenAI-compatible schema) from app functions list.
-
-        Returns [] if no functions provided.
+        Prepare legacy xAI/OpenAI-compatible tools list from app functions list.
 
         :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)
+        :return: List of tools in dict format
         """
         if not functions or not isinstance(functions, list):
             return []
@@ -117,4 +121,51 @@ class Tools:
                 "description": desc,
                 "parameters": params,
             })
+        return tools
+
+    def prepare_sdk_tools(self, functions: list) -> List[object]:
+        """
+        Prepare xAI SDK client-side tool descriptors for Chat Responses.
+
+        :param functions: List of functions with keys: name (str), desc (str), params (JSON Schema str)
+        :return: List of xai_sdk.chat.tool(...) objects
+        """
+        if x_tool is None:
+            return []  # SDK too old; skip silently
+        if not functions or not isinstance(functions, list):
+            return []
+
+        tools: List[object] = []
+        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"}
+            try:
+                tools.append(x_tool(
+                    name=name,
+                    description=desc,
+                    parameters=params,
+                ))
+            except Exception:
+                # In case of schema issues, fallback to empty-params tool
+                try:
+                    tools.append(x_tool(
+                        name=name,
+                        description=desc,
+                        parameters={"type": "object"},
+                    ))
+                except Exception:
+                    continue
         return tools

pygpt_net/{controller/chat/handler → provider/api/x_ai}/utils.py

@@ -6,10 +6,9 @@
 # GitHub:  https://github.com/szczyglis-dev/py-gpt   #
 # MIT License                                        #
 # Created By  : Marcin Szczygliński                  #
-# Updated Date: 2025.09.05 00:00:00                  #
+# Updated Date: 2026.01.05 20:00:00                  #
 # ================================================== #
 
-import base64
 from typing import Any, Optional
 
 

pygpt_net/provider/api/x_ai/vision.py

@@ -6,7 +6,7 @@
 # GitHub:  https://github.com/szczyglis-dev/py-gpt   #
 # MIT License                                        #
 # Created By  : Marcin Szczygliński                  #
-# Updated Date: 2025.09.05 01:00:00                  #
+# Updated Date: 2026.01.04 19:00:00                  #
 # ================================================== #
 
 import os
@@ -50,9 +50,6 @@ class Vision:
             try:
                 if att.path and self.window.core.api.xai.vision.is_image(att.path):
                     mime = self.window.core.api.xai.vision.guess_mime(att.path)
-                    # Accept only JPEG/PNG for SDK too (for consistency)
-                    #if mime not in self.allowed_mimes:
-                       # continue
                     with open(att.path, "rb") as f:
                         b64 = base64.b64encode(f.read()).decode("utf-8")
                     images.append(f"data:{mime};base64,{b64}")

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: 2026.01.02 02:00:00                  #
+# Updated Date: 2026.01.05 20:00:00                  #
 # ================================================== #
 
 import copy
@@ -238,6 +238,27 @@ class Patch:
                     data["remote_store.openai.hide_threads"] = True
                 updated = True
 
+            # < 2.7.7
+            if old < parse_version("2.7.7"):
+                print("Migrating config from < 2.7.7...")
+                to_add = [
+                    "remote_tools.anthropic.code_execution",
+                    "remote_tools.anthropic.file_search",
+                    "remote_tools.anthropic.mcp",
+                    "remote_tools.anthropic.mcp.tools",
+                    "remote_tools.anthropic.mcp.mcp_servers",
+                    "remote_tools.anthropic.web_fetch",
+                    "remote_tools.xai.code_execution",
+                    "remote_tools.xai.mcp",
+                    "remote_tools.xai.mcp.args",
+                    "remote_tools.xai.web_search",
+                    "remote_tools.xai.x_search"
+                ]
+                for key in to_add:
+                    if key not in data:
+                        data[key] = cfg_get_base(key)
+                updated = True
+
         # update file
         migrated = False
         if updated:

pygpt_net/provider/core/model/patch.py

@@ -6,7 +6,7 @@
 # GitHub:  https://github.com/szczyglis-dev/py-gpt   #
 # MIT License                                        #
 # Created By  : Marcin Szczygliński                  #
-# Updated Date: 2026.01.03 02:10:00                  #
+# Updated Date: 2026.01.04 19:00:00                  #
 # ================================================== #
 
 from packaging.version import parse as parse_version, Version
@@ -116,6 +116,31 @@ class Patch:
                             data[model] = base_model
                 updated = True
 
+            # <  2.7.7 <--- add missing image input
+            if old < parse_version("2.7.7"):
+                print("Migrating models from < 2.7.7...")
+                models_to_add = [
+                    "grok-4-1-fast-non-reasoning",
+                    "grok-4-1-fast-reasoning",
+                    "grok-4-fast-non-reasoning",
+                    "grok-4-fast-reasoning"
+                ]
+                for model in models_to_add:
+                    if model not in data:
+                        base_model = from_base(model)
+                        if base_model:
+                            data[model] = base_model
+
+                models_to_update = [
+                    "grok-4"
+                ]
+                for model in models_to_update:
+                    if model in data:
+                        m = data[model]
+                        if not m.is_image_input():
+                            m.input.append("image")
+                updated = True
+
         # update file
         if updated:
             # fix empty/broken data

pygpt_net/tools/image_viewer/ui/dialogs.py

@@ -6,17 +6,18 @@
 # GitHub:  https://github.com/szczyglis-dev/py-gpt   #
 # MIT License                                        #
 # Created By  : Marcin Szczygliński                  #
-# Updated Date: 2025.08.24 23:00:00                  #
+# Updated Date: 2026.01.05 23:00:00                  #
 # ================================================== #
 
-from PySide6.QtCore import Qt
+from PySide6.QtCore import Qt, QPoint, QSize, QEvent
 from PySide6.QtGui import QAction, QIcon
-from PySide6.QtWidgets import QMenuBar, QVBoxLayout, QHBoxLayout, QSizePolicy
+from PySide6.QtWidgets import QMenuBar, QVBoxLayout, QHBoxLayout, QSizePolicy, QScrollArea
 
 from pygpt_net.ui.widget.dialog.base import BaseDialog
 from pygpt_net.ui.widget.image.display import ImageLabel
 from pygpt_net.utils import trans
 
+
 class DialogSpawner:
     def __init__(self, window=None):
         """
@@ -36,16 +37,23 @@ class DialogSpawner:
         :return: BaseDialog instance
         """
         dialog = ImageViewerDialog(self.window, self.id)
-        dialog.disable_geometry_store = True  # disable geometry store
+        dialog.disable_geometry_store = False
         dialog.id = id
+        dialog.shared_id = self.id
 
         source = ImageLabel(dialog, self.path)
         source.setVisible(False)
         pixmap = ImageLabel(dialog, self.path)
         pixmap.setSizePolicy(QSizePolicy(QSizePolicy.Ignored, QSizePolicy.Ignored))
 
+        # scrollable container for pixmap
+        scroll = QScrollArea(dialog)
+        scroll.setWidgetResizable(True)
+        scroll.setAlignment(Qt.AlignCenter)
+        scroll.setWidget(pixmap)
+
         row = QHBoxLayout()
-        row.addWidget(pixmap)
+        row.addWidget(scroll)
 
         layout = QVBoxLayout()
         layout.addLayout(row)
@@ -53,6 +61,10 @@ class DialogSpawner:
         dialog.append_layout(layout)
         dialog.source = source
         dialog.pixmap = pixmap
+        dialog.scroll_area = scroll
+
+        # install event filter for wheel zoom and panning and cursor changes
+        dialog.scroll_area.viewport().installEventFilter(dialog)
 
         return dialog
 
@@ -74,13 +86,32 @@ class ImageViewerDialog(BaseDialog):
         self.actions = {}
         self.source = None
         self.pixmap = None
+        self.scroll_area = None
+
+        # cache for image change / resize handling
         self._last_src_key = 0
         self._last_target_size = None
+
+        # icons
         self._icon_add = QIcon(":/icons/add.svg")
         self._icon_folder = QIcon(":/icons/folder.svg")
         self._icon_save = QIcon(":/icons/save.svg")
         self._icon_logout = QIcon(":/icons/logout.svg")
 
+        # zoom / pan state
+        self._zoom_mode = 'fit'  # 'fit' or 'manual'
+        self._zoom_factor = 1.0  # current manual factor (image space)
+        self._fit_factor = 1.0   # computed on-the-fly for fit mode
+        self._min_zoom = 0.05
+        self._max_zoom = 16.0
+        self._zoom_step = 1.25
+        self._drag_active = False
+        self._drag_last_pos = QPoint()
+
+        # performance guards to prevent extremely huge widget sizes
+        self._max_widget_dim = 32768          # max single dimension (px) for the view widget
+        self._max_total_pixels = 80_000_000   # max total pixels of the view widget (about 80MP)
+
     def append_layout(self, layout):
         """
         Update layout
@@ -98,18 +129,30 @@ class ImageViewerDialog(BaseDialog):
         """
         src = self.source.pixmap() if self.source is not None else None
         if src and not src.isNull() and self.pixmap is not None:
-            target_size = self.pixmap.size()
             key = src.cacheKey()
-            if key != self._last_src_key or target_size != self._last_target_size:
-                self.pixmap.setPixmap(
-                    src.scaled(
+            # reset to fit mode on new image
+            if key != self._last_src_key:
+                self._zoom_mode = 'fit'
+                self._zoom_factor = 1.0
+                if self.scroll_area is not None:
+                    self.scroll_area.setWidgetResizable(True)
+                # ensure no distortion in fit mode
+                if self.pixmap is not None:
+                    self.pixmap.setScaledContents(False)
+
+            if self._zoom_mode == 'fit':
+                target_size = self._viewport_size()
+                if key != self._last_src_key or target_size != self._last_target_size:
+                    # scale to viewport while keeping aspect ratio, smooth transform
+                    scaled = src.scaled(
                         target_size,
                         Qt.KeepAspectRatio,
                         Qt.SmoothTransformation
                     )
-                )
-                self._last_src_key = key
-                self._last_target_size = target_size
+                    self.pixmap.setPixmap(scaled)
+                    self._fit_factor = self._compute_fit_factor(src.size(), target_size)
+                    self._last_src_key = key
+                    self._last_target_size = target_size
         super(ImageViewerDialog, self).resizeEvent(event)
 
     def setup_menu(self) -> QMenuBar:
@@ -152,4 +195,248 @@ class ImageViewerDialog(BaseDialog):
         self.file_menu.addAction(self.actions["save_as"])
         self.file_menu.addAction(self.actions["exit"])
 
-        return self.menu_bar
+        return self.menu_bar
+
+    # =========================
+    # Zoom / pan implementation
+    # =========================
+
+    def eventFilter(self, obj, event):
+        """
+        Handle wheel zoom, panning and cursor changes on the scroll area viewport.
+        """
+        if self.scroll_area is None or obj is not self.scroll_area.viewport():
+            return super(ImageViewerDialog, self).eventFilter(obj, event)
+
+        et = event.type()
+
+        # Always show grab cursor when mouse is over the image area
+        if et == QEvent.Enter:
+            if self._has_image():
+                self.scroll_area.viewport().setCursor(Qt.OpenHandCursor)
+            return False
+
+        if et == QEvent.Leave:
+            self.scroll_area.viewport().unsetCursor()
+            return False
+
+        if et == QEvent.MouseButtonPress:
+            if event.button() == Qt.LeftButton and self._can_drag():
+                self._drag_active = True
+                self._drag_last_pos = self._event_pos(event)
+                self.scroll_area.viewport().setCursor(Qt.ClosedHandCursor)
+                event.accept()
+                return True
+            return False
+
+        if et == QEvent.MouseMove:
+            if self._drag_active:
+                pos = self._event_pos(event)
+                delta = pos - self._drag_last_pos
+                self._drag_last_pos = pos
+                # move scrollbars opposite to mouse movement
+                hbar = self.scroll_area.horizontalScrollBar()
+                vbar = self.scroll_area.verticalScrollBar()
+                hbar.setValue(hbar.value() - delta.x())
+                vbar.setValue(vbar.value() - delta.y())
+                event.accept()
+                return True
+            return False
+
+        if et == QEvent.MouseButtonRelease:
+            if event.button() == Qt.LeftButton and self._drag_active:
+                self._drag_active = False
+                # back to grab cursor
+                if self._has_image():
+                    self.scroll_area.viewport().setCursor(Qt.OpenHandCursor)
+                event.accept()
+                return True
+            return False
+
+        if et == QEvent.Wheel:
+            # zoom in/out with mouse wheel
+            if not self._has_image():
+                return False
+
+            # start manual zoom from current fit factor if needed
+            if self._zoom_mode == 'fit':
+                self._fit_factor = self._compute_fit_factor(
+                    self.source.pixmap().size(),
+                    self._viewport_size()
+                )
+                self._zoom_factor = self._fit_factor
+                self._zoom_mode = 'manual'
+                # switch to manual rendering path: original pixmap + scaled contents
+                self.scroll_area.setWidgetResizable(False)
+                self.pixmap.setScaledContents(True)
+                # ensure we display original image for better performance (no giant intermediate pixmaps)
+                self.pixmap.setPixmap(self.source.pixmap())
+
+            old_w = max(1, self.pixmap.width())
+            old_h = max(1, self.pixmap.height())
+
+            angle = 0
+            try:
+                angle = event.angleDelta().y()
+                if angle == 0:
+                    angle = event.angleDelta().x()
+            except Exception:
+                pass
+
+            if angle == 0:
+                return False
+
+            step = self._zoom_step if angle > 0 else (1.0 / self._zoom_step)
+            # compute tentative new factor and clamp by hard min/max and size guards
+            tentative = self._zoom_factor * step
+            tentative = max(self._min_zoom, min(self._max_zoom, tentative))
+            # apply size-based guards to avoid extremely huge widget sizes
+            tentative = self._clamp_factor_by_size(tentative)
+
+            if abs(tentative - self._zoom_factor) < 1e-9:
+                event.accept()
+                return True
+
+            vp_pos = self._event_pos(event)
+            hbar = self.scroll_area.horizontalScrollBar()
+            vbar = self.scroll_area.verticalScrollBar()
+
+            # position in content coords before zoom (keep point under cursor stable)
+            content_x = hbar.value() + vp_pos.x()
+            content_y = vbar.value() + vp_pos.y()
+            rx = content_x / float(old_w)
+            ry = content_y / float(old_h)
+
+            self._zoom_factor = tentative
+            self._set_scaled_pixmap_by_factor(self._zoom_factor)
+
+            new_w = max(1, self.pixmap.width())
+            new_h = max(1, self.pixmap.height())
+
+            hbar.setValue(int(rx * new_w - vp_pos.x()))
+            vbar.setValue(int(ry * new_h - vp_pos.y()))
+
+            event.accept()
+            return True
+
+        return super(ImageViewerDialog, self).eventFilter(obj, event)
+
+    def _has_image(self) -> bool:
+        """Check if source image is available."""
+        return (
+            self.source is not None
+            and self.source.pixmap() is not None
+            and not self.source.pixmap().isNull()
+            and self.pixmap is not None
+        )
+
+    def _can_drag(self) -> bool:
+        """Allow dragging only when image does not fit into the viewport."""
+        if not self._has_image():
+            return False
+        if self._zoom_mode != 'manual':
+            return False
+        vp = self._viewport_size()
+        return self.pixmap.width() > vp.width() or self.pixmap.height() > vp.height()
+
+    def _viewport_size(self) -> QSize:
+        """Get current viewport size."""
+        if self.scroll_area is not None:
+            return self.scroll_area.viewport().size()
+        return self.size()
+
+    def _compute_fit_factor(self, img_size: QSize, target: QSize) -> float:
+        """Compute factor for fitting image into target size."""
+        iw = max(1, img_size.width())
+        ih = max(1, img_size.height())
+        tw = max(1, target.width())
+        th = max(1, target.height())
+        return min(tw / float(iw), th / float(ih))
+
+    def _clamp_factor_by_size(self, factor: float) -> float:
+        """
+        Clamp zoom factor to avoid creating extremely large widget sizes.
+        This keeps interactivity smooth by limiting max resulting dimensions and total pixels.
+        """
+        src = self.source.pixmap()
+        if not src or src.isNull():
+            return factor
+
+        iw = max(1, src.width())
+        ih = max(1, src.height())
+
+        # only guard when zooming in; zooming out should not be limited by these caps
+        if factor <= 1.0:
+            return factor
+
+        # desired size
+        dw = iw * factor
+        dh = ih * factor
+
+        scale = 1.0
+
+        # total pixel cap
+        total = dw * dh
+        if total > self._max_total_pixels:
+            from math import sqrt
+            scale = min(scale, sqrt(self._max_total_pixels / float(total)))
+
+        # dimension caps
+        if dw * scale > self._max_widget_dim:
+            scale = min(scale, self._max_widget_dim / float(dw))
+        if dh * scale > self._max_widget_dim:
+            scale = min(scale, self._max_widget_dim / float(dh))
+
+        if scale < 1.0:
+            return max(self._min_zoom, factor * scale)
+        return factor
+
+    def _set_scaled_pixmap_by_factor(self, factor: float):
+        """
+        Scale and display the image using provided factor relative to the original image.
+        In manual mode this avoids allocating giant intermediate QPixmaps by:
+        - drawing the original pixmap;
+        - enabling scaled contents;
+        - resizing the label to the required size.
+        """
+        if not self._has_image():
+            return
+
+        src = self.source.pixmap()
+        iw = max(1, src.width())
+        ih = max(1, src.height())
+
+        # target size based on factor (KeepAspectRatio preserved by proportional math)
+        new_w = max(1, int(round(iw * factor)))
+        new_h = max(1, int(round(ih * factor)))
+
+        # enforce guards once more to be safe
+        guarded_factor = self._clamp_factor_by_size(factor)
+        if abs(guarded_factor - factor) > 1e-9:
+            new_w = max(1, int(round(iw * guarded_factor)))
+            new_h = max(1, int(round(ih * guarded_factor)))
+            self._zoom_factor = guarded_factor  # keep internal factor in sync
+
+        if self._zoom_mode == 'manual':
+            # ensure manual path uses original pixmap and scaled contents
+            if self.pixmap.pixmap() is None or self.pixmap.pixmap().cacheKey() != src.cacheKey():
+                self.pixmap.setPixmap(src)
+            self.pixmap.setScaledContents(True)
+            self.pixmap.resize(new_w, new_h)
+        else:
+            # fallback (not expected here): keep classic high-quality scaling
+            scaled = src.scaled(new_w, new_h, Qt.KeepAspectRatio, Qt.SmoothTransformation)
+            self.pixmap.setScaledContents(False)
+            self.pixmap.setPixmap(scaled)
+            if self.scroll_area is not None:
+                self.scroll_area.setWidgetResizable(True)
+
+    def _event_pos(self, event) -> QPoint:
+        """
+        Extract integer QPoint from mouse/touchpad event position (supports QPointF in 6.9+).
+        """
+        if hasattr(event, "position"):
+            return event.position().toPoint()
+        if hasattr(event, "pos"):
+            return event.pos()
+        return QPoint(0, 0)

pygpt_net/tools/text_editor/ui/dialogs.py

@@ -6,7 +6,7 @@
 # GitHub:  https://github.com/szczyglis-dev/py-gpt   #
 # MIT License                                        #
 # Created By  : Marcin Szczygliński                  #
-# Updated Date: 2024.03.26 15:00:00                  #
+# Updated Date: 2026.01.05 23:00:00                  #
 # ================================================== #
 
 from PySide6.QtWidgets import QPushButton, QHBoxLayout, QVBoxLayout
@@ -63,8 +63,9 @@ class DialogSpawner:
         layout.addLayout(bottom_layout)
 
         dialog = EditorFileDialog(self.window)
-        dialog.disable_geometry_store = True  # disable geometry store
+        dialog.disable_geometry_store = False
         dialog.id = id
+        dialog.shared_id = "text-edit"
         dialog.append_layout(layout)
         dialog.setWindowTitle("Text editor")
 

pygpt_net/tools/text_editor/ui/widgets.py

@@ -6,7 +6,7 @@
 # GitHub:  https://github.com/szczyglis-dev/py-gpt   #
 # MIT License                                        #
 # Created By  : Marcin Szczygliński                  #
-# Updated Date: 2025.08.24 23:00:00                  #
+# Updated Date: 2026.01.03 00:00:00                  #
 # ================================================== #
 
 from PySide6.QtGui import QAction, QIcon, QKeySequence
@@ -67,6 +67,10 @@ class TextFileEditor(BaseCodeEditor):
             )
             menu.addAction(action)
 
+        # Add zoom submenu
+        zoom_menu = self.window.ui.context_menu.get_zoom_menu(self, "editor", self.value, self.on_zoom_changed)
+        menu.addMenu(zoom_menu)
+
         action = QAction(self._icon_search, trans('text.context_menu.find'), menu)
         action.triggered.connect(self.find_open)
         action.setShortcut(QKeySequence.StandardKey.Find)