pygpt-net 2.4.38__py3-none-any.whl → 2.4.40__py3-none-any.whl

pygpt_net/controller/tools/__init__.py

@@ -6,10 +6,15 @@
 # GitHub:  https://github.com/szczyglis-dev/py-gpt   #
 # MIT License                                        #
 # Created By  : Marcin Szczygliński                  #
-# Updated Date: 2024.11.07 23:00:00                  #
+# Updated Date: 2024.12.12 01:00:00                  #
 # ================================================== #
 
+from PySide6.QtGui import QAction, QIcon
+from PySide6.QtWidgets import QTabWidget, QMenu
+
 from pygpt_net.core.tabs.tab import Tab
+from pygpt_net.utils import trans
+
 
 class Tools:
     def __init__(self, window=None):
@@ -44,6 +49,37 @@ class Tools:
         if idx is not None:
             self.window.controller.ui.tabs.switch_tab_by_idx(idx)
 
+    def append_tab_menu(
+            self,
+            parent: QTabWidget,
+            menu: QMenu,
+            idx: int,
+            column_idx: int
+    ) -> QMenu:
+        """
+        Append tab menu
+
+        :param parent: parent widget
+        :param menu: menu
+        :param idx: tab index
+        :param column_idx: column index
+        :return: tab add submenu
+        """
+        submenu = menu.addMenu(QIcon(":/icons/add.svg"), trans("action.tab.add.tool"))
+        tools = self.window.tools.get_all()
+        for id in tools:
+            tool = tools[id]
+            if not tool.has_tab:
+                continue
+            icon = tool.tab_icon
+            title = trans(tool.tab_title)
+            action = QAction(QIcon(icon), title, parent)
+            action.triggered.connect(
+                lambda idx=idx, column_idx=column_idx, id=id: parent.add_tab(idx, column_idx, Tab.TAB_TOOL, id)
+            )
+            submenu.addAction(action)
+        return submenu
+
     def get_tab_tools(self) -> dict:
         """
         Get tab tools

pygpt_net/controller/ui/__init__.py

@@ -6,7 +6,7 @@
 # GitHub:  https://github.com/szczyglis-dev/py-gpt   #
 # MIT License                                        #
 # Created By  : Marcin Szczygliński                  #
-# Updated Date: 2024.11.21 20:00:00                  #
+# Updated Date: 2024.12.09 23:00:00                  #
 # ================================================== #
 
 from PySide6.QtGui import QColor
@@ -47,10 +47,6 @@ class UI:
         self.update()
         self.init_toolbox()
 
-    def pre_setup(self):
-        """Post setup UI"""
-        self.tabs.setup()
-
     def update(self):
         """Update all elements"""
 

pygpt_net/controller/ui/tabs.py

@@ -6,7 +6,7 @@
 # GitHub:  https://github.com/szczyglis-dev/py-gpt   #
 # MIT License                                        #
 # Created By  : Marcin Szczygliński                  #
-# Updated Date: 2024.11.20 21:00:00                  #
+# Updated Date: 2024.12.12 01:00:00                  #
 # ================================================== #
 
 from PySide6.QtCore import QTimer
@@ -29,40 +29,91 @@ class Tabs:
         self.initialized = False
         self.appended = False
         self.current = 0
+        self.column_idx = 0
+        self.tmp_column_idx = 0
+        self.locked = False
+        self.col = {}
 
     def setup(self):
         """Setup tabs"""
         self.window.core.tabs.load()
         self.window.controller.notepad.load()
+        self.setup_options()
         self.initialized = True
 
-    def add(self, type: int, title: str, icon=None, reference=None, data_id=None):
-        """
-        Add tab
+    def setup_options(self):
+        """Setup options"""
+        state = self.window.core.config.get("layout.split", False)
+        self.window.ui.nodes['layout.split'].setChecked(state)
+        if not state:
+            self.window.ui.splitters['columns'].setSizes([1, 0])
+
+    def add(
+            self,
+            type: int,
+            title: str,
+            icon=None,
+            child=None,
+            data_id=None,
+            tool_id=None,
+    ):
+        """
+        Add a new tab
 
         :param type: Tab type
         :param title: Tab title
         :param icon: Tab icon
-        :param reference: Tab reference
-        :param data_id: Tab data ID
-        """
-        self.window.core.tabs.add(type, title, icon, reference, data_id)
-
-    def append(self, type: int, idx: int):
-        """
-        Append tab in place
+        :param child: Tab child (child widget)
+        :param data_id: Tab data ID (child data ID)
+        :param tool_id: Tool ID
+        """
+        self.window.core.tabs.add(
+            type=type,
+            title=title,
+            icon=icon,
+            child=child,
+            data_id=data_id,
+            tool_id=tool_id
+        )
+
+    def append(
+            self,
+            type: int,
+            tool_id: str = None,
+            idx: int = 0,
+            column_idx: int = 0
+    ):
+        """
+        Append tab at tab index
 
         :param type: Tab type
+        :param tool_id: Tool ID
         :param idx: Tab index
+        :param column_idx: Column index
         """
         self.appended = True  # lock reload in previous tab
