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

pygpt_net/ui/widget/option/combo.py

@@ -6,7 +6,7 @@
 # GitHub:  https://github.com/szczyglis-dev/py-gpt   #
 # MIT License                                        #
 # Created By  : Marcin Szczygliński                  #
-# Updated Date: 2025.07.12 19:00:00                  #
+# Updated Date: 2025.09.02 16:00:00                  #
 # ================================================== #
 
 from PySide6.QtCore import Qt
@@ -109,6 +109,8 @@ class OptionCombo(QWidget):
             for item in self.keys:
                 if type(item) is dict:
                     for key, value in item.items():
+                        if not isinstance(key, str):
+                            key = str(key)
                         if key.startswith("separator::"):
                             self.combo.addSeparator(value)
                         else:
@@ -117,6 +119,8 @@ class OptionCombo(QWidget):
                     self.combo.addItem(item, item)
         elif type(self.keys) is dict:
             for key, value in self.keys.items():
+                if not isinstance(key, str):
+                    key = str(key)
                 if key.startswith("separator::"):
                     self.combo.addSeparator(value)
                 else:

pygpt_net/ui/widget/textarea/input.py

@@ -6,12 +6,13 @@
 # GitHub:  https://github.com/szczyglis-dev/py-gpt   #
 # MIT License                                        #
 # Created By  : Marcin Szczygliński                  #
-# Updated Date: 2025.08.27 07:00:00                  #
+# Updated Date: 2025.09.03 00:00:00                  #
 # ================================================== #
 
 from typing import Optional
+import math
 
