pygpt-net 2.4.37__py3-none-any.whl → 2.4.42__py3-none-any.whl

pygpt_net/tools/html_canvas/__init__.py

@@ -6,36 +6,46 @@
 # GitHub:  https://github.com/szczyglis-dev/py-gpt   #
 # MIT License                                        #
 # Created By  : Marcin Szczygliński                  #
-# Updated Date: 2024.11.11 23:00:00                  #
+# Updated Date: 2024.12.14 22:00:00                  #
 # ================================================== #
 
 import os
+from typing import Dict
 
-from PySide6.QtCore import QTimer, Slot, QUrl
+from PySide6.QtCore import QTimer, Slot
 from PySide6.QtGui import QAction, QIcon
-from PySide6.QtWidgets import QFileDialog
+from PySide6.QtWidgets import QFileDialog, QWidget
 
+from pygpt_net.core.tabs.tab import Tab
 from pygpt_net.core.text.utils import output_clean_html, output_html2text
 from pygpt_net.tools.base import BaseTool
-from pygpt_net.tools.html_canvas.ui.dialogs import Canvas
 from pygpt_net.utils import trans
 
+from .ui.dialogs import Tool
+from .ui.widgets import ToolWidget, ToolSignals
+
 
 class HtmlCanvas(BaseTool):
     def __init__(self, *args, **kwargs):
         """
-        HTML/JS canvas
+        HTML/JS Canvas
 
         :param window: Window instance
         """
         super(HtmlCanvas, self).__init__(*args, **kwargs)
         self.id = "html_canvas"
+        self.dialog_id = "html_canvas"
+        self.has_tab = True
+        self.tab_title = "menu.tools.html_canvas"
+        self.tab_icon = ":/icons/code.svg"
         self.opened = False
         self.is_edit = False
         self.auto_clear = True
         self.dialog = None
         self.is_edit = False
+        self.auto_opened = False
         self.file_output = ".canvas.html"
+        self.signals = ToolSignals()
 
     def setup(self):
         """Setup"""
@@ -50,16 +60,19 @@ class HtmlCanvas(BaseTool):
         """Update menu"""
         self.update_menu()
 
-    def toggle_edit(self):
-        """Toggle edit mode"""
+    def toggle_edit(self, widget: ToolWidget):
+        """
+        Toggle edit mode
+
+        :param widget: Canvas widget
+        """
         current = self.is_edit
         self.is_edit = not self.is_edit
-        self.window.ui.nodes['html_canvas.edit'].setVisible(self.is_edit)
-        self.window.ui.nodes['html_canvas.output'].setVisible(not self.is_edit)
+        widget.edit.setVisible(self.is_edit)
+        widget.output.setVisible(not self.is_edit)
         if current:
-            self.set_output(self.window.ui.nodes['html_canvas.edit'].toPlainText())
+            self.set_output(widget.edit.toPlainText())
             self.save_output()
-        self.window.ui.nodes['html_canvas.btn.edit'].setChecked(self.is_edit)
 
     def update_menu(self):
         """Update menu"""
@@ -78,18 +91,26 @@ class HtmlCanvas(BaseTool):
         """
         return os.path.join(self.window.core.config.get_user_dir("data"), self.file_output)
 
+    def get_dialog_id(self) -> str:
+        """
+        Get dialog ID
+
+        :return: Dialog ID
+        """
+        return self.dialog_id
+
     def set_output(self, output: str):
         """
         Set output HTML
 
         :param output: Output HTML code
         """
-        path = os.path.join(self.window.core.config.get_user_dir("data"), self.file_output)
+        path = self.get_current_path()
         with open(path, "w", encoding="utf-8") as f:
             f.write(output)
         if os.path.exists(path):
-            self.window.ui.nodes['html_canvas.output'].setUrl(QUrl().fromLocalFile(path))
-        self.window.ui.nodes['html_canvas.edit'].setPlainText(output)
+            self.signals.reload.emit(path)
+        self.signals.update.emit(output)
 
     def reload_output(self):
         """Reload output data"""
@@ -102,11 +123,16 @@ class HtmlCanvas(BaseTool):
 
         :return: Output data
         """
