pygpt-net 2.6.61__py3-none-any.whl → 2.6.63__py3-none-any.whl

pygpt_net/ui/widget/node_editor/editor.py

@@ -6,7 +6,7 @@
 # GitHub:  https://github.com/szczyglis-dev/py-gpt   #
 # MIT License                                        #
 # Created By  : Marcin Szczygliński                  #
-# Updated Date: 2025.09.25 12:35:00                  #
+# Updated Date: 2025.09.26 12:00:00                  #
 # ================================================== #
 
 from __future__ import annotations
@@ -143,18 +143,6 @@ class NodeEditor(QWidget):
         # Centralized strings
         self.config: EditorConfig = config if isinstance(config, EditorConfig) else EditorConfig()
 
-        # Theme and palette
-        """
-        if parent and hasattr(parent, "window"):
-            theme = parent.window.core.config.get("theme")
-            if theme.startswith("light"):
-                print("[NodeEditor] Detected light theme from parent")
-                self._grid_back_color = QColor(255, 255, 255)
-                self._grid_pen_color = QColor(230, 230, 230)
-                self.gridBackColor = Property(QColor, lambda self: self._grid_back_color, lambda self, v: self._q_set("_grid_back_color", v))
-                self.gridPenColor = Property(QColor, lambda self: self._grid_pen_color, lambda self, v: self._q_set("_grid_pen_color", v))
-        """
-
         self.graph = NodeGraph(registry)
         self.scene = NodeGraphicsScene(self)
         self.view = NodeGraphicsView(self.scene, self)
@@ -422,7 +410,12 @@ class NodeEditor(QWidget):
 
     def add_node(self, type_name: str, scene_pos: QPointF):
         """Add a new node of the given type at scene_pos (undoable)."""
+        # Enforce optional per-type limit configured in registry.
+        if not self._can_add_node_of_type(type_name):
+            self._dbg(f"add_node blocked: type='{type_name}' reached its max per-layout limit")
+            return False
         self._undo.push(AddNodeCommand(self, type_name, scene_pos))
+        return True
 
     def clear(self, ask_user: bool = True):
         """Clear the entire editor (undoable), optionally asking the user for confirmation."""
@@ -438,6 +431,7 @@ class NodeEditor(QWidget):
             if reply != QMessageBox.Yes:
                 return False
         self._undo.push(ClearGraphCommand(self))
+        self._update_status_label()
         return True
 
     def undo(self):
@@ -668,6 +662,35 @@ class NodeEditor(QWidget):
         vp_pt = self.view.mapFromScene(scene_pos)
         return self.view.viewport().mapToGlobal(vp_pt)
 
+    # ---------- Per-type limit helpers ----------
+
+    def _type_limit(self, type_name: str) -> Optional[int]:
+        """Return configured max_num for type or None if unlimited."""
+        spec = self.graph.registry.get(type_name) if self.graph and self.graph.registry else None
+        if not spec:
+            return None
+        try:
+            limit = getattr(spec, "max_num", None)
+            if isinstance(limit, int) and limit <= 0:
+                return None
+            return limit if isinstance(limit, int) else None
+        except Exception:
+            return None
+
+    def _count_nodes_of_type(self, type_name: str) -> int:
+        """Count current nodes of a given type in the live graph."""
+        try:
+            return sum(1 for n in self.graph.nodes.values() if getattr(n, "type", None) == type_name)
+        except Exception:
+            return 0
+
+    def _can_add_node_of_type(self, type_name: str) -> bool:
+        """Check whether adding another node of given type is allowed by max_num."""
+        limit = self._type_limit(type_name)
+        if limit is None:
+            return True
+        return self._count_nodes_of_type(type_name) < int(limit)
+
     def _on_scene_context_menu(self, scene_pos: QPointF):
         """Show context menu for adding nodes and undo/redo/clear at empty scene position."""
         try:
