pygpt-net 2.6.60__py3-none-any.whl → 2.6.62__py3-none-any.whl

pygpt_net/ui/widget/node_editor/item.py

@@ -6,7 +6,7 @@
 # GitHub:  https://github.com/szczyglis-dev/py-gpt   #
 # MIT License                                        #
 # Created By  : Marcin Szczygliński                  #
-# Updated Date: 2025.09.24 00:00:00                  #
+# Updated Date: 2025.09.25 12:05:00                  #
 # ================================================== #
 
 from __future__ import annotations
@@ -140,20 +140,16 @@ class PortItem(QGraphicsObject):
         except Exception:
             pass
         cap_val = self._allowed_capacity()
+        cfg = self.node_item.editor.config
         if isinstance(cap_val, int):
             if cap_val < 0:
-                cap_str = "unlimited (∞)"
+                cap_str = cfg.cap_unlimited()
             else:
                 cap_str = str(cap_val)
         else:
-            cap_str = "n/a"
-        tip = (
-            f"Node: {node_name}\n"
-            f"Port: {self.side.upper()} • {self.prop_id}\n"
-            f"Allowed connections: {cap_str}\n\n"
-            f"Click: start a new connection\n"
-            f"Ctrl+Click: rewire/detach existing"
-        )
+            cap_str = cfg.cap_na()
+        side_label = cfg.side_label(self.side).upper()
+        tip = cfg.port_tooltip(node_name, side_label, self.prop_id, cap_str)
         self.setToolTip(tip)
         try:
             self._label_cap.setToolTip(tip)
@@ -225,6 +221,11 @@ class PortItem(QGraphicsObject):
     def mousePressEvent(self, e):
         """Emit portClicked on left click to begin a connection or rewire."""
         if e.button() == Qt.LeftButton:
+            try:
+                # Bring parent node to front when clicking the port
+                self.node_item.editor.raise_node_to_top(self.node_item)
+            except Exception:
+                pass
             self.node_item.editor._dbg(f"Port clicked: side={self.side}, node={self.node_item.node.name}({self.node_item.node.uuid}), prop={self.prop_id}, connected_count={self._connected_count}")
             self.portClicked.emit(self)
             e.accept()
@@ -355,7 +356,7 @@ class EdgeItem(QGraphicsPathItem):
         ss = self._editor.window().styleSheet()
         if ss:
             menu.setStyleSheet(ss)
-        act_del = QAction("Delete connection", menu)
+        act_del = QAction(self._editor.config.edge_context_delete(), menu)
         menu.addAction(act_del)
         chosen = menu.exec(event.screenPos())
         if chosen == act_del:

pygpt_net/ui/widget/node_editor/node.py

@@ -6,14 +6,14 @@
 # GitHub:  https://github.com/szczyglis-dev/py-gpt   #
 # MIT License                                        #
 # Created By  : Marcin Szczygliński                  #
-# Updated Date: 2025.09.24 00:00:00                  #
+# Updated Date: 2025.09.26 10:00:00                  #
 # ================================================== #
 
 from __future__ import annotations
 import re
-from typing import Dict, Optional, List, Any
+from typing import Dict, Optional, List, Any, Tuple
 