-        return self.window.ui.nodes['html_canvas.edit'].toPlainText()
+        path = self.get_current_path()
+        data = ""
+        if os.path.exists(path):
+            with open(path, "r", encoding="utf-8") as f:
+                data = f.read()
+        return data
 
     def load_output(self):
         """Load output data from file"""
-        path = os.path.join(self.window.core.config.get_user_dir("data"), self.file_output)
+        path = self.get_current_path()
         data = ""
         if os.path.exists(path):
             with open(path, "r", encoding="utf-8") as f:
@@ -115,14 +141,14 @@ class HtmlCanvas(BaseTool):
 
     def save_output(self):
         """Save output data to file"""
-        path = os.path.join(self.window.core.config.get_user_dir("data"), self.file_output)
+        path = self.get_current_path()
         data = self.get_output()
         with open(path, "w", encoding="utf-8") as f:
             f.write(data)
 
     def clear_output(self):
         """Clear output"""
-        path = os.path.join(self.window.core.config.get_user_dir("data"), self.file_output)
+        path = self.get_current_path()
         if os.path.exists(path):
             os.remove(path)
         self.set_output("")
@@ -151,9 +177,17 @@ class HtmlCanvas(BaseTool):
         if not self.opened:
             self.opened = True
             self.load_output()
-            self.window.ui.dialogs.open('html_canvas', width=800, height=600)
+            self.window.ui.dialogs.open(self.dialog_id, width=800, height=600)
             self.update()
 
+    def auto_open(self):
+        """Auto open canvas dialog"""
+        if self.window.controller.ui.tabs.is_current_tool(self.id):
+            return # do not open if already opened in tab
+        if not self.auto_opened:
+            self.auto_opened = True
+            self.open()
+
     def open_file(self):
         """Open file dialog"""
         last_dir = self.window.core.config.get_last_used_dir()
@@ -172,7 +206,7 @@ class HtmlCanvas(BaseTool):
     def close(self):
         """Close HTML canvas dialog"""
         self.opened = False
-        self.window.ui.dialogs.close('html_canvas')
+        self.window.ui.dialogs.close(self.dialog_id)
         self.update()
 
     def toggle(self):
@@ -193,13 +227,21 @@ class HtmlCanvas(BaseTool):
         else:
             self.close()
 
+    def get_toolbar_icon(self) -> QWidget:
+        """
+        Get toolbar icon
+
+        :return: QWidget
+        """
+        return self.window.ui.nodes['icon.html_canvas']
+
     def toggle_icon(self, state: bool):
         """
         Toggle canvas icon
 
         :param state: State
         """
-        self.window.ui.nodes['icon.html_canvas'].setVisible(state)
+        self.get_toolbar_icon().setVisible(state)
 
     def get_current_output(self) -> str:
         """
@@ -207,7 +249,7 @@ class HtmlCanvas(BaseTool):
 
         :return: Output data
         """
-        return self.window.ui.nodes['html_canvas.output'].get_html_content()
+        return self.get_output()
 
     @Slot(str, str)
     def handle_save_as(self, text: str, type: str = 'txt'):
@@ -224,7 +266,7 @@ class HtmlCanvas(BaseTool):
         # fix: QTimer required here to prevent crash if signal emitted from WebEngine window
         QTimer.singleShot(0, lambda: self.window.controller.chat.common.save_text(text, type))
 
-    def setup_menu(self) -> dict:
+    def setup_menu(self) -> Dict[str, QAction]:
         """
         Setup main menu
 
@@ -242,16 +284,30 @@ class HtmlCanvas(BaseTool):
         )
         return actions
 
+    def as_tab(self, tab: Tab) -> QWidget:
+        """
+        Spawn and return tab instance
+
+        :param tab: Parent Tab instance
+        :return: Tab widget instance
+        """
+        canvas = Tool(window=self.window, tool=self)
+        layout = canvas.widget.setup()
+        widget = QWidget()
+        widget.setLayout(layout)
+        self.load_output()
+        return widget
+
     def setup_dialogs(self):
         """Setup dialogs (static)"""
-        self.dialog = Canvas(self.window)
+        self.dialog = Tool(window=self.window, tool=self)
         self.dialog.setup()
 
     def setup_theme(self):
         """Setup theme"""
         pass
 
-    def get_lang_mappings(self) -> dict:
+    def get_lang_mappings(self) -> Dict[str, Dict]:
         """
         Get language mappings
 