-        self.window.core.tabs.append(type, idx)
-        self.switch_tab_by_idx(idx + 1)  # switch to new tab
+        self.column_idx = column_idx  # switch to column
+        tab = self.window.core.tabs.append(
+            type=type,
+            idx=idx,
+            column_idx=column_idx,
+            tool_id=tool_id
+        )
+        self.switch_tab_by_idx(tab.idx, column_idx)  # switch to new tab
 
     def reload_titles(self):
         """Reload tab titles"""
         self.window.core.tabs.reload_titles()
 
+    def update_current(self):
+        """Update current tab"""
+        curr_tab = self.get_current_tab()
+        curr_column = self.get_current_column_idx()
+        if curr_column not in self.col:
+            self.col[curr_column] = -1
+        if curr_tab is not None:
+            self.col[curr_column] = curr_tab.pid
+
     def reload(self):
         """Reload tabs"""
         self.window.core.tabs.reload()
@@ -78,15 +129,16 @@ class Tabs:
             else:
                 self.window.ui.nodes['output_plain'][pid].setVisible(False)
                 self.window.ui.nodes['output'][pid].setVisible(True)
-        self.switch_tab(Tab.TAB_CHAT)
+        #self.switch_tab(Tab.TAB_CHAT)
 
-    def on_tab_changed(self, idx: int):
+    def on_tab_changed(self, idx: int, column_idx: int = 0):
         """
         Output tab changed
 
         :param idx: tab index
+        :param column_idx: column index
         """
-        tab = self.window.core.tabs.get_tab_by_index(idx)
+        tab = self.window.core.tabs.get_tab_by_index(idx, column_idx)
         if tab is None:
             self.appended = False
             return
@@ -99,43 +151,57 @@ class Tabs:
                 if meta is not None:
                     self.window.controller.ctx.load(meta.id)  # reload
 
-
         prev_tab = self.current
+        prev_column = self.column_idx
         self.current = idx
+        self.column_idx = column_idx
         self.window.controller.ui.mode.update()
         self.window.controller.ui.vision.update()
 
         # check type
         if tab.type == Tab.TAB_NOTEPAD:
             self.window.controller.notepad.opened_once = True
-            self.window.controller.notepad.on_open(idx)
+            self.window.controller.notepad.on_open(idx, column_idx)
         elif tab.type == Tab.TAB_CHAT:
-            pid_meta = self.window.core.ctx.output.get_meta(tab.pid)
-            meta = self.window.core.ctx.get_meta_by_id(pid_meta)
+            # get meta for selected tab, if not loaded yet then append meta here
+            meta_id = self.window.core.ctx.output.prepare_meta(tab)
+            meta = self.window.core.ctx.get_meta_by_id(meta_id)
             if meta is not None:
-                self.window.controller.ctx.load(pid_meta)  # reload renderer
+                self.window.controller.ctx.load(meta.id)  # reload renderer
         elif tab.type == Tab.TAB_TOOL_PAINTER:
             if self.window.core.config.get('vision.capture.enabled'):
                 self.window.controller.camera.enable_capture()
 
-        if prev_tab != idx:
+        if prev_tab != idx or prev_column != column_idx:
             self.window.dispatch(AppEvent(AppEvent.TAB_SELECTED))  # app event
 
-    def get_current_idx(self) -> int:
+        self.window.controller.ui.update()
+        self.update_current()
+
+    def get_current_idx(self, column_idx: int = 0) -> int:
         """
         Get current tab index
 
+        :param column_idx: column index
         :return: tab index
         """
         return self.current
 
+    def get_current_column_idx(self) -> int:
+        """
+        Get current column index
+
+        :return: column index
+        """
+        return self.column_idx
+
     def get_current_tab(self) -> Tab or None:
         """
         Get current tab
 
         :return: tab
         """
