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

pygpt_net/tools/agent_builder/ui/dialogs.py

@@ -6,18 +6,20 @@
 # GitHub:  https://github.com/szczyglis-dev/py-gpt   #
 # MIT License                                        #
 # Created By  : Marcin Szczygliński                  #
-# Updated Date: 2025.09.19 00:00:00                  #
+# Updated Date: 2025.09.24 00:00:00                  #
 # ================================================== #
 
-from PySide6.QtCore import Qt
+from PySide6.QtCore import Qt, QEvent
 from PySide6.QtGui import QAction, QIcon
-from PySide6.QtWidgets import QVBoxLayout, QMenuBar, QSplitter
+from PySide6.QtWidgets import QVBoxLayout, QMenuBar, QSplitter, QSizePolicy, QWidget
 
-from pygpt_net.tools.agent_builder.ui.list import AgentsWidget
-from pygpt_net.ui.widget.builder.editor import NodeEditor
+from pygpt_net.ui.widget.element.labels import HelpLabel
+from pygpt_net.ui.widget.node_editor.editor import NodeEditor
 from pygpt_net.ui.widget.dialog.base import BaseDialog
 from pygpt_net.utils import trans
 
+from .list import AgentsWidget
+
 
 class Builder:
 
@@ -34,18 +36,18 @@ class Builder:
         self.actions = {}
 
     def setup_menu(self, parent=None) -> QMenuBar:
-        """Setup audio agent_builder dialog menu"""
+        """Setup agent_builder dialog menu"""
         self.menu_bar = QMenuBar(parent)
         self.file_menu = self.menu_bar.addMenu(trans("menu.file"))
         t = self.tool
 
-        self.actions["open"] = QAction(QIcon(":/icons/folder.svg"), trans("action.open"), self.menu_bar)
+        self.actions["open"] = QAction(QIcon(":/icons/reload.svg"), trans("action.reload"), self.menu_bar)
         self.actions["open"].triggered.connect(lambda checked=False, t=t: t.load())
 
         self.actions["save"] = QAction(QIcon(":/icons/save.svg"), trans("action.save"), self.menu_bar)
         self.actions["save"].triggered.connect(lambda checked=False, t=t: t.save())
 
-        self.actions["clear"] = QAction(QIcon(":/icons/clear.svg"), trans("action.clear"), self.menu_bar)
+        self.actions["clear"] = QAction(QIcon(":/icons/close.svg"), trans("action.clear"), self.menu_bar)
         self.actions["clear"].triggered.connect(lambda checked=False, t=t: t.clear())
 
         self.file_menu.addAction(self.actions["open"])
@@ -55,60 +57,124 @@ class Builder:
 
     def setup(self):
         """Setup agent_builder dialog"""
+        # Ensure previous deferred deletions are flushed before building a new editor instance
+        try:
+            from PySide6.QtWidgets import QApplication
+            QApplication.sendPostedEvents(None, QEvent.DeferredDelete)
+            QApplication.processEvents()
+        except Exception:
+            pass
+
         id = 'agent.builder'
         u = self.window.ui
 
         u.dialog['agent.builder'] = BuilderDialog(self.window)
         dlg = u.dialog['agent.builder']
 