pygpt_net/tools/html_canvas/ui/dialogs.py

@@ -6,29 +6,32 @@
 # GitHub:  https://github.com/szczyglis-dev/py-gpt   #
 # MIT License                                        #
 # Created By  : Marcin Szczygliński                  #
-# Updated Date: 2024.11.11 23:00:00                  #
+# Updated Date: 2024.12.09 23:00:00                  #
 # ================================================== #
 
 import re
 
 from PySide6.QtCore import Qt
 from PySide6.QtGui import QAction, QIcon
-from PySide6.QtWidgets import QHBoxLayout, QVBoxLayout, QCheckBox, QMenuBar
+from PySide6.QtWidgets import QMenuBar, QVBoxLayout
 
-from pygpt_net.tools.html_canvas.ui.widgets import CanvasOutput, CanvasEdit
 from pygpt_net.ui.widget.dialog.base import BaseDialog
-from pygpt_net.ui.widget.element.labels import HelpLabel
-from pygpt_net.ui.widget.textarea.html import CustomWebEnginePage
 from pygpt_net.utils import trans
 
-class Canvas:
-    def __init__(self, window=None):
+from .widgets import ToolWidget
+
+class Tool:
+    def __init__(self, window=None, tool=None):
         """
         HTML/JS canvas dialog
 
         :param window: Window instance
+        :param tool: Tool instance
         """
         self.window = window
+        self.tool = tool  # tool instance
+        self.widget = ToolWidget(window, tool)
+        self.layout = None
         self.menu_bar = None
         self.menu = {}
         self.actions = {}  # menu actions
@@ -45,20 +48,20 @@ class Canvas:
 
         self.actions["file.open"] = QAction(QIcon(":/icons/folder.svg"), trans("tool.html_canvas.menu.file.open"))
         self.actions["file.open"].triggered.connect(
-            lambda: self.window.tools.get("html_canvas").open_file()
+            lambda: self.tool.open_file()
         )
         self.actions["file.save_as"] = QAction(QIcon(":/icons/save.svg"), trans("tool.html_canvas.menu.file.save_as"))
         self.actions["file.save_as"].triggered.connect(
-            lambda: self.window.ui.nodes['html_canvas.output'].signals.save_as.emit(
-                re.sub(r'\n{2,}', '\n\n', self.window.ui.nodes['html_canvas.output'].html_content), 'html')
+            lambda: self.widget.output.signals.save_as.emit(
+                re.sub(r'\n{2,}', '\n\n', self.widget.output.html_content), 'html')
         )
         self.actions["file.reload"] = QAction(QIcon(":/icons/reload.svg"), trans("tool.html_canvas.menu.file.reload"))
         self.actions["file.reload"].triggered.connect(
-            lambda: self.window.tools.get("html_canvas").reload_output()
+            lambda: self.tool.reload_output()
         )
         self.actions["file.clear"] = QAction(QIcon(":/icons/close.svg"), trans("tool.html_canvas.menu.file.clear"))
         self.actions["file.clear"].triggered.connect(
-            lambda: self.window.tools.get("html_canvas").clear()
+            lambda: self.tool.clear()
         )
 
         # add actions
@@ -70,61 +73,44 @@ class Canvas:
 
     def setup(self):
         """Setup canvas dialog"""