-from PySide6.QtCore import Qt, QPointF, QRectF, QSizeF, Signal,QEvent
+from PySide6.QtCore import Qt, QPointF, QRectF, QSizeF, Signal, QEvent
 from PySide6.QtGui import QAction, QBrush, QColor, QPainter, QPainterPath, QPen
 from PySide6.QtWidgets import (
     QWidget, QApplication, QGraphicsItem, QGraphicsWidget, QGraphicsProxyWidget, QStyleOptionGraphicsItem,
@@ -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,12 +89,20 @@ class SingleLineTextEdit(QTextEdit):
             c.setPosition(min(pos, len(t2)))
             self.setTextCursor(c)
 
+    def contextMenuEvent(self, e):
+        """Widget-level context menu is intentionally disabled."""
+        try:
+            e.ignore()
+        except Exception:
+            pass
+        return
+
 
 class NodeContentWidget(QWidget):
     """Form-like widget that renders property editors for a node.
 
     The widget builds appropriate Qt editors based on PropertyModel.type:
-        - "str": QLineEdit
+        - "str": QLineEdit-like (SingleLineTextEdit with placeholder support)
         - "text": QTextEdit
         - "int": QSpinBox
         - "float": QDoubleSpinBox
@@ -103,6 +114,8 @@ class NodeContentWidget(QWidget):
 
     Notes:
         - For Base ID-like properties, the field is read-only; a composed display value is shown.
+        - Placeholder and description are applied when provided in the type spec or model
+          (description is shown as tooltip on both the editor and its label).
         - ShortcutOverride is handled so typing in editors does not trigger scene shortcuts.
 
     Signal:
@@ -125,7 +138,24 @@ class NodeContentWidget(QWidget):
         self._editors: Dict[str, QWidget] = {}
         for pid, pm in node.properties.items():
             editable = self._editable_from_spec(pid, pm)
+
+            # Resolve UI hints: placeholder and description from spec (fallback to model)
+            placeholder = self._spec_text_attr(pid, "placeholder")
+            try:
+                if not placeholder and hasattr(pm, "placeholder") and getattr(pm, "placeholder") not in (None, ""):
+                    placeholder = str(getattr(pm, "placeholder"))
+            except Exception:
+                pass
+            description = self._spec_text_attr(pid, "description")
+            try:
+                if not description and hasattr(pm, "description") and getattr(pm, "description") not in (None, ""):
+                    description = str(getattr(pm, "description"))
+            except Exception:
+                pass
+
             w: QWidget
+            extra_tooltip: Optional[str] = None  # used e.g. for capacity hints
+
             if pm.type == "str":
                 te = SingleLineTextEdit()
                 te.setFocusPolicy(Qt.StrongFocus)
@@ -145,17 +175,31 @@ class NodeContentWidget(QWidget):
                     te.setReadOnly(not editable)
 
                 te.setPlainText(txt)
+                if placeholder:
+                    try:
+                        te.setPlaceholderText(placeholder)
+                    except Exception:
+                        pass
                 te.textChanged.connect(lambda pid=pid, te=te: self.valueChanged.emit(pid, te.toPlainText()))
                 te.editingFinished.connect(lambda pid=pid, te=te: self.valueChanged.emit(pid, te.toPlainText()))
                 w = te
+
             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)
+                if placeholder:
+                    try:
+                        te.setPlaceholderText(placeholder)
+                    except Exception:
+                        pass
                 te.textChanged.connect(lambda pid=pid, te=te: self.valueChanged.emit(pid, te.toPlainText()))
                 w = te
+
             elif pm.type == "int":
                 w = QSpinBox()
                 w.setFocusPolicy(Qt.StrongFocus)
@@ -163,7 +207,10 @@ class NodeContentWidget(QWidget):
                 if pm.value is not None:
                     w.setValue(int(pm.value))
                 w.setEnabled(editable)
+
+                # QSpinBox has no placeholder; use tooltip only
                 w.valueChanged.connect(lambda v, pid=pid: self.valueChanged.emit(pid, int(v)))
+
             elif pm.type == "float":
                 w = QDoubleSpinBox()
                 w.setFocusPolicy(Qt.StrongFocus)
@@ -173,6 +220,7 @@ class NodeContentWidget(QWidget):
                     w.setValue(float(pm.value))
                 w.setEnabled(editable)
                 w.valueChanged.connect(lambda v, pid=pid: self.valueChanged.emit(pid, float(v)))
+
             elif pm.type == "bool":
                 w = QCheckBox()
                 w.setFocusPolicy(Qt.StrongFocus)
@@ -180,6 +228,7 @@ class NodeContentWidget(QWidget):
                     w.setChecked(bool(pm.value))
                 w.setEnabled(editable)
                 w.toggled.connect(lambda v, pid=pid: self.valueChanged.emit(pid, bool(v)))
+
             elif pm.type == "combo":
                 w = QComboBox()
                 w.setFocusPolicy(Qt.StrongFocus)
@@ -188,20 +237,41 @@ class NodeContentWidget(QWidget):
                 if pm.value is not None and pm.value in (pm.options or []):
                     w.setCurrentText(pm.value)
                 w.setEnabled(editable)
+                # QComboBox placeholder works when editable; we keep non-editable by default
                 w.currentTextChanged.connect(lambda v, pid=pid: self.valueChanged.emit(pid, v))
+
             else:
                 # Render a read-only capacity placeholder for port-like properties ("input/output").
                 cap_text = self._capacity_text_for_property(pid, pm)
                 w = QLabel(cap_text)
                 w.setEnabled(False)
-                w.setToolTip(f"Allowed connections (IN/OUT): {cap_text}")
+                extra_tooltip = self.editor.config.port_capacity_tooltip(cap_text)
 
             name = self._display_name_for_property(pid, pm)
             if name == "Base ID":
-                name = "ID"
+                name = self.editor.config.label_id()
             self.form.addRow(name, w)
             self._editors[pid] = w
 
+            # Apply tooltip(s) after the row is created so we can also set the label tooltip
+            if description or extra_tooltip:
+                final_tt_parts: List[str] = []
+                if description:
+                    final_tt_parts.append(description)
+                if extra_tooltip:
+                    final_tt_parts.append(extra_tooltip)
+                final_tt = "\n".join(final_tt_parts)
+                try:
+                    w.setToolTip(final_tt)
+                except Exception:
+                    pass
+                try:
+                    lbl = self.form.labelForField(w)
+                    if lbl is not None:
+                        lbl.setToolTip(description or "")
+                except Exception:
+                    pass
+
     def event(self, e):
         """
         Filter ShortcutOverride so editor keystrokes are not eaten by the scene.
@@ -481,6 +551,55 @@ class NodeContentWidget(QWidget):
 
         return None
 
+    # --- Spec helpers for UI hints ---
+
+    def _get_prop_spec(self, pid: str) -> Optional[Any]:
+        """Return a property specification object from the registry for this node type."""
+        try:
+            reg = self.graph.registry
+            if not reg:
+                return None
+            type_spec = reg.get(self.node.type)
+            if not type_spec:
+                return None
+
+            for attr in ("properties", "props", "fields", "ports", "inputs", "outputs"):
+                try:
+                    cont = getattr(type_spec, attr, None)
+                    if isinstance(cont, dict) and pid in cont:
+                        return cont[pid]
+                except Exception:
+                    pass
+            for meth in ("get_property", "property_spec", "get_prop", "prop", "property"):
+                if hasattr(type_spec, meth):
+                    try:
+                        return getattr(type_spec, meth)(pid)
+                    except Exception:
+                        pass
+        except Exception:
+            pass
+        return None
+
+    def _spec_text_attr(self, pid: str, key: str) -> Optional[str]:
+        """Get a string attribute (e.g., 'placeholder', 'description') from spec if available."""
+        obj = self._get_prop_spec(pid)
+        if obj is None:
+            return None
+        try:
+            v = getattr(obj, key, None)
+            if isinstance(v, str) and v != "":
+                return v
+        except Exception:
+            pass
+        try:
+            if isinstance(obj, dict):
+                v = obj.get(key)
+                if isinstance(v, str) and v != "":
+                    return v
+        except Exception:
+            pass
+        return None
+
 
 class NodeItem(QGraphicsWidget):
     """Rounded node with title and ports aligned to property rows.
@@ -613,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
 
@@ -854,6 +973,14 @@ class NodeItem(QGraphicsWidget):
         if self._resizing:
             return
 
+        # When global grab mode is active, suppress resize/move cursors
+        view = self.editor.view
+        if getattr(view, "_global_grab_mode", False):
+            self._hover_resize_mode = "none"
+            self.unsetCursor()
+            self.update()
+            return
+
         mode = self._hit_resize_zone(pos)
         self._hover_resize_mode = mode
 
@@ -891,9 +1018,9 @@ class NodeItem(QGraphicsWidget):
         self.update()
 
     def hoverMoveEvent(self, event):
-        """While panning is active, suppress resize hints; otherwise update hover state."""
+        """While panning is active or global grab is enabled, suppress resize hints; otherwise update hover state."""
         view = self.editor.view
-        if getattr(view, "_panning", False):
+        if getattr(view, "_panning", False) or getattr(view, "_global_grab_mode", False):
             self._hover_resize_mode = "none"
             self.unsetCursor()
             self.update()
@@ -912,6 +1039,17 @@ class NodeItem(QGraphicsWidget):
 
     def mousePressEvent(self, event):
         """Start resize when pressing the proper zone; otherwise begin move drag."""
+        # Always bring clicked node to front (dynamic z-order)
+        try:
+            self.editor.raise_node_to_top(self)
+        except Exception:
+            pass
+
+        # If global grab is active, do not initiate node drag/resize (view handles panning)
+        if getattr(self.editor.view, "_global_grab_mode", False) and event.button() == Qt.LeftButton:
+            event.ignore()
+            return
+
         if event.button() == Qt.LeftButton:
             mode = self._hit_resize_zone(event.pos())
             if mode != "none":
@@ -971,7 +1109,7 @@ class NodeItem(QGraphicsWidget):
             return
 
         if self._dragging and event.button() == Qt.LeftButton:
-            if self._overlaps:
+            if bool(getattr(self.editor, "enable_collisions", True)) and self._overlaps:
                 self.setPos(self._last_valid_pos)
             else:
                 if self.pos() != self._start_pos:
@@ -985,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)
@@ -1047,6 +1256,14 @@ class NodeItem(QGraphicsWidget):
                 if _qt_is_valid(self._overlay):
                     self._overlay.update()
                 return False
+
+            if obj is self._content and et == QEvent.MouseButtonPress:
+                # Bring to front when clicking inside embedded editors (proxy widget area)
+                try:
+                    self.editor.raise_node_to_top(self)
+                except Exception:
+                    pass
+                return False
         except Exception:
             pass
         return False
@@ -1065,6 +1282,11 @@ class NodeItem(QGraphicsWidget):
                 if not getattr(self, "_dragging", False):
                     return value
 
+                # When collisions are disabled, skip overlap checks entirely
+                if not bool(getattr(self.editor, "enable_collisions", True)):
+                    self._overlaps = False
+                    return value
+
                 sc = self.scene()
                 if sc is None or not _qt_is_valid(sc):
                     return value
@@ -1115,6 +1337,17 @@ class NodeItem(QGraphicsWidget):
                 pass
             return super().itemChange(change, value)
 
+        if change == QGraphicsItem.ItemSelectedHasChanged:
+            # Bring newly selected node to front as well (e.g., rubber-band selection)
+            try:
+                ed = getattr(self, "editor", None)
+                if ed and getattr(ed, "_alive", True) and not getattr(ed, "_closing", False):
+                    if self.isSelected():
+                        ed.raise_node_to_top(self)
+            except Exception:
+                pass
+            return super().itemChange(change, value)
+
         return super().itemChange(change, value)
 
     def contextMenuEvent(self, event):
@@ -1123,15 +1356,15 @@ class NodeItem(QGraphicsWidget):
         ss = self.editor.window().styleSheet()
         if ss:
             menu.setStyleSheet(ss)
-        act_rename = QAction("Rename", menu)
-        act_delete = QAction("Delete", menu)
+        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(event.screenPos())
         if chosen == act_rename:
             from PySide6.QtWidgets import QInputDialog
-            new_name, ok = QInputDialog.getText(self.editor.window(), "Rename Node", "Name:", text=self.node.name)
+            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()