-        editor = NodeEditor(dlg)  # parent == dialog
-        editor.setStyleSheet("""
+        registry = self.tool.get_registry()  # node types
+        editor = NodeEditor(
+            parent=dlg,
+            registry=registry
+        )  # parent == dialog
+
+        theme = self.window.core.config.get("theme")
+        if theme.startswith("light"):
+            style = """
+            NodeEditor {
+                qproperty-gridBackColor: #ffffff;
+                qproperty-gridPenColor:  #eaeaea;
+
+                qproperty-nodeBackgroundColor: #2d2f34;
+                qproperty-nodeBorderColor:     #4b4f57;
+                qproperty-nodeSelectionColor:  #ff9900;
+                qproperty-nodeTitleColor:      #3a3d44;
+
+                qproperty-portInputColor:      #66b2ff;
+                qproperty-portOutputColor:     #70e070;
+                qproperty-portConnectedColor:  #ffd166;
+
+                qproperty-edgeColor:           #c0c0c0;
+                qproperty-edgeSelectedColor:   #ff8a5c;
+            }
+            """
+        else:
+            style = """
             NodeEditor {
                 qproperty-gridBackColor: #242629;
                 qproperty-gridPenColor:  #3b3f46;
-    
+
                 qproperty-nodeBackgroundColor: #2d2f34;
                 qproperty-nodeBorderColor:     #4b4f57;
                 qproperty-nodeSelectionColor:  #ff9900;
                 qproperty-nodeTitleColor:      #3a3d44;
-    
+
                 qproperty-portInputColor:      #66b2ff;
                 qproperty-portOutputColor:     #70e070;
                 qproperty-portConnectedColor:  #ffd166;
-    
+
                 qproperty-edgeColor:           #c0c0c0;
                 qproperty-edgeSelectedColor:   #ff8a5c;
             }
-            """)
-
-        # Demo: add a couple of nodes
-        #editor.add_node("Value/Float", QPointF(100, 120))
-        #editor.add_node("Value/Float", QPointF(100, 240))
-        #editor.add_node("Math/Add", QPointF(420, 180))
+            """
+        editor.setStyleSheet(style)
         editor.on_clear = self.tool.clear
+        editor.editing_allowed = self.tool.editing_allowed
 
         u.editor[id] = editor
 
         layout = QVBoxLayout()
         layout.setMenuBar(self.setup_menu(dlg))
 
-        agents_list = AgentsWidget(self.window, tool=self.tool)
+        agents_list = AgentsWidget(self.window, tool=self.tool, parent=dlg)
         list_widget = agents_list.setup()
-        list_widget.setFixedWidth(250)
+
+        # Left side container: list fills all space, help label stays at the bottom
+        left_side = QWidget(dlg)
+        left_layout = QVBoxLayout(left_side)
+        left_layout.setContentsMargins(0, 0, 0, 0)
+        left_layout.setSpacing(6)
+
+        left_help_label = HelpLabel(trans("node.editor.list.tip"))
+        left_help_label.setWordWrap(True)
+        left_help_label.setAlignment(Qt.AlignLeft | Qt.AlignVCenter)
+        left_help_label.setTextInteractionFlags(Qt.TextSelectableByMouse)
+        left_help_label.setSizePolicy(QSizePolicy.Preferred, QSizePolicy.Minimum)
+
+        left_layout.addWidget(list_widget)
+        left_layout.addWidget(left_help_label)
+        left_layout.setStretch(0, 1)  # list -> fills all vertical space
+
+        # Fix the width of the whole left panel (not only the list)
+        left_side.setFixedWidth(250)
+
         center_splitter = QSplitter(Qt.Horizontal)
-        center_splitter.addWidget(list_widget)
+        center_splitter.addWidget(left_side)
         center_splitter.addWidget(u.editor[id])
         center_splitter.setStretchFactor(0, 1)
         center_splitter.setStretchFactor(1, 8)
         layout.addWidget(center_splitter)
+        # Make the splitter take all extra vertical space so the legend stays compact at the bottom
+        layout.setStretch(0, 1)
 
+        # Bottom legend as a compact, centered help label
+        legend_label = HelpLabel(trans("node.editor.bottom.tip"))
+        legend_label.setAlignment(Qt.AlignCenter)
+        legend_label.setWordWrap(True)
+        legend_label.setTextInteractionFlags(Qt.TextSelectableByMouse)
+        legend_label.setSizePolicy(QSizePolicy.Preferred, QSizePolicy.Minimum)
+
+        layout.addWidget(legend_label)
+
+        u.nodes["agent.builder.splitter"] = center_splitter
         u.nodes["agent.builder.list"] = agents_list
+        u.nodes["agent.builder.legend"] = legend_label
+        u.nodes["agent.builder.list.help"] = left_help_label
 
         dlg.setLayout(layout)
         dlg.setWindowTitle(trans("agent.builder.title"))
 
     def clear(self):
-        """Clear transcribe dialog"""
+        """Clear dialog"""
         pass
 
 
@@ -123,6 +189,7 @@ class BuilderDialog(BaseDialog):
         super(BuilderDialog, self).__init__(window, id)
         self.window = window
         self.id = id  # id
+        self._cleaned = False
 
     def closeEvent(self, event):
         """
@@ -140,13 +207,90 @@ class BuilderDialog(BaseDialog):
         :param event: key press event
         """
         if event.key() == Qt.Key_Escape:
-            self.cleanup()
             self.close()
         else:
             super(BuilderDialog, self).keyPressEvent(event)
 
     def cleanup(self):
-        """
-        Cleanup on close
-        """
-        self.window.tools.get("agent_builder").on_close()
+        """Cleanup on dialog close"""
+        if self._cleaned:
+            return
+        self._cleaned = True
+
+        tool = self.window.tools.get("agent_builder")
+        if tool:
+            try:
+                tool.on_close()  # store current state (layout, nodes positions, etc.)
+            except Exception:
+                pass
+
+        u = self.window.ui
+
+        try:
+            u.nodes["agent.builder.list"].cleanup()
+        except Exception as e:
+            print("Agents list close failed:", e)
+
+        splitter = u.nodes.get("agent.builder.splitter")
+        editor = u.editor.pop('agent.builder', None)
+
+        # Detach editor from splitter before closing/deleting it to avoid dangling pointers in QSplitter
+        try:
+            if splitter is not None and editor is not None:
+                # Ensure the editor actually belongs to this splitter
+                idx = splitter.indexOf(editor) if editor.parent() is splitter else -1
+                if idx != -1:
+                    # Create the replacement without a parent; QSplitter will adopt it.
+                    from PySide6.QtWidgets import QWidget as _QW
+                    placeholder = _QW()
+                    splitter.replaceWidget(idx, placeholder)
+        except Exception as e:
+            print("Splitter detach failed:", e)
+
+        if editor is not None:
+            try:
+                editor.setStyleSheet("")
+            except Exception:
+                pass
+            try:
+                editor.close()
+            except Exception as e:
+                print("NodeEditor close failed:", e)
+            try:
+                editor.setParent(None)
+                editor.deleteLater()
+            except Exception:
+                pass
+
+        # Dispose legend label safely
+        legend = u.nodes.pop("agent.builder.legend", None)
+        if legend is not None:
+            try:
+                legend.setParent(None)
+                legend.deleteLater()
+            except Exception:
+                pass
+
+        # Dispose left-side help label safely
+        try:
+            help_lbl = u.nodes.pop("agent.builder.list.help", None)
+            if help_lbl is not None:
+                help_lbl.setParent(None)
+                help_lbl.deleteLater()
+        except Exception:
+            pass
+
+        # Drop splitter reference
+        try:
+            u.nodes.pop("agent.builder.splitter", None)
+        except Exception:
+            pass
+
+        # Ensure all deferred deletions are processed (do it a few rounds to be safe)
+        try:
+            from PySide6.QtWidgets import QApplication
+            for _ in range(3):
+                QApplication.sendPostedEvents(None, QEvent.DeferredDelete)
+                QApplication.processEvents()
+        except Exception:
+            pass

pygpt_net/tools/agent_builder/ui/list.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: 2025.09.24 00:00:00                  #
 # ================================================== #
 
 from PySide6 import QtCore
@@ -19,7 +19,7 @@ from pygpt_net.utils import trans
 
 
 class AgentsWidget:
-    def __init__(self, window=None, tool=None):
+    def __init__(self, window=None, tool=None, parent=None):
         """
         Agents select widget
 
@@ -27,6 +27,7 @@ class AgentsWidget:
         :param tool: tool instance
         """
         self.window = window
+        self.parent = parent
         self.tool = tool
         self.id = "agent.builder.list"
         self.list = None
@@ -37,21 +38,42 @@ class AgentsWidget:
 
         :return: QWidget
         """
-        new_btn = QPushButton(QIcon(":/icons/add.svg"), "")
+        new_btn = QPushButton(QIcon(":/icons/add.svg"), "", self.parent)
         new_btn.clicked.connect(self.action_new)
 
-        self.list = AgentsList(self.window, tool=self.tool, id=self.id)
+        self.list = AgentsList(self.parent, tool=self.tool, id=self.id)
         layout = QVBoxLayout()
         layout.addWidget(new_btn)
         layout.addWidget(self.list)
 
-        self.window.ui.models[self.id] = self.create_model(self.window)
+        self.window.ui.models[self.id] = self.create_model(self.parent)
         self.list.setModel(self.window.ui.models[self.id])
 
         widget = QWidget()
         widget.setLayout(layout)
         return widget
 
+    def cleanup(self):
+        """Cleanup agents list widget"""
+        # Defensively detach the model and schedule deletion only if the view still exists
+        try:
+            if self.list is not None:
+                try:
+                    self.list.setModel(None)
+                except Exception:
+                    pass
+                try:
+                    self.list.deleteLater()
+                except Exception:
+                    pass
+        finally:
+            # Drop model reference in UI registry
+            try:
+                self.window.ui.models.pop(self.id, None)
+            except Exception:
+                pass
+            self.list = None
+
     def action_new(self):
         """
         New agent action
@@ -64,7 +86,7 @@ class AgentsWidget:
         :param parent: parent widget
         :return: QStandardItemModel
         """
-        return QStandardItemModel(0, 1, parent)
+        return QStandardItemModel(0, 1, parent=parent)
 
     def update_list(self, data):
         """
@@ -75,13 +97,18 @@ class AgentsWidget:
         nodes = self.window.ui.nodes
         models = self.window.ui.models
 
-        view = nodes[self.id]
-        model = models.get(self.id)
+        # Guard: dialog may be closed; widget/list may not exist anymore
+        widget = nodes.get(self.id)
+        if widget is None or widget.list is None:
+            return
 
+        model = models.get(self.id)
         if model is None:
-            model = self.create_model(self.window)
+            # When reopened after cleanup, re-create model and re-bind it to the view
+            model = self.create_model(self.parent)
             models[self.id] = model
-            view.setModel(model)
+            widget.list.setModel(model)
+
         try:
             if not data:
                 model.setRowCount(0)

pygpt_net/ui/__init__.py

@@ -172,15 +172,13 @@ class UI:
 
     def show_loading(self):
         """Show loading"""
-        if self.window.core.config.get('layout.animation.disable', False):
-            return
+        return
         self.window.ui.nodes['anim.loading'].start_anim()
         self.window.ui.nodes['anim.loading'].show()
 
     def hide_loading(self):
         """Hide loading"""
-        if self.window.core.config.get('layout.animation.disable', False):
-            return
+        return
         self.window.ui.nodes['anim.loading'].stop_anim()
         self.window.ui.nodes['anim.loading'].hide()
 

pygpt_net/ui/dialog/about.py

@@ -19,6 +19,9 @@ from pygpt_net.utils import trans
 
 
 class About:
+
+    RELEASE_YEAR = 2025
+
     def __init__(self, window=None):
         """
         About dialog
@@ -36,34 +39,65 @@ class About:
         """
         return self.window.core.updater.get_fetch_thanks()
 
+    def build_versions_str(self, lib_versions: dict, break_after: str = "LlamaIndex") -> str:
+        parts = []
+        line = []
+        for k, v in lib_versions.items():
+            line.append(f"{k}: {v}")
+            if k == break_after:
+                parts.append(", ".join(line))
+                line = []
+        if line:
+            parts.append(", ".join(line))
+        return "\n".join(parts)
+
     def prepare_content(self) -> str:
         """
         Get info text
 
         :return: info text
         """
-        llama_index_version = None
-        langchain_version = None
-        openai_version = None
-        versions = True
+        lib_versions = {}
+
+        try:
+            import platform
+            lib_versions['Python'] = platform.python_version()
+        except ImportError:
+            pass
 
         try:
-            from llama_index.core import __version__ as llama_index_version
-            # from langchain import __version__ as langchain_version
             from openai.version import VERSION as openai_version
+            lib_versions['OpenAI API'] = openai_version
+        except ImportError:
+            pass
+
+        try:
+            from llama_index.core import __version__ as llama_index_version
+            lib_versions['LlamaIndex'] = llama_index_version
+        except ImportError:
+            pass
+
+        try:
+            from anthropic import __version__ as anthropic_version
+            lib_versions['Anthropic API'] = anthropic_version
+        except ImportError:
+            pass
+
+        try:
+            from google.genai import __version__ as google_genai_version
+            lib_versions['Google API'] = google_genai_version
         except ImportError:
             pass
 
-        lib_versions = ""
-        if llama_index_version is None or openai_version is None:
-            versions = False
+        try:
+            from xai_sdk import __version__ as xai_sdk_version
+            lib_versions['xAI API'] = xai_sdk_version
+        except ImportError:
+            pass
 
-        if versions:
-            lib_versions = "OpenAI API: {}, LlamaIndex: {}\n\n".format(
-                openai_version,
-                # langchain_version,
-                llama_index_version,
-            )
+        versions_str = ""
+        if lib_versions:
+            versions_str = self.build_versions_str(lib_versions, break_after="LlamaIndex")
 
         platform = self.window.core.platforms.get_as_string()
         version = self.window.meta['version']
@@ -80,29 +114,14 @@ class About:
         label_github = trans("dialog.about.github")
         label_docs = trans("dialog.about.docs")
 
-        data = "{label_version}: {version}, {platform}\n" \
-               "{label_build}: {build}\n" \
-               "{lib_versions}" \
-               "{label_website}: {website}\n" \
-               "{label_github}: {github}\n" \
-               "{label_docs}: {docs}\n\n" \
-               "(c) 2025 {author}\n" \
-               "{email}\n".format(
-                label_version=label_version,
-                version=version,
-                platform=platform,
-                label_build=label_build,
-                build=build.replace('.', '-'),
-                label_website=label_website,
-                website=website,
-                label_github=label_github,
-                github=github,
-                label_docs=label_docs,
-                docs=docs,
-                author=author,
-                email=email,
-                lib_versions=lib_versions,
-            )
+        data = f"{label_version}: {version}, {platform}\n" \
+               f"{label_build}: {build.replace('.', '-')}\n\n" \
+               f"{versions_str}\n\n" \
+               f"{label_website}: {website}\n" \
+               f"{label_github}: {github}\n" \
+               f"{label_docs}: {docs}\n\n" \
+               f"(c) {self.RELEASE_YEAR} {author}\n" \
+               f"{email}\n"
         return data
 
     def setup(self):
@@ -139,6 +158,7 @@ class About:
         string = self.prepare_content()
         content = QLabel(string)
         content.setTextInteractionFlags(Qt.TextSelectableByMouse)
+        content.setWordWrap(True)
         self.window.ui.nodes['dialog.about.content'] = content
 
         thanks = QLabel(trans('about.thanks'))