-        self.window.ui.nodes['html_canvas.output'] = CanvasOutput(self.window)
-        self.window.ui.nodes['html_canvas.output'].setPage(
-            CustomWebEnginePage(self.window, self.window.ui.nodes['html_canvas.output'])
-        )
-        self.window.ui.nodes['html_canvas.edit'] = CanvasEdit(self.window)
-        self.window.ui.nodes['html_canvas.edit'].setVisible(False)
-        self.window.ui.nodes['html_canvas.edit'].textChanged.connect(
-            lambda: self.window.tools.get("html_canvas").save_output()
-        )
-
-        # edit checkbox
-        self.window.ui.nodes['html_canvas.btn.edit'] = QCheckBox(trans("html_canvas.btn.edit"))
-        self.window.ui.nodes['html_canvas.btn.edit'].stateChanged.connect(
-            lambda: self.window.tools.get("html_canvas").toggle_edit()
-        )
-
-        path = self.window.tools.get("html_canvas").get_current_path()
-        path_label = HelpLabel(path)
-        path_label.setMaximumHeight(30)
-        path_label.setAlignment(Qt.AlignRight)
+        self.layout = self.widget.setup()
+        self.layout.setMenuBar(self.setup_menu())  # add menu bar
 
-        bottom_layout = QHBoxLayout()
-        bottom_layout.addWidget(self.window.ui.nodes['html_canvas.btn.edit'])
-        bottom_layout.addWidget(path_label)
+        id = self.tool.get_dialog_id()
+        dialog = ToolDialog(window=self.window, tool=self.tool)
+        dialog.setLayout(self.layout)
+        dialog.setWindowTitle(trans("dialog.html_canvas.title"))
+        dialog.resize(800, 500)
+        self.window.ui.dialog[id] = dialog
 
-        output_layout = QVBoxLayout()
-        output_layout.addWidget(self.window.ui.nodes['html_canvas.output'])
-        output_layout.addWidget(self.window.ui.nodes['html_canvas.edit'])
-        output_layout.setContentsMargins(0, 0, 0, 0)
+    def get_widget(self) -> ToolWidget:
+        """
+        Get widget
 
-        # connect signals
-        self.window.ui.nodes['html_canvas.output'].signals.save_as.connect(self.window.tools.get("html_canvas").handle_save_as)
-        self.window.ui.nodes['html_canvas.output'].signals.audio_read.connect(self.window.controller.chat.render.handle_audio_read)
+        :return: ToolWidget
+        """
+        return self.widget
 
-        layout = QVBoxLayout()
-        layout.setMenuBar(self.setup_menu())  # add menu bar
-        layout.addLayout(output_layout)
-        layout.addLayout(bottom_layout)
+    def get_tab(self) -> QVBoxLayout:
+        """
+        Get layout
 
-        self.window.ui.dialog['html_canvas'] = CanvasDialog(self.window)
-        self.window.ui.dialog['html_canvas'].setLayout(layout)
-        self.window.ui.dialog['html_canvas'].setWindowTitle(trans("dialog.html_canvas.title"))
-        self.window.ui.dialog['html_canvas'].resize(800, 500)
+        :return: QVBoxLayout
+        """
+        return self.layout
 
 
-class CanvasDialog(BaseDialog):
-    def __init__(self, window=None, id="html_canvas"):
+class ToolDialog(BaseDialog):
+    def __init__(self, window=None, id="html_canvas", tool=None):
         """
         HTML canvas dialog
 
         :param window: main window
         :param id: logger id
         """
-        super(CanvasDialog, self).__init__(window, id)
+        super(ToolDialog, self).__init__(window, id)
         self.window = window
+        self.tool = tool
 
     def closeEvent(self, event):
         """
@@ -133,7 +119,7 @@ class CanvasDialog(BaseDialog):
         :param event: close event
         """
         self.cleanup()