-from PySide6.QtCore import Qt, QSize
+from PySide6.QtCore import Qt, QSize, QTimer, QEvent
 from PySide6.QtGui import QAction, QIcon, QImage
 from PySide6.QtWidgets import (
     QTextEdit,
@@ -90,6 +91,24 @@ class ChatInput(QTextEdit):
         # Apply initial margins (top padding + left space for icons)
         self._apply_margins()
 
+        # ---- Auto-resize config (input in splitter) ----
+        self._auto_max_lines = 10  # max lines for auto-expansion
+        self._auto_max_ratio = 0.25  # max fraction of main window height
+        self._auto_debounce_ms = 0  # coalesce updates in next event loop turn
+        self._auto_updating = False  # reentrancy guard
+        self._splitter_resize_in_progress = False
+        self._splitter_connected = False
+        self._user_adjusting_splitter = False
+        self._auto_pause_ms_after_user_drag = 350
+        self._last_target_container_h = None
+
+        self._auto_timer = QTimer(self)
+        self._auto_timer.setSingleShot(True)
+        self._auto_timer.timeout.connect(self._auto_resize_tick)
+
+        # Trigger auto-resize on text changes (tokens update stays intact)
+        self.textChanged.connect(self._schedule_auto_resize)
+
     def _apply_text_top_padding(self):
         """Apply extra top padding inside the text area by using viewport margins."""
         # Left margin is computed in _apply_margins()
@@ -213,6 +232,9 @@ class ChatInput(QTextEdit):
                         self.window.controller.chat.input.send_input()
                         handled = True
                 self.setFocus()
+                # Collapse to minimum after sending
+                if handled:
+                    QTimer.singleShot(0, self.collapse_to_min)
         elif key == Qt.Key_Escape and self.window.controller.ctx.extra.is_editing():
             self.window.controller.ctx.extra.edit_cancel()
             handled = True
@@ -240,10 +262,17 @@ class ChatInput(QTextEdit):
                 self.window.core.config.data['font_size.input'] = self.value
                 self.window.core.config.save()
                 self.window.controller.ui.update_font_size()
+                # Reflow may change number of lines; adjust auto-height next tick
+                QTimer.singleShot(0, self._schedule_auto_resize)
             event.accept()
             return
         super().wheelEvent(event)
 
+    def changeEvent(self, event):
+        super().changeEvent(event)
+        if event.type() == QEvent.FontChange:
+            self._schedule_auto_resize()
+
     def action_add_attachment(self):
         """Add attachment (button click)."""
         self.window.controller.attachment.open_add()
@@ -672,4 +701,245 @@ class ChatInput(QTextEdit):
         try:
             self._reposition_icon_bar()
         except Exception:
-            pass
+            pass
+        # Recompute on width changes (word wrap may change line count)
+        if not self._splitter_resize_in_progress:
+            if self.hasFocus():
+                self._schedule_auto_resize()
+            else:
+                # Allow shrinking to minimum when content is single line
+                self._schedule_auto_resize(enforce_minimize_if_single=True)
+
+    # ================== Auto-resize inside QSplitter ==================
+
+    def _ensure_splitter_hook(self):
+        """Lazy-connect to main splitter to detect manual drags."""
+        if self._splitter_connected:
+            return
+        splitter = self._get_main_splitter()
+        if splitter is not None:
+            try:
+                splitter.splitterMoved.connect(self._on_splitter_moved_by_user)
+                self._splitter_connected = True
+            except Exception:
+                pass
+
+    def _on_splitter_moved_by_user(self, pos, index):
+        """Pause auto-resize briefly while the user drags the splitter."""
+        self._user_adjusting_splitter = True
+        QTimer.singleShot(self._auto_pause_ms_after_user_drag, self._reset_user_adjusting_flag)
+
+    def _reset_user_adjusting_flag(self):
+        self._user_adjusting_splitter = False
+
+    def _get_main_splitter(self):
+        """Get main vertical splitter from window registry."""
+        try:
+            return self.window.ui.splitters.get('main.output')
+        except Exception:
+            return None
+
+    def _find_container_in_splitter(self, splitter):
+        """Find the direct child of splitter that contains this ChatInput."""
+        if splitter is None:
+            return None, -1
+        for i in range(splitter.count()):
+            w = splitter.widget(i)
+            if w and w.isAncestorOf(self):
+                return w, i
+        return None, -1
+
+    def _schedule_auto_resize(self, force: bool = False, enforce_minimize_if_single: bool = False):
+        """Schedule auto-resize; multiple calls are coalesced."""
+        # Store flags for the next tick
+        self._pending_force = getattr(self, "_pending_force", False) or bool(force)
+        self._pending_minimize_if_single = getattr(self, "_pending_minimize_if_single", False) or bool(
+            enforce_minimize_if_single)
+        # Avoid scheduling when splitter drag in progress
+        if self._user_adjusting_splitter or self._splitter_resize_in_progress:
+            return
+        self._ensure_splitter_hook()
+        # Debounce to next event loop to ensure document layout is up to date
+        if not self._auto_timer.isActive():
+            self._auto_timer.start(self._auto_debounce_ms)
+
+    def _auto_resize_tick(self):
+        """Execute auto-resize once after debounce."""
+        force = getattr(self, "_pending_force", False)
+        minimize_if_single = getattr(self, "_pending_minimize_if_single", False)
+        self._pending_force = False
+        self._pending_minimize_if_single = False
+        try:
+            self._update_auto_height(force=force, minimize_if_single=minimize_if_single)
+        except Exception:
+            # Never break input pipeline on errors
+            pass
+
+    def _document_content_height(self) -> int:
+        """Return QTextDocument layout height in pixels."""
+        doc = self.document()
+        layout = doc.documentLayout()
+        if layout is not None:
+            h = layout.documentSize().height()
+        else:
+            h = doc.size().height()
+        return int(math.ceil(h))
+
+    def _line_spacing(self) -> int:
+        """Return current line spacing for font."""
+        return int(math.ceil(self.fontMetrics().lineSpacing()))
+
+    def _effective_lines(self, doc_h: int, line_h: int, doc_margin: float) -> float:
+        """Rough estimate of visible line count from document height."""
+        base = max(0.0, doc_h - 2.0 * float(doc_margin))
+        if line_h <= 0:
+            return 1.0
+        return max(1.0, base / float(line_h))
+
+    def _min_input_widget_height(self, non_viewport_h: int) -> int:
+        """Height of QTextEdit widget required to fit a single line without scrollbars."""
+        line_h = self._line_spacing()
+        doc_margin = float(self.document().documentMargin())
+        min_viewport_h = int(math.ceil(2.0 * doc_margin + line_h))
+        # Respect current minimum size hint to avoid jitter on some styles
+        min_hint = max(self.minimumSizeHint().height(), 0)
+        return max(min_hint, min_viewport_h + non_viewport_h)
+
+    def _max_input_widget_height_by_lines(self, non_viewport_h: int) -> int:
+        """Max widget height allowed by line count cap."""
+        line_h = self._line_spacing()
+        doc_margin = float(self.document().documentMargin())
+        max_viewport_h = int(math.ceil(2.0 * doc_margin + self._auto_max_lines * line_h))
+        return max_viewport_h + non_viewport_h
+
+    def _should_shrink_to_min(self, doc_h: int) -> bool:
+        """Decide if we should collapse to minimum (single line or empty)."""
+        line_h = self._line_spacing()
+        doc_margin = float(self.document().documentMargin())
+        threshold = 2.0 * doc_margin + 1.25 * line_h  # small slack for layout rounding
+        return doc_h <= threshold
+
+    def _update_auto_height(self, force: bool = False, minimize_if_single: bool = False):
+        """
+        Core auto-resize routine:
+        - expand only when the input has focus (unless force=True),
+        - cap by max lines and 1/4 of main window height,
+        - shrink back to minimal only after send or when text is effectively one line.
+        """
+        if self._auto_updating or self._splitter_resize_in_progress:
+            return
+
+        splitter = self._get_main_splitter()
+        container, idx = self._find_container_in_splitter(splitter)
+        if splitter is None or container is None or idx < 0:
+            return  # Not yet attached to the splitter
+
+        # Expansion only with focus unless forced
+        has_focus = self.hasFocus()
+        can_expand = force or has_focus
+        if self._user_adjusting_splitter and not force:
+            return
+
+        # Measure current layout and targets
+        doc_h = self._document_content_height()
+        non_viewport_h = self.height() - self.viewport().height()
+        needed_input_h = int(math.ceil(doc_h + non_viewport_h))
+        min_input_h = self._min_input_widget_height(non_viewport_h)
+        max_input_by_lines = self._max_input_widget_height_by_lines(non_viewport_h)
+
+        # Container overhead above the inner QTextEdit
+        container_overhead = max(0, container.height() - self.height())
+        needed_container_h = needed_input_h + container_overhead
+        min_container_h = min_input_h + container_overhead
+
+        # Max cap by window fraction
+        try:
+            max_container_by_ratio = int(self.window.height() * self._auto_max_ratio)
+        except Exception:
+            max_container_by_ratio = 0  # fallback disables ratio cap if window unavailable
+
+        max_container_by_lines = max_input_by_lines + container_overhead
+        cap_container_max = max_container_by_lines
+        if max_container_by_ratio > 0:
+            cap_container_max = min(cap_container_max, max_container_by_ratio)
+
+        current_sizes = splitter.sizes()
+        if idx >= len(current_sizes):
+            return
+        current_container_h = current_sizes[idx]
+
+        # Decide on action
+        target_container_h = None
+
+        # Shrink only when requested or effectively single line
+        if minimize_if_single or self._should_shrink_to_min(doc_h):
+            if current_container_h > min_container_h + 1:
+                target_container_h = min_container_h
+
+        # Expand if focused (or forced), but only up to caps
+        elif can_expand:
+            desired = min(needed_container_h, cap_container_max)
+            if desired > current_container_h + 1:
+                target_container_h = desired
+
+        # Apply if needed
+        if target_container_h is None:
+            return
+
+        total = sum(current_sizes)
+        # Clamp to splitter total height
+        target_container_h = max(0, min(target_container_h, total))
+
+        if abs(target_container_h - current_container_h) <= 1:
+            return
+
+        # Prepare new sizes (2 widgets expected: output at 0, input at 1)
+        new_sizes = list(current_sizes)
+        # Distribute delta to other panes; here we have exactly 2
+        other_total = total - current_container_h
+        new_other_total = total - target_container_h
+        if other_total <= 0:
+            # degenerate case; just set directly
+            pass
+        else:
+            # Scale other widgets proportionally
+            scale = new_other_total / float(other_total) if other_total > 0 else 1.0
+            for i in range(len(new_sizes)):
+                if i != idx:
+                    new_sizes[i] = int(round(new_sizes[i] * scale))
+        new_sizes[idx] = int(target_container_h)
+
+        # Final clamp to preserve sum
+        diff = total - sum(new_sizes)
+        if diff != 0 and len(new_sizes) > 0:
+            # Adjust the first non-target pane to fix rounding
+            for i in range(len(new_sizes)):
+                if i != idx:
+                    new_sizes[i] += diff
+                    break
+
+        self._splitter_resize_in_progress = True
+        try:
+            old_block = splitter.blockSignals(True)
+            splitter.setSizes(new_sizes)
+            splitter.blockSignals(old_block)
+        finally:
+            self._splitter_resize_in_progress = False
+
+        # Keep stored sizes in sync with app expectations (mirrors ChatMain.on_splitter_moved)
+        try:
+            tabs = self.window.ui.tabs
+            if "input" in tabs:
+                t_idx = tabs['input'].currentIndex()
+                if t_idx != 0:
+                    self.window.controller.ui.splitter_output_size_files = new_sizes
+                else:
+                    self.window.controller.ui.splitter_output_size_input = new_sizes
+        except Exception:
+            pass
+
+        self._last_target_container_h = target_container_h
+
+    def collapse_to_min(self):
+        """Public helper to collapse input area to minimal height."""
+        self._schedule_auto_resize(force=True, enforce_minimize_if_single=True)

pygpt_net/ui/widget/textarea/web.py

@@ -566,6 +566,8 @@ class Bridge(QObject):
         self.window = window
 
     chunk = Signal(str, str, str, bool, bool)  # name, buffer, chunk, replace, is_code
+    node = Signal(str)  # content
+    nodeReplace = Signal(str)  # content
     readyChanged = Signal(bool)
 
     @Slot()

{pygpt_net-2.6.33.dist-info → pygpt_net-2.6.36.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: pygpt-net
-Version: 2.6.33
+Version: 2.6.36
 Summary: Desktop AI Assistant powered by: OpenAI GPT-5, GPT-4, o1, o3, Gemini, Claude, Grok, DeepSeek, and other models supported by Llama Index, and Ollama. Chatbot, agents, completion, image generation, vision analysis, speech-to-text, plugins, internet access, file handling, command execution and more.
 License: MIT
 Keywords: ai,api,api key,app,assistant,bielik,chat,chatbot,chatgpt,claude,dall-e,deepseek,desktop,gemini,gpt,gpt-3.5,gpt-4,gpt-4-vision,gpt-4o,gpt-5,gpt-oss,gpt3.5,gpt4,grok,langchain,llama-index,llama3,mistral,o1,o3,ollama,openai,presets,py-gpt,py_gpt,pygpt,pyside,qt,text completion,tts,ui,vision,whisper
@@ -118,7 +118,7 @@ Description-Content-Type: text/markdown
 
 [![pygpt](https://snapcraft.io/pygpt/badge.svg)](https://snapcraft.io/pygpt)
 
-Release: **2.6.33** | build: **2025-09-02** | Python: **>=3.10, <3.14**
+Release: **2.6.36** | build: **2025-09-04** | Python: **>=3.10, <3.14**
 
 > Official website: https://pygpt.net | Documentation: https://pygpt.readthedocs.io
 > 
@@ -3565,6 +3565,24 @@ may consume additional tokens that are not displayed in the main window.
 
 ## Recent changes:
 
+**2.6.36 (2025-09-04)**
+
+- Optimized rendering of large code blocks.
+
+**2.6.35 (2025-09-04)**
+
+- Improved responsiveness in chat streaming.
+- Added zoom, fit, and auto-scroll on crop in Painter.
+- Added a scroll-up button in the chat window.
+- Optimized memory usage.
+
+**2.6.34 (2025-09-03)**
+
+- Added auto-resizing for input.
+- Added file management to the OpenAI Vector Stores tool.
+- Implemented removal of script tags when exporting HTML.
+- Enabled maintaining custom resolution in Painter.
+
 **2.6.33 (2025-09-02)**
 
 - Added a "crop" option, auto-resize canvas, and layer support to Painter.