-        return self.window.core.tabs.get_tab_by_index(self.current)
+        return self.window.core.tabs.get_tab_by_index(self.get_current_idx(), self.column_idx)
 
     def get_current_type(self) -> int or None:
         """
@@ -143,7 +209,7 @@ class Tabs:
 
         :return: tab type
         """
-        tab = self.window.core.tabs.get_tab_by_index(self.current)
+        tab = self.window.core.tabs.get_tab_by_index(self.get_current_idx(), self.column_idx)
         if tab is None:
             return None
         return tab.type
@@ -154,7 +220,7 @@ class Tabs:
 
         :return: tab PID
         """
-        tab = self.window.core.tabs.get_tab_by_index(self.current)
+        tab = self.window.core.tabs.get_tab_by_index(self.get_current_idx(), self.column_idx)
         if tab is None:
             return None
         return tab.pid
@@ -166,7 +232,7 @@ class Tabs:
         :param idx: tab index
         :return: tab type
         """
-        tab = self.window.core.tabs.get_tab_by_index(idx)
+        tab = self.window.core.tabs.get_tab_by_index(idx, self.column_idx)
         if tab is None:
             return None
         return tab.type
@@ -178,68 +244,118 @@ class Tabs:
         :param type: tab type
         :return: tab index
         """
-        return self.window.core.tabs.get_min_idx_by_type(type)
+        return self.window.core.tabs.get_min_idx_by_type(type, self.column_idx)
 
-    def on_tab_clicked(self, idx: int):
+    def on_column_changed(self):
+        """Column changed event"""
+        if self.locked:
+            return
+        tab = self.window.core.tabs.get_tab_by_index(self.current, self.column_idx)
+        if tab is None:
+            return
+        current_ctx = self.window.core.ctx.get_current()
+        if current_ctx is not None and current_ctx != tab.data_id:
+            self.window.controller.ctx.select_on_list_only(tab.data_id)
+        self.window.controller.ui.update()
+        self.update_current()
+
+    def on_tab_clicked(self, idx: int, column_idx: int = 0):
         """
         Tab click event
 
         :param idx: tab index
+        :param column_idx: column index
+        """
+        self.current = idx
+        self.column_idx = column_idx
+        self.on_column_changed()
+        self.update_current()
+
+    def on_column_focus(self, idx: int):
+        """
+        Column focus event
+
+        :param idx: column index
         """
-        pass
+        self.column_idx = idx
+        self.on_column_changed()
+        self.update_current()
 
-    def on_tab_dbl_clicked(self, idx: int):
+    def on_tab_dbl_clicked(self, idx: int, column_idx: int = 0):
         """
         Tab double click event
 
         :param idx: tab index
+        :param column_idx: column index
         """
-        pass
+        self.column_idx = column_idx
+        self.on_tab_changed(idx, column_idx)
+        self.update_current()
 
-    def on_tab_closed(self, idx: int):
+    def on_tab_closed(self, idx: int, column_idx: int = 0):
         """
         Tab close event
 
         :param idx: tab index
+        :param column_idx: column index
         """
-        self.window.core.tabs.remove_tab_by_idx(idx)
+        if self.locked:
+            return
+        self.window.core.tabs.remove_tab_by_idx(idx, column_idx)
+        self.update_current()
 
-    def on_tab_moved(self, idx: int):
+    def on_tab_moved(self, idx: int, column_idx: int = 0):
         """
         Tab moved event
 
         :param idx: tab index
+        :param column_idx: column index
         """
+        if self.locked:
+            return
         self.window.core.tabs.update()
+        self.update_current()
 
-    def close(self, idx: int):
+    def close(self, idx: int, column_idx: int = 0):
         """
         Close tab
 
         :param idx: tab index
+        :param column_idx: column index
         """
-        self.on_tab_closed(idx)
+        self.on_tab_closed(idx, column_idx)
+        self.update_current()
 
-    def close_all(self, type: int, force: bool = False):
+    def close_all(
+            self,
+            type: int,
+            column_idx: int = 0,
+            force: bool = False
+    ):
         """
         Close all tabs
 
         :param type: tab type