-        super(CanvasDialog, self).closeEvent(event)
+        super(ToolDialog, self).closeEvent(event)
 
     def keyPressEvent(self, event):
         """
@@ -145,14 +131,12 @@ class CanvasDialog(BaseDialog):
             self.cleanup()
             self.close()  # close dialog when the Esc key is pressed.
         else:
-            super(CanvasDialog, self).keyPressEvent(event)
+            super(ToolDialog, self).keyPressEvent(event)
 
     def cleanup(self):
-        """
-        Cleanup on close
-        """
-        if self.window is None:
+        """Cleanup on close"""
+        if self.window is None or self.tool is None:
             return
-        self.window.tools.get("html_canvas").opened = False
-        self.window.tools.get("html_canvas").close()
-        self.window.tools.get("html_canvas").update()
+        self.tool.opened = False
+        self.tool.close()
+        self.tool.update()

pygpt_net/tools/html_canvas/ui/widgets.py

@@ -6,13 +6,101 @@
 # GitHub:  https://github.com/szczyglis-dev/py-gpt   #
 # MIT License                                        #
 # Created By  : Marcin Szczygliński                  #
-# Updated Date: 2024.11.11 23:00:00                  #
+# Updated Date: 2024.12.09 23:00:00                  #
 # ================================================== #
 
+from PySide6.QtCore import Qt, Slot, QUrl, QObject, Signal
+from PySide6.QtWidgets import QVBoxLayout, QCheckBox, QHBoxLayout
+
+from pygpt_net.ui.widget.element.labels import HelpLabel
 from pygpt_net.ui.widget.textarea.editor import BaseCodeEditor
-from pygpt_net.ui.widget.textarea.html import HtmlOutput
+from pygpt_net.ui.widget.textarea.html import HtmlOutput, CustomWebEnginePage
 
 import pygpt_net.icons_rc
+from pygpt_net.utils import trans
+
+
+class ToolWidget:
+    def __init__(self, window=None, tool=None):
+        """
+        HTML/JS canvas widget
+
+        :param window: Window instance
+        :param tool: Tool instance
+        """
+        self.window = window
+        self.tool = tool  # tool instance
+        self.output = None  # canvas output
+        self.edit = None  # canvas edit
+        self.btn_edit = None  # edit checkbox
+
+    def setup(self) -> QVBoxLayout:
+        """
+        Setup widget body
+
+        :return: QVBoxLayout
+        """
+        self.output = CanvasOutput(self.window)
+        self.output.setPage(
+            CustomWebEnginePage(self.window, self.output)
+        )
+        self.edit = CanvasEdit(self.window)
+        self.edit.setVisible(False)
+        self.edit.textChanged.connect(
+            lambda: self.tool.save_output()
+        )
+
+        # edit checkbox
+        self.btn_edit = QCheckBox(trans("html_canvas.btn.edit"))
+        self.btn_edit.stateChanged.connect(
+            lambda: self.tool.toggle_edit(self)
+        )
+
+        path = self.tool.get_current_path()
+        path_label = HelpLabel(path)
+        path_label.setMaximumHeight(30)
+        path_label.setAlignment(Qt.AlignRight)
+
+        bottom_layout = QHBoxLayout()
+        bottom_layout.addWidget(self.btn_edit)
+        bottom_layout.addWidget(path_label)
+
+        output_layout = QVBoxLayout()
+        output_layout.addWidget(self.output)
+        output_layout.addWidget(self.edit)
+        output_layout.setContentsMargins(0, 0, 0, 0)
+
+        # connect signals
+        self.output.signals.save_as.connect(
+            self.tool.handle_save_as)
+        self.output.signals.audio_read.connect(
+            self.window.controller.chat.render.handle_audio_read)
+
+        self.tool.signals.update.connect(self.set_output)
+        self.tool.signals.reload.connect(self.load_output)
+
+        layout = QVBoxLayout()
+        layout.addLayout(output_layout)
+        layout.addLayout(bottom_layout)
+        return layout
+
+    @Slot(str)
+    def set_output(self, content: str):
+        """
+        Set output content
+
+        :param content: Content
+        """
+        self.edit.setPlainText(content)
+
+    @Slot(str)
+    def load_output(self, path: str):
+        """
+        Load output content
+
+        :param path: Content
+        """
+        self.output.setUrl(QUrl().fromLocalFile(path))
 
 class CanvasOutput(HtmlOutput):
     def __init__(self, window=None):
@@ -39,4 +127,9 @@ class CanvasEdit(BaseCodeEditor):
         self.min_font_size = 8
         self.setProperty('class', 'interpreter-output')
         self.default_stylesheet = ""
-        self.setStyleSheet(self.default_stylesheet)
+        self.setStyleSheet(self.default_stylesheet)
+
+
+class ToolSignals(QObject):
+    update = Signal(str)  # data
+    reload = Signal(str)  # path

pygpt_net/tools/image_viewer/__init__.py

@@ -6,12 +6,13 @@
 # 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.14 22:00:00                  #
 # ================================================== #
 
 import hashlib
 import os
 import shutil
+from typing import Dict, Optional
 
 from PySide6 import QtGui, QtCore
 from PySide6.QtGui import QAction, QIcon
@@ -19,6 +20,7 @@ from PySide6.QtWidgets import QFileDialog
 
 from pygpt_net.tools.base import BaseTool
 from pygpt_net.tools.image_viewer.ui.dialogs import DialogSpawner
+from pygpt_net.ui.widget.dialog.base import BaseDialog
 from pygpt_net.utils import trans
 
 
@@ -255,7 +257,7 @@ class ImageViewer(BaseTool):
         except Exception as e:
             self.window.core.debug.log(e)
 
-    def setup_menu(self) -> dict:
+    def setup_menu(self) -> Dict[str, QAction]:
         """
         Setup main menu
 