@@ -685,7 +708,21 @@ class NodeEditor(QWidget):
         add_menu = menu.addMenu(self.config.menu_add())
         action_by_type: Dict[QAction, str] = {}
         for tname in self.graph.registry.types():
-            act = add_menu.addAction(tname)
+            # Prefer UI-only display name; fallback to identifier (type_name)
+            try:
+                label = self.graph.registry.display_name(tname)
+            except Exception:
+                label = tname
+            act = add_menu.addAction(label)
+            # Show the underlying identifier in tooltip to make UI/ID relation explicit
+            if label != tname:
+                try:
+                    act.setToolTip(tname)
+                except Exception:
+                    pass
+            # Disable when limit reached (evaluated in real-time, per layout)
+            if not self._can_add_node_of_type(tname):
+                act.setEnabled(False)
             action_by_type[act] = tname
 
         menu.addSeparator()
@@ -711,7 +748,8 @@ class NodeEditor(QWidget):
             self.clear(ask_user=True)
         elif chosen in action_by_type:
             type_name = action_by_type[chosen]
-            self._undo.push(AddNodeCommand(self, type_name, scene_pos))
+            # Route through editor.add_node() to enforce limit guards
+            self.add_node(type_name, scene_pos)
 
     # ---------- Z-order helpers ----------
 

pygpt_net/ui/widget/node_editor/node.py

@@ -6,7 +6,7 @@
 # GitHub:  https://github.com/szczyglis-dev/py-gpt   #
 # MIT License                                        #
 # Created By  : Marcin Szczygliński                  #
-# Updated Date: 2025.09.25 15:32:39                  #
+# Updated Date: 2025.09.26 10:00:00                  #
 # ================================================== #
 
 from __future__ import annotations
@@ -44,6 +44,9 @@ class SingleLineTextEdit(QTextEdit):
         self.setTabChangesFocus(True)
         self.setFrameStyle(QFrame.NoFrame)
         self.document().setDocumentMargin(2)
+        # Enforce line-edit-like behavior with no context menu
+        # (widget menus are disabled by design; only node menu remains)
+        self.setContextMenuPolicy(Qt.NoContextMenu)
         self._update_height()
 
     def _update_height(self):
@@ -86,58 +89,13 @@ class SingleLineTextEdit(QTextEdit):
             c.setPosition(min(pos, len(t2)))
             self.setTextCursor(c)
 
-    def _apply_menu_theme(self, menu: QMenu):
-        """Apply app/window stylesheet + palette + font to context menu."""
-        try:
-            wnd = self.window()
-        except Exception:
-            wnd = None
-        stylesheet = ""
-        pal = None
-        font = None
-        try:
-            if wnd:
-                stylesheet = wnd.styleSheet() or ""
-                pal = wnd.palette()
-                font = wnd.font()
-        except Exception:
-            pass
-        try:
-            app = QApplication.instance()
-            if app:
-                if not stylesheet and app.styleSheet():
-                    stylesheet = app.styleSheet()
-                if pal is None:
-                    pal = app.palette()
-                if font is None:
-                    font = app.font()
-        except Exception:
-            pass
-        try:
-            if pal:
-                menu.setPalette(pal)
-            if font:
-                menu.setFont(font)
-            if stylesheet:
-                menu.setStyleSheet(stylesheet)
-            menu.ensurePolished()
-        except Exception:
-            pass
-
     def contextMenuEvent(self, e):
-        """Ensure standard context menu follows app-wide (e.g., Qt Material) styling."""
+        """Widget-level context menu is intentionally disabled."""
         try:
-            menu = self.createStandardContextMenu()
+            e.ignore()
         except Exception:
-            return super().contextMenuEvent(e)
-        self._apply_menu_theme(menu)
-        try:
-            menu.exec(e.globalPos())
-        finally:
-            try:
-                menu.deleteLater()
-            except Exception:
-                pass
+            pass
+        return
 
 
 class NodeContentWidget(QWidget):
@@ -229,6 +187,8 @@ class NodeContentWidget(QWidget):
             elif pm.type == "text":
                 te = QTextEdit()
                 te.setFocusPolicy(Qt.StrongFocus)
+                # Disable widget-level context menu completely (only node menu is available)
+                te.setContextMenuPolicy(Qt.NoContextMenu)
                 if pm.value is not None:
                     te.setPlainText(str(pm.value))
                 te.setReadOnly(not editable)
@@ -238,8 +198,6 @@ class NodeContentWidget(QWidget):
                     except Exception:
                         pass
                 te.textChanged.connect(lambda pid=pid, te=te: self.valueChanged.emit(pid, te.toPlainText()))
-                # Ensure context menu follows global (Material) style
-                self._install_styled_context_menu(te)
                 w = te
 
             elif pm.type == "int":
@@ -314,57 +272,6 @@ class NodeContentWidget(QWidget):
                 except Exception:
                     pass
 
-    def _install_styled_context_menu(self, te: QTextEdit):
-        """Install a custom context menu handler that applies global styles."""
-        try:
-            te.setContextMenuPolicy(Qt.CustomContextMenu)
-            te.customContextMenuRequested.connect(
-                lambda pos, _te=te: self._show_styled_standard_menu(_te, pos)
-            )
-        except Exception:
-            pass
-
-    def _show_styled_standard_menu(self, te: QTextEdit, pos):
-        """Create standard menu and apply app/window stylesheet + palette + font."""
-        try:
-            menu = te.createStandardContextMenu()
-        except Exception:
-            return
-        stylesheet = ""
-        pal = None
-        font = None
-        try:
-            # Prefer editor helpers (consistent with the rest of NodeEditor)
-            stylesheet = self.editor._current_stylesheet()
-            pal = self.editor._current_palette()
-            font = self.editor._current_font()
-        except Exception:
-            try:
-                wnd = te.window()
-                if wnd:
-                    stylesheet = wnd.styleSheet() or ""
-                    pal = wnd.palette()
-                    font = wnd.font()
-            except Exception:
-                pass
-        try:
-            if pal:
-                menu.setPalette(pal)
-            if font:
-                menu.setFont(font)
-            if stylesheet:
-                menu.setStyleSheet(stylesheet)
-            menu.ensurePolished()
-        except Exception:
-            pass
-        try:
-            menu.exec(te.mapToGlobal(pos))
-        finally:
-            try:
-                menu.deleteLater()
-            except Exception:
-                pass
-
     def event(self, e):
         """
         Filter ShortcutOverride so editor keystrokes are not eaten by the scene.
@@ -825,7 +732,7 @@ class NodeItem(QGraphicsWidget):
     def _effective_hit_margin(self) -> float:
         """Return the effective resize-grip 'hit' margin (visual margin minus inset)."""
         margin = float(getattr(self.editor, "_resize_grip_margin", 12.0) or 12.0)
-        inset = float(getattr(self.editor, "_resize_grip_hit_inset", 3.0) or 0.0)
+        inset = float(getattr(self.editor, "_resize_grip_hit_inset", 5.0) or 0.0)
         hit = max(4.0, margin - inset)
         return hit
 
@@ -1216,6 +1123,77 @@ class NodeItem(QGraphicsWidget):
         """Filter events on proxy/content to keep hover/ports/overlay in sync."""
         et = e.type()
         try:
+            # Forward RMB on the proxy (covers all embedded editors) to node menu
+            if obj is self._proxy:
+                if et == QEvent.GraphicsSceneMousePress:
+                    try:
+                        if e.button() == Qt.RightButton:
+                            # Use screenPos if available; fallback to view mapping
+                            gp = e.screenPos() if hasattr(e, "screenPos") else None
+                            if gp is None:
+                                sp = e.scenePos()
+                                vp = self.editor.view.mapFromScene(sp)
+                                gp = self.editor.view.viewport().mapToGlobal(vp)
+                            # Reuse node menu logic here for consistency
+                            menu = QMenu(self.editor.window())
+                            ss = self.editor.window().styleSheet()
+                            if ss:
+                                menu.setStyleSheet(ss)
+                            act_rename = QAction(self.editor.config.node_context_rename(), menu)
+                            act_delete = QAction(self.editor.config.node_context_delete(), menu)
+                            menu.addAction(act_rename)
+                            menu.addSeparator()
+                            menu.addAction(act_delete)
+                            chosen = menu.exec(gp.toPoint() if hasattr(gp, "toPoint") else gp)
+                            if chosen == act_rename:
+                                from PySide6.QtWidgets import QInputDialog
+                                new_name, ok = QInputDialog.getText(
+                                    self.editor.window(),
+                                    self.editor.config.rename_dialog_title(),
+                                    self.editor.config.rename_dialog_label(),
+                                    text=self.node.name
+                                )
+                                if ok and new_name:
+                                    self.node.name = new_name
+                                    self.update()
+                            elif chosen == act_delete:
+                                self.editor._delete_node_item(self)
+                            e.accept()
+                            return True
+                    except Exception:
+                        pass
+
+                if et == QEvent.GraphicsSceneContextMenu:
+                    try:
+                        gp = e.screenPos() if hasattr(e, "screenPos") else None
+                        menu = QMenu(self.editor.window())
+                        ss = self.editor.window().styleSheet()
+                        if ss:
+                            menu.setStyleSheet(ss)
+                        act_rename = QAction(self.editor.config.node_context_rename(), menu)
+                        act_delete = QAction(self.editor.config.node_context_delete(), menu)
+                        menu.addAction(act_rename)
+                        menu.addSeparator()
+                        menu.addAction(act_delete)
+                        chosen = menu.exec(gp)
+                        if chosen == act_rename:
+                            from PySide6.QtWidgets import QInputDialog
+                            new_name, ok = QInputDialog.getText(
+                                self.editor.window(),
+                                self.editor.config.rename_dialog_title(),
+                                self.editor.config.rename_dialog_label(),
+                                text=self.node.name
+                            )
+                            if ok and new_name:
+                                self.node.name = new_name
+                                self.update()
+                        elif chosen == act_delete:
+                            self.editor._delete_node_item(self)
+                        e.accept()
+                        return True
+                    except Exception:
+                        pass
+
             if obj is self._proxy and et in (QEvent.GraphicsSceneMouseMove, QEvent.GraphicsSceneHoverMove):
                 local = self.mapFromScene(e.scenePos())
                 self._apply_hover_from_pos(local)

pygpt_net/ui/widget/node_editor/view.py

@@ -254,7 +254,6 @@ class NodeViewOverlayControls(QWidget):
         self.setAttribute(Qt.WA_StyledBackground, True)
 
         layout = QHBoxLayout(self)
-        # Bigger spacing to visually add padding around buttons
         layout.setContentsMargins(0, 0, 0, 0)
         layout.setSpacing(8)
 
@@ -266,21 +265,21 @@ class NodeViewOverlayControls(QWidget):
         self.btnGrab.setToolTip(cfg.overlay_grab_tooltip())
         self.btnGrab.setIcon(QIcon(":/icons/drag.svg"))
         self.btnGrab.setIconSize(QSize(20, 20))
-        self.btnGrab.setMinimumSize(32, 32)
+        self.btnGrab.setMinimumSize(25, 25)
 
-        # Zoom Out (placed before Zoom In)
+        # Zoom Out
         self.btnZoomOut = QPushButton(self)
         self.btnZoomOut.setToolTip(cfg.overlay_zoom_out_tooltip())
         self.btnZoomOut.setIcon(QIcon(":/icons/zoom_out.svg"))
         self.btnZoomOut.setIconSize(QSize(20, 20))
-        self.btnZoomOut.setMinimumSize(32, 32)
+        self.btnZoomOut.setMinimumSize(25, 25)
 
         # Zoom In
         self.btnZoomIn = QPushButton(self)
         self.btnZoomIn.setToolTip(cfg.overlay_zoom_in_tooltip())
         self.btnZoomIn.setIcon(QIcon(":/icons/zoom_in.svg"))
         self.btnZoomIn.setIconSize(QSize(20, 20))
-        self.btnZoomIn.setMinimumSize(32, 32)
+        self.btnZoomIn.setMinimumSize(25, 25)
 
         layout.addWidget(self.btnGrab)
         layout.addWidget(self.btnZoomIn)        

pygpt_net/ui/widget/textarea/input.py

@@ -6,7 +6,7 @@
 # GitHub:  https://github.com/szczyglis-dev/py-gpt   #
 # MIT License                                        #
 # Created By  : Marcin Szczygliński                  #
-# Updated Date: 2025.09.22 12:00:00                  #
+# Updated Date: 2025.09.26 12:00:00                  #
 # ================================================== #
 
 from typing import Optional
@@ -62,8 +62,8 @@ class ChatInput(QTextEdit):
         self._icons_margin = 6           # inner left/right padding around the bar
         self._icons_spacing = 4          # spacing between buttons
         self._icons_offset_y = -4        # small upward shift (visual alignment)
-        self._icon_size = QSize(18, 18)  # icon size (matches your original)
-        self._btn_size = QSize(24, 24)   # button size (w x h), matches previous QPushButton
+        self._icon_size = QSize(18, 18)  # icon size (matches original)
+        self._btn_size = QSize(24, 24)   # button size (w x h), matches QPushButton
 
         # Storage for icon buttons and metadata
         self._icons = {}       # key -> QPushButton
@@ -124,6 +124,9 @@ class ChatInput(QTextEdit):
         self._tokens_timer.timeout.connect(self.window.controller.ui.update_tokens)
         self.textChanged.connect(self._on_text_changed_tokens)
 
+        # Paste/input safety limits
+        self._paste_max_chars = 1000000000  # hard cap to prevent pathological pastes from freezing/crashing
+
     def _on_text_changed_tokens(self):
         """Schedule token count update with debounce."""
         self._tokens_timer.start()
@@ -142,15 +145,133 @@ class ChatInput(QTextEdit):
         self._text_top_padding = max(0, int(px))
         self._apply_margins()
 
+    def canInsertFromMimeData(self, source) -> bool:
+        """
+        Restrict accepted MIME types to safe, explicitly handled ones.
+        This prevents Qt from trying to parse unknown/broken formats.
+        """
+        try:
+            if source is None:
+                return False
+            return source.hasText() or source.hasUrls() or source.hasImage()
+        except Exception:
+            return False
+
     def insertFromMimeData(self, source):
         """
         Insert from mime data
 
         :param source: source
         """
-        self.handle_clipboard(source)
-        if not source.hasImage():
-            super().insertFromMimeData(source)
+        # Always process attachments first; never break input pipeline on errors.
+        try:
+            self.handle_clipboard(source)
+        except Exception as e:
+            try:
+                self.window.core.debug.log(e)
+            except Exception:
+                pass
+
+        # If an image is present, we treat it as attachment-only and do not insert textual representation.
+        try:
+            if source and source.hasImage():
+                return
+        except Exception:
+            # fallback to text extraction below
+            pass
+
+        # Insert only sanitized plain text (no HTML, no custom formats).
+        try:
+            text = self._safe_text_from_mime(source)
+            if text:
+                self.insertPlainText(text)
+        except Exception as e:
+            try:
+                self.window.core.debug.log(e)
+            except Exception:
+                pass
+
+    def _safe_text_from_mime(self, source) -> str:
+        """
+        Extracts plain text from QMimeData safely, normalizes and sanitizes it.
+        Falls back to URLs joined by space if textual content is not provided.
+        """
+        try:
+            if source is None:
+                return ""
+            if source.hasText():
+                return self._sanitize_text(source.text())
+            if source.hasUrls():
+                parts = []
+                for url in source.urls():
+                    try:
+                        if url.isLocalFile():
+                            parts.append(url.toLocalFile())
+                        else:
+                            parts.append(url.toString())
+                    except Exception:
+                        continue
+                return self._sanitize_text(" ".join([p for p in parts if p]))
+        except Exception as e:
+            try:
+                self.window.core.debug.log(e)
+            except Exception:
+                pass
+        return ""
+
+    def _sanitize_text(self, text: str) -> str:
+        """
+        Sanitize pasted text:
+        - normalize newlines
+        - remove NUL and most control chars except tab/newline
+        - strip zero-width and bidi control characters
+        - hard-cap maximum length to avoid UI freeze
+        """
+        if not text:
+            return ""
+        if not isinstance(text, str):
+            try:
+                text = str(text)
+            except Exception:
+                return ""
+
+        # Normalize line breaks
+        text = text.replace("\r\n", "\n").replace("\r", "\n")
+
+        # Remove disallowed control chars, keep tab/newline
+        out = []
+        for ch in text:
+            code = ord(ch)
+            if code == 0:
+                continue  # NUL
+            if code < 32:
+                if ch in ("\n", "\t"):
+                    out.append(ch)
+                else:
+                    out.append(" ")
+                continue
+            if code == 0x7F:
+                continue  # DEL
+            # Remove zero-width and bidi controls
+            if (0x200B <= code <= 0x200F) or (0x202A <= code <= 0x202E) or (0x2066 <= code <= 0x2069):
+                continue
+            out.append(ch)
+
+        s = "".join(out)
+
+        # Cap very large pastes
+        try:
+            limit = int(self._paste_max_chars)
+        except Exception:
+            limit = 250000
+        if limit > 0 and len(s) > limit:
+            s = s[:limit]
+            try:
+                self.window.core.debug.log(f"Input paste truncated to {limit} chars")
+            except Exception:
+                pass
+
+        return s
 
     def handle_clipboard(self, source):
         """