+        :param column_idx: column index
         :param force: force close
         """
         if not force:
+            self.tmp_column_idx = column_idx
             self.window.ui.dialogs.confirm(
                 type='tab.close_all',
                 id=type,
                 msg=trans('tab.close_all.confirm'),
             )
             return
-        self.window.core.tabs.remove_all_by_type(type)
+        column_idx = self.tmp_column_idx
+        self.window.core.tabs.remove_all_by_type(type, column_idx)
+        self.update_current()
 
     def next_tab(self):
         """Switch to next tab"""
-        current = self.window.ui.tabs['output'].currentIndex()
-        all = len(self.window.ui.tabs['output'].children())
+        tabs = self.window.ui.layout.get_active_tabs()
+        current = tabs.currentIndex()
+        all = len(tabs.children())
         next = current + 1
         if next >= all:
             next = 0
@@ -247,8 +363,9 @@ class Tabs:
 
     def prev_tab(self):
         """Switch to previous tab"""
-        current = self.window.ui.tabs['output'].currentIndex()
-        all = len(self.window.ui.tabs['output'].children())
+        tabs = self.window.ui.layout.get_active_tabs()
+        current = tabs.currentIndex()
+        all = len(tabs.children())
         prev = current - 1
         if prev < 0:
             prev = all - 1
@@ -264,14 +381,16 @@ class Tabs:
         if idx is not None:
             self.switch_tab_by_idx(idx)
 
-    def switch_tab_by_idx(self, idx: int):
+    def switch_tab_by_idx(self, idx: int, column_idx: int = 0):
         """
         Switch tab by index
 
         :param idx: tab index
+        :param column_idx: column index
         """
-        self.window.ui.tabs['output'].setCurrentIndex(idx)
-        self.on_tab_changed(idx)
+        tabs = self.window.ui.layout.get_tabs_by_idx(column_idx)
+        tabs.setCurrentIndex(idx)
+        self.on_tab_changed(idx, column_idx)
 
     def get_current_tab_name(self) -> str:
         """
@@ -279,7 +398,8 @@ class Tabs:
 
         :return: tab name
         """
-        return self.window.ui.tabs['output'].tabText(self.current)
+        tabs = self.window.ui.layout.get_active_tabs()
+        return tabs.tabText(self.current)
 
     def get_current_tab_name_for_audio(self) -> str:
         """
@@ -309,18 +429,20 @@ class Tabs:
         """
         Update tab tooltip
 
-        :param tooltip: tooltip
+        :param tooltip: tooltip text
         """
-        self.window.ui.tabs['output'].setTabToolTip(self.current, tooltip)
+        tabs = self.window.ui.layout.get_active_tabs()
+        tabs.setTabToolTip(self.current, tooltip)
 
-    def rename(self, idx: int):
+    def rename(self, idx: int, column_idx: int = 0):
         """
-        Rename tab
+        Rename tab (show dialog)
 
         :param idx: tab idx
+        :param column_idx: column idx
         """
         # get tab
-        tab = self.window.core.tabs.get_tab_by_index(idx)
+        tab = self.window.core.tabs.get_tab_by_index(idx, column_idx)
         if tab is None:
             return
         # set dialog and show
@@ -329,7 +451,12 @@ class Tabs:
         self.window.ui.dialog['rename'].current = idx
         self.window.ui.dialog['rename'].show()
 
-    def update_name(self, idx: int, name: str, close: bool = True):
+    def update_name(
+            self,
+            idx: int,
+            name: str,
+            close: bool = True
+    ):
         """
         Update tab title
 
@@ -349,7 +476,11 @@ class Tabs:
         """
         self.update_name(self.current, name)
 