@@ -273,7 +275,11 @@ class ImageViewer(BaseTool):
         )
         return actions
 
-    def get_instance(self, type_id: str, dialog_id: str = None):
+    def get_instance(
+            self,
+            type_id: str,
+            dialog_id: Optional[str] = None
+    ) -> Optional[BaseDialog]:
         """
         Spawn and return dialog instance
 
@@ -284,7 +290,7 @@ class ImageViewer(BaseTool):
         if type_id == "image_viewer":
             return self.spawner.setup(dialog_id)
 
-    def get_lang_mappings(self) -> dict:
+    def get_lang_mappings(self) -> Dict[str, Dict]:
         """
         Get language mappings
 

pygpt_net/tools/indexer/__init__.py

@@ -6,11 +6,12 @@
 # GitHub:  https://github.com/szczyglis-dev/py-gpt   #
 # MIT License                                        #
 # Created By  : Marcin Szczygliński                  #
-# Updated Date: 2024.08.20 19:00:00                  #
+# Updated Date: 2024.12.14 22:00:00                  #
 # ================================================== #
 
 import datetime
 import json
+from typing import Dict, Any, List
 
 from PySide6.QtCore import Slot
 from PySide6.QtGui import QAction, QIcon, QTextCursor
@@ -200,7 +201,7 @@ class IndexerTool(BaseTool):
                 last_str = datetime.datetime.fromtimestamp(last_ts).strftime('%Y-%m-%d %H:%M:%S')
         self.window.ui.nodes['tool.indexer.ctx.last_auto'].setText(last_str)
 
-    def update_tab_files(self):
+    def update_tab_files(self) -> List[str]:
         """
         Update files tab
 
@@ -420,7 +421,7 @@ class IndexerTool(BaseTool):
         self.refresh()
 
     @Slot(object)
-    def handle_log(self, data: any):
+    def handle_log(self, data: Any):
         """
         Handle log message
 
@@ -428,7 +429,7 @@ class IndexerTool(BaseTool):
         """
         self.log(data)
 
-    def log(self, data: any):
+    def log(self, data: Any):
         """
         Log message to console or logger window
 
@@ -451,7 +452,7 @@ class IndexerTool(BaseTool):
         """Clear log"""
         self.window.ui.nodes["tool.indexer.status"].clear()
 
-    def get_tables(self) -> dict:
+    def get_tables(self) -> Dict[str, Dict]:
         """
         Get tables configuration
 
@@ -513,7 +514,7 @@ class IndexerTool(BaseTool):
         }
         return tables
 
-    def setup_menu(self) -> dict:
+    def setup_menu(self) -> Dict[str, QAction]:
         """
         Setup main menu (Tools)
 
@@ -536,7 +537,7 @@ class IndexerTool(BaseTool):
         self.dialog = DialogBuilder(self.window)
         self.dialog.setup()
 
-    def get_lang_mappings(self) -> dict:
+    def get_lang_mappings(self) -> Dict[str, Dict]:
         """
         Get language mappings