@@ -158,20 +279,33 @@ class ChatInput(QTextEdit):
 
         :param source: source
         """
-        if source.hasImage():
-            image = source.imageData()
-            if isinstance(image, QImage):
-                self.window.controller.attachment.from_clipboard_image(image)
-        elif source.hasUrls():
-            urls = source.urls()
-            for url in urls:
-                if url.isLocalFile():
-                    local_path = url.toLocalFile()
-                    self.window.controller.attachment.from_clipboard_url(local_path)
-        elif source.hasText():
-            text = source.text()
-            if text:
-                self.window.controller.attachment.from_clipboard_text(text)
+        if source is None:
+            return
+        try:
+            if source.hasImage():
+                image = source.imageData()
+                if isinstance(image, QImage):
+                    self.window.controller.attachment.from_clipboard_image(image)
+            elif source.hasUrls():
+                urls = source.urls()
+                for url in urls:
+                    try:
+                        if url.isLocalFile():
+                            local_path = url.toLocalFile()
+                            self.window.controller.attachment.from_clipboard_url(local_path)
+                    except Exception:
+                        # Ignore broken URL entries
+                        continue
+            elif source.hasText():
+                text = self._sanitize_text(source.text())
+                if text:
+                    self.window.controller.attachment.from_clipboard_text(text)
+        except Exception as e:
+            # Never propagate clipboard errors to UI thread
+            try:
+                self.window.core.debug.log(e)
+            except Exception:
+                pass
 
     def contextMenuEvent(self, event):
         """
@@ -395,7 +529,7 @@ class ChatInput(QTextEdit):
         btn.setCursor(Qt.PointingHandCursor)
         btn.setToolTip(tooltip or key)
         btn.setFocusPolicy(Qt.NoFocus)
-        btn.setFlat(True)  # flat button style like your original
+        btn.setFlat(True)  # flat button style
         # optional: no text
         btn.setText("")