-    def update_title(self, idx: int, title: str):
+    def update_title(
+            self,
+            idx: int,
+            title: str
+    ):
         """
         Update tab title
 
@@ -359,8 +490,9 @@ class Tabs:
         # check if current tab is chat
         if self.get_current_type() != Tab.TAB_CHAT:
             return
+        tabs = self.window.ui.layout.get_active_tabs()
         tooltip = title
-        self.window.ui.tabs['output'].setTabToolTip(idx, tooltip)
+        tabs.setTabToolTip(idx, tooltip)
         if len(title) > 8:
             title = title[:8] + '...'  # truncate to max 8 chars
         self.window.core.tabs.update_title(idx, title, tooltip)
@@ -383,7 +515,110 @@ class Tabs:
         if idx is not None:
             self.switch_tab_by_idx(idx)
 
-    def new_tab(self):
-        """Handle [+} button"""
-        idx = self.get_current_idx()
-        self.append(Tab.TAB_CHAT, idx)
+    def new_tab(self, column_idx: int = 0):
+        """
+        Handle [+] button
+
+        :param column_idx: column index
+        """
+        idx = self.get_current_idx(column_idx)
+        self.append(
+            type=Tab.TAB_CHAT,
+            tool_id=None,
+            idx=idx,
+            column_idx=column_idx
+        )
+
+    def restore_data(self):
+        """Restore tab data"""
+        data = self.window.core.config.get("tabs.opened", [])
+        if not data:
+            self.switch_tab_by_idx(0, 0)
+            return
+
+        # reverse order, second column is first
+        data = dict(reversed(list(data.items())))
+        for col_idx in data:
+            tab_idx = data[col_idx]
+            self.switch_tab_by_idx(int(tab_idx), int(col_idx))
+
+        # set default column to 0
+        self.column_idx = 0
+        self.on_column_changed()
+
+    def move_tab(self, idx: int, column_idx: int, new_column_idx: int):
+        """
+        Move tab to another column
+
+        :param idx: tab index
+        :param column_idx: column index
+        :param new_column_idx: new column index
+        """
+        self.locked = True
+        tab = self.window.core.tabs.get_tab_by_index(idx, column_idx)
+        self.window.core.tabs.move_tab(tab, new_column_idx)
+        self.locked = False
+        # switch to new column
+        self.column_idx = new_column_idx
+        self.on_column_changed()
+        # switch to new tab
+        self.switch_tab_by_idx(tab.idx, new_column_idx)
+
+    def toggle_split_screen(self, state):
+        """
+        Toggle split screen mode
+
+        :param state: True if split screen is enabled
+        """
+        if state:
+            # self.rightWidget.show()
+            self.window.ui.splitters['columns'].setSizes([1, 1])
+        else:
+            # self.rightWidget.hide()
+            self.window.ui.splitters['columns'].setSizes([1, 0])
+            # set to first column
+            self.column_idx = 0
+            self.on_column_changed()
+        self.window.core.config.set("layout.split", state)
+        self.window.core.config.save()
+
+    def is_current_by_type(self, type: int) -> bool:
+        """
+        Check if one of current tabs is of given type
+
+        :param type: tab type
+        :return: True if one of tab is of given type
+        """
+        for col in self.col:
+            pid = self.col[col]
+            tab = self.window.core.tabs.get_tab_by_pid(pid)
+            if tab is not None and tab.type == type:
+                return True
+
+    def is_current_tool(self, tool_id: str) -> bool:
+        """
+        Check if one of current tabs is of given tool ID
+
+        :param tool_id: tool ID
+        :return: True if one of tab is of given tool ID
+        """
+        for col in self.col:
+            pid = self.col[col]
+            tab = self.window.core.tabs.get_tab_by_pid(pid)
+            if tab is not None and tab.tool_id == tool_id:
+                return True
+
+    def switch_to_first_chat(self):
+        """Switch to first chat tab"""
+        if self.is_current_by_type(Tab.TAB_CHAT):
+            return
+        # abort if active tab is chat
+        if self.get_current_type() == Tab.TAB_CHAT:
+            return
+        # find first chat tab
+        for col in self.col:
+            pid = self.col[col]
+            tab = self.window.core.tabs.get_tab_by_pid(pid)
+            if tab is not None and tab.type == Tab.TAB_CHAT:
+                self.switch_tab_by_idx(tab.idx, col)
+                return

pygpt_net/core/command.py

@@ -6,7 +6,7 @@
 # GitHub:  https://github.com/szczyglis-dev/py-gpt   #
 # MIT License                                        #
 # Created By  : Marcin Szczygliński                  #
-# Updated Date: 2024.11.21 20:00:00                  #
+# Updated Date: 2024.12.13 08:00:00                  #
 # ================================================== #
 
 import copy
@@ -18,6 +18,7 @@ from pygpt_net.core.types import (
     MODE_COMPLETION,
     MODE_LANGCHAIN,
     MODE_LLAMA_INDEX,
+    MODE_AUDIO,
 )
 from pygpt_net.core.events import Event
 from pygpt_net.item.ctx import CtxItem
@@ -537,6 +538,7 @@ class Command:
             MODE_LLAMA_INDEX,
             MODE_LANGCHAIN,
             MODE_COMPLETION,
+            MODE_AUDIO,
         ]
         mode = self.window.core.config.get('mode')
         if mode in disabled_modes: