pygpt-net 2.6.55__py3-none-any.whl → 2.6.57__py3-none-any.whl

pygpt_net/tools/agent_builder/tool.py

@@ -0,0 +1,292 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# ================================================== #
+# This file is a part of PYGPT package               #
+# Website: https://pygpt.net                         #
+# GitHub:  https://github.com/szczyglis-dev/py-gpt   #
+# MIT License                                        #
+# Created By  : Marcin Szczygliński                  #
+# Updated Date: 2025.09.19 00:00:00                  #
+# ================================================== #
+
+from datetime import datetime
+from typing import Dict
+
+from PySide6 import QtCore
+from PySide6.QtGui import QAction, QIcon
+
+from pygpt_net.tools.base import BaseTool
+from pygpt_net.utils import trans
+
+from .ui.dialogs import Builder
+
+class AgentBuilder(BaseTool):
+    def __init__(self, *args, **kwargs):
+        """
+        Agent builder (nodes editor)
+
+        :param window: Window instance
+        """
+        super(AgentBuilder, self).__init__(*args, **kwargs)
+        self.id = "agent_builder"
+        self.opened = False
+        self.dialog = None  # dialog
+        self.initialized = False
+        self.current_agent = None  # current agent ID
+
+    def setup(self):
+        """Setup controller"""
+        pass
+
+    def update(self):
+        """Update"""
+        pass
+
+    def save(self):
+        """Save layout to file"""
+        if "agent.builder" not in self.window.ui.editor:
+            return
+        custom = self.window.core.agents.custom
+        layout = self.window.ui.editor["agent.builder"].save_layout()
+        custom.update_layout(layout)
+        if self.current_agent:
+            custom.update_agent_layout(self.current_agent, layout)
+        custom.save()
+        self.window.update_status(f"Saved at: {datetime.now().strftime('%H:%M:%S')}")
+
+    def load(self):
+        """Load layout from file"""
+        self.restore()
+
+    def open(self):
+        """Open dialog"""
+        if not self.initialized:
+            self.dialog = Builder(self.window, tool=self)
+            self.dialog.setup()
+            self.restore()
+            self.initialized = True
+        self.window.ui.dialogs.open('agent.builder', width=900, height=600)
+        self.opened = True
+        self.update()
+
+    def close(self):
+        """Close dialog"""
+        self.window.ui.dialogs.close('agent.builder')
+        self.opened = False
+
+    def toggle(self):
+        """Toggle dialog window"""
+        if self.opened:
+            self.close()
+        else:
+            self.open()
+
+    def store_current(self):
+        """Store current to file"""
+        self.save()
+
+    def restore(self):
+        """Restore layout and agents from file"""
+        layout = self.window.core.agents.custom.get_layout()
+        if layout:
+            data = layout.data
+            if data:
+                self.window.ui.editor["agent.builder"].load_layout(data)
+                self.window.update_status(f"Loaded layout at: {datetime.now().strftime('%H:%M:%S')}")
+
+        self.update_list()
+
+        # select first agent on list
+        agents = self.window.core.agents.custom.get_agents()
+        if agents and len(agents) > 0:
+            first_agent_id = list(agents.keys())[0]
+            self.edit_agent(first_agent_id)
+
+    def show_hide(self, show: bool = True):
+        """
+        Show/hide dialog window
+
+        :param show: show/hide
+        """
+        if show:
+            self.open()
+        else:
+            self.close()
+
+    def on_close(self):
+        """On window close"""
+        self.opened = False
+        self.update()
+
+    def on_exit(self):
+        """On exit"""
+        self.store_current()
+
+    def clear(self, force: bool = False):
+        """
+        Clear layout
+
+        :param force: force clear
+        """
+        if not force:
+            self.window.ui.dialogs.confirm(
+                type='agent.builder.agent.clear',
+                id=0,
+                msg=trans('agent.builder.confirm.clear.msg'),
+            )
+            return
+        if self.window.ui.editor["agent.builder"].clear(ask_user=False):
+            self.save()
+
+    def add_agent(self, name: str = None):
+        """Add new agent"""
+        if name is None:
+            self.window.ui.dialog['create'].id = 'agent.builder.agent'
+            self.window.ui.dialog['create'].input.setText("")
+            self.window.ui.dialog['create'].current = ""
+            self.window.ui.dialog['create'].show()
+            self.window.ui.dialog['create'].input.setFocus()
+            return
+        uuid = self.window.core.agents.custom.new_agent(name)
+        if uuid:
+            self.update_list()
+            self.window.ui.editor["agent.builder"].clear(ask_user=False)
+            self.window.ui.dialogs.close('create')
+            self.edit_agent(uuid)
+
+    def rename_agent(self, agent_id: str, name: str = None):
+        """
+        Rename agent
+
+        :param agent_id: agent ID
+        :param name: new name
+        """
+        agent = self.window.core.agents.custom.get_agent(agent_id)
+        if not agent:
+            print("Agent not found:", agent_id)
+            return
+        current_name = agent.name
+        if name is None:
+            self.window.ui.dialog['rename'].id = 'agent.builder.agent'
+            self.window.ui.dialog['rename'].input.setText(current_name)
+            self.window.ui.dialog['rename'].current =agent_id
+            self.window.ui.dialog['rename'].show()
+            self.window.ui.dialog['rename'].input.setFocus()
+            return
+        if agent:
+            agent.name = name
+            self.window.core.agents.custom.save()
+            self.update_list()
+            self.window.ui.dialogs.close('rename')
+
+    def edit_agent(self, agent_id: str):
+        """
+        Edit agent
+
+        :param agent_id: agent ID
+        """
+        self.save()
+        self.current_agent = agent_id
+        agent = self.window.core.agents.custom.get_agent(agent_id)
+        if agent:
+            layout = agent.layout
+            if layout:
+                self.window.ui.editor["agent.builder"].load_layout(layout)
+            else:
+                self.window.ui.editor["agent.builder"].clear(ask_user=False)
+            self.select_on_list(agent_id)
+
+    def duplicate_agent(self, agent_id: str):
+        """
+        Duplicate agent
+
+        :param agent_id: agent ID
+        """
+        agent = self.window.core.agents.custom.get_agent(agent_id)
+        if agent:
+            new_name = f"{agent.name} (copy)"
+            self.window.core.agents.custom.duplicate_agent(agent_id, new_name)
+            self.update_list()
+
+    def delete_agent(self, agent_id: str, force: bool = False):
+        """
+        Delete agent
+
+        :param agent_id: agent ID
+        :param force: force delete without confirmation
+        """
+        if not force:
+            self.window.ui.dialogs.confirm(
+                type='agent.builder.agent.delete',
+                id=agent_id,
+                msg=trans('agent.builder.confirm.delete.msg'),
+            )
+            return
+        self.window.core.agents.custom.delete_agent(agent_id)
+        self.update_list()
+        if self.current_agent == agent_id:
+            self.current_agent = None
+            self.window.ui.editor["agent.builder"].clear(ask_user=False)
+
+    def update_list(self):
+        """Update agents list"""
+        data = self.window.core.agents.custom.get_agents()
+        self.window.ui.nodes["agent.builder.list"].update_list(data)
+
+    def select_on_list(self, agent_id: str):
+        """
+        Select agent on list
+
+        :param agent_id: agent ID
+        """
+        nodes = self.window.ui.nodes
+        models = self.window.ui.models
+
+        agents_list = nodes["agent.builder.list"].list
+        model = models.get("agent.builder.list")
+
+        if model is None:
+            return
+        for row in range(model.rowCount()):
+            idx = model.index(row, 0)
+            if str(model.data(idx, QtCore.Qt.UserRole)) == str(agent_id):
+                agents_list.setCurrentIndex(idx)
+                sm = agents_list.selectionModel()
+                if sm:
+                    sm.select(idx, QtCore.QItemSelectionModel.ClearAndSelect)
+                agents_list.scrollTo(idx)
+                break
+
+    def setup_menu(self) -> Dict[str, QAction]:
+        """
+        Setup main menu
+
+        :return dict with menu actions
+        """
+        actions = {}
+        actions["agent.builder"] = QAction(
+            QIcon(":/icons/robot.svg"),
+            trans("menu.tools.agent.builder"),
+            self.window,
+            checkable=False,
+        )
+        actions["agent.builder"].triggered.connect(
+            lambda: self.toggle()
+        )
+        return actions
+
+    def setup_dialogs(self):
+        """Setup dialogs (static)"""
+        pass
+
+    def get_lang_mappings(self) -> Dict[str, Dict]:
+        """
+        Get language mappings
+
+        :return: dict with language mappings
+        """
+        return {
+            'menu.text': {
+                'tools.agent.builder': 'menu.tools.agent.builder',
+            }
+        }

pygpt_net/tools/agent_builder/ui/dialogs.py

@@ -0,0 +1,152 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# ================================================== #
+# This file is a part of PYGPT package               #
+# Website: https://pygpt.net                         #
+# GitHub:  https://github.com/szczyglis-dev/py-gpt   #
+# MIT License                                        #
+# Created By  : Marcin Szczygliński                  #
+# Updated Date: 2025.09.19 00:00:00                  #
+# ================================================== #
+
+from PySide6.QtCore import Qt
+from PySide6.QtGui import QAction, QIcon
+from PySide6.QtWidgets import QVBoxLayout, QMenuBar, QSplitter
+
+from pygpt_net.tools.agent_builder.ui.list import AgentsWidget
+from pygpt_net.ui.widget.builder.editor import NodeEditor
+from pygpt_net.ui.widget.dialog.base import BaseDialog
+from pygpt_net.utils import trans
+
+
+class Builder:
+
+    def __init__(self, window=None, tool=None):
+        """
+        Builder dialog
+
+        :param window: Window instance
+        """
+        self.window = window
+        self.tool = tool
+        self.menu_bar = None
+        self.file_menu = None
+        self.actions = {}
+
+    def setup_menu(self, parent=None) -> QMenuBar:
+        """Setup audio 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"].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"].triggered.connect(lambda checked=False, t=t: t.clear())
+
+        self.file_menu.addAction(self.actions["open"])
+        self.file_menu.addAction(self.actions["save"])
+        self.file_menu.addAction(self.actions["clear"])
+        return self.menu_bar
+
+    def setup(self):
+        """Setup agent_builder dialog"""
+        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("""
+            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.on_clear = self.tool.clear
+
+        u.editor[id] = editor
+
+        layout = QVBoxLayout()
+        layout.setMenuBar(self.setup_menu(dlg))
+
+        agents_list = AgentsWidget(self.window, tool=self.tool)
+        list_widget = agents_list.setup()
+        list_widget.setFixedWidth(250)
+        center_splitter = QSplitter(Qt.Horizontal)
+        center_splitter.addWidget(list_widget)
+        center_splitter.addWidget(u.editor[id])
+        center_splitter.setStretchFactor(0, 1)
+        center_splitter.setStretchFactor(1, 8)
+        layout.addWidget(center_splitter)
+
+        u.nodes["agent.builder.list"] = agents_list
+
+        dlg.setLayout(layout)
+        dlg.setWindowTitle(trans("agent.builder.title"))
+
+    def clear(self):
+        """Clear transcribe dialog"""
+        pass
+
+
+class BuilderDialog(BaseDialog):
+    def __init__(self, window=None, id=None):
+        """
+        BuilderDialog
+
+        :param window: main window
+        :param id: configurator id
+        """
+        super(BuilderDialog, self).__init__(window, id)
+        self.window = window
+        self.id = id  # id
+
+    def closeEvent(self, event):
+        """
+        Close event
+
+        :param event: close event
+        """
+        self.cleanup()
+        super(BuilderDialog, self).closeEvent(event)
+
+    def keyPressEvent(self, event):
+        """
+        Key press event
+
+        :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()

pygpt_net/tools/agent_builder/ui/list.py

@@ -0,0 +1,228 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# ================================================== #
+# This file is a part of PYGPT package               #
+# Website: https://pygpt.net                         #
+# GitHub:  https://github.com/szczyglis-dev/py-gpt   #
+# MIT License                                        #
+# Created By  : Marcin Szczygliński                  #
+# Updated Date: 2025.08.24 23:00:00                  #
+# ================================================== #
+
+from PySide6 import QtCore
+from PySide6.QtCore import QPoint
+from PySide6.QtGui import QAction, QIcon, Qt, QStandardItemModel
+from PySide6.QtWidgets import QMenu, QVBoxLayout, QPushButton, QWidget
+
+from pygpt_net.ui.widget.lists.base import BaseList
+from pygpt_net.utils import trans
+
+
+class AgentsWidget:
+    def __init__(self, window=None, tool=None):
+        """
+        Agents select widget
+
+        :param window: main window
+        :param tool: tool instance
+        """
+        self.window = window
+        self.tool = tool
+        self.id = "agent.builder.list"
+        self.list = None
+
+    def setup(self):
+        """
+        Setup agents list widget
+
+        :return: QWidget
+        """
+        new_btn = QPushButton(QIcon(":/icons/add.svg"), "")
+        new_btn.clicked.connect(self.action_new)
+
+        self.list = AgentsList(self.window, 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.list.setModel(self.window.ui.models[self.id])
+
+        widget = QWidget()
+        widget.setLayout(layout)
+        return widget
+
+    def action_new(self):
+        """
+        New agent action
+        """
+        self.tool.add_agent()
+
+    def create_model(self, parent) -> QStandardItemModel:
+        """
+        Create list model
+        :param parent: parent widget
+        :return: QStandardItemModel
+        """
+        return QStandardItemModel(0, 1, parent)
+
+    def update_list(self, data):
+        """
+        Update presets list
+
+        :param data: Data to update
+        """
+        nodes = self.window.ui.nodes
+        models = self.window.ui.models
+
+        view = nodes[self.id]
+        model = models.get(self.id)
+
+        if model is None:
+            model = self.create_model(self.window)
+            models[self.id] = model
+            view.setModel(model)
+        try:
+            if not data:
+                model.setRowCount(0)
+            else:
+                count = len(data)
+                model.setRowCount(count)
+                index_fn = model.index
+                set_item_data = model.setItemData
+                display_role = QtCore.Qt.DisplayRole
+
+                for i, (key, item) in enumerate(data.items()):
+                    agent_id = item.id  # <---------- from this
+                    name = item.name
+                    idx = index_fn(i, 0)
+                    set_item_data(idx, {
+                        display_role: name,
+                        QtCore.Qt.UserRole: agent_id,
+                    })
+        finally:
+            pass
+
+class AgentsList(BaseList):
+    _ICO_EDIT = QIcon(":/icons/edit.svg")
+    _ICO_COPY = QIcon(":/icons/copy.svg")
+    _ICO_UNDO = QIcon(":/icons/undo.svg")
+    _ICO_DELETE = QIcon(":/icons/delete.svg")
+    _ICO_CHECK = QIcon(":/icons/check.svg")
+    _ICO_CLOSE = QIcon(":/icons/close.svg")
+
+    def __init__(self, window=None, tool=None, id=None):
+        """
+        Agents select menu
+
+        :param window: main window
+        :param id: input id
+        """
+        super(AgentsList, self).__init__(window)
+        self.window = window
+        self.id = id
+        self.tool = tool
+        self.doubleClicked.connect(self.dblclick)
+        self.setContextMenuPolicy(Qt.CustomContextMenu)
+        self.customContextMenuRequested.connect(self.show_context_menu)
+
+    def click(self, item):
+        idx = item.row()
+        if idx >= 0:
+            model = self.model()
+            agent_id = model.data(model.index(idx, 0), QtCore.Qt.UserRole)
+            if agent_id is not None:
+                self.tool.edit_agent(agent_id)
+
+    def dblclick(self, val):
+        """
+        Double click event
+
+        :param val: double click event
+        """
+        pass
+
+    def show_context_menu(self, pos: QPoint):
+        """
+        Context menu event
+
+        :param pos: QPoint
+        """
+        global_pos = self.viewport().mapToGlobal(pos)
+        index = self.indexAt(pos)
+        if not index.isValid():
+            return
+
+        menu = QMenu(self)
+
+        edit_act = QAction(self._ICO_EDIT, trans('preset.action.edit'), menu)
+        edit_act.triggered.connect(lambda checked=False, it=index: self.action_edit(it))
+        menu.addAction(edit_act)
+
+        duplicate_act = QAction(self._ICO_COPY, trans('preset.action.duplicate'), menu)
+        duplicate_act.triggered.connect(lambda checked=False, it=index: self.action_duplicate(it))
+        menu.addAction(duplicate_act)
+
+        delete_act = QAction(self._ICO_DELETE, trans('preset.action.delete'), menu)
+        delete_act.triggered.connect(lambda checked=False, it=index: self.action_delete(it))
+        menu.addAction(delete_act)
+
+        menu.exec_(global_pos)
+
+    def action_edit(self, item):
+        """
+        Edit action handler
+
+        :param item: list item
+        """
+        idx = item.row()
+        if idx >= 0:
+            model = self.model()
+            agent_id = model.data(model.index(idx, 0), QtCore.Qt.UserRole)
+            if agent_id is not None:
+                self.tool.rename_agent(agent_id)
+
+    def action_duplicate(self, item):
+        """
+        Duplicate action handler
+
+        :param item: list item
+        """
+        idx = item.row()
+        if idx >= 0:
+            model = self.model()
+            agent_id = model.data(model.index(idx, 0), QtCore.Qt.UserRole)
+            if agent_id is not None:
+                self.tool.duplicate_agent(agent_id)
+
+    def action_delete(self, item):
+        """
+        Delete action handler
+
+       :param item: list item
+        """
+        idx = item.row()
+        if idx >= 0:
+            model = self.model()
+            agent_id = model.data(model.index(idx, 0), QtCore.Qt.UserRole)
+            if agent_id is not None:
+                self.tool.delete_agent(agent_id)
+
+    def mousePressEvent(self, event):
+        if event.button() == Qt.LeftButton:
+            index = self.indexAt(event.pos())
+            if not index.isValid():
+                return
+            super().mousePressEvent(event)
+        elif event.button() == Qt.RightButton:
+            event.accept()
+        else:
+            super().mousePressEvent(event)
+
+    def selectionCommand(self, index, event=None):
+        """
+        Selection command
+        :param index: Index
+        :param event: Event
+        """
+        return super().selectionCommand(index, event)