pygpt-net 2.1.37__py3-none-any.whl → 2.4.48__py3-none-any.whl

pygpt_net/controller/notepad.py

@@ -6,13 +6,19 @@
 # GitHub:  https://github.com/szczyglis-dev/py-gpt   #
 # MIT License                                        #
 # Created By  : Marcin Szczygliński                  #
-# Updated Date: 2024.02.28 22:00:00                  #
+# Updated Date: 2024.12.14 08:00:00                  #
 # ================================================== #
 
-from PySide6.QtGui import QIcon, QTextCursor
+from typing import Optional, Tuple
 
+from PySide6.QtGui import QTextCursor
+
+from pygpt_net.core.tabs.tab import Tab
 from pygpt_net.item.notepad import NotepadItem
+from pygpt_net.ui.widget.tabs.body import TabBody
+from pygpt_net.ui.widget.textarea.notepad import NotepadWidget
 from pygpt_net.utils import trans
+
 import pygpt_net.icons_rc
 
 
@@ -24,10 +30,29 @@ class Notepad:
         :param window: Window instance
         """
         self.window = window
-        self.default_num_notepads = 1
-        self.start_tab_idx = 4  # tab idx from notepad starts
         self.opened_once = False
 
+    def create(
+            self,
+            idx: Optional[int] = None
+    ) -> Tuple[TabBody, int, int]:
+        """
+        Create notepad widget
+
+        :param idx: notepad idx
+        :return: notepad widget (TabBody)
+        """
+        if idx is None:
+            idx = self.window.core.tabs.count_by_type(Tab.TAB_NOTEPAD) + 1
+        data_id = idx
+        self.window.ui.notepad[data_id] = NotepadWidget(self.window)
+        self.window.ui.notepad[data_id].id = idx
+        self.window.ui.notepad[data_id].textarea.id = idx
+        title = trans('output.tab.notepad')
+        title += " " + str(idx)
+        children = self.window.core.tabs.from_widget(self.window.ui.notepad[data_id])
+        return children, idx, data_id
+
     def load(self):
         """Load all notepads contents"""
         self.window.core.notepad.load_all()
@@ -47,42 +72,7 @@ class Notepad:
                     item.idx = idx
                     items[idx] = item
                 if idx in self.window.ui.notepad:
-                    title = items[idx].title
                     self.window.ui.notepad[idx].setText(items[idx].content)
-                    if items[idx].initialized and title is not None and len(title) > 0:
-                        self.update_name(idx, items[idx].title, False)
-
-    def reload_tab_names(self):
-        """Reload tab names (after lang change)"""
-        num_notepads = self.get_num_notepads()
-        items = self.window.core.notepad.get_all()
-        if num_notepads > 0:
-            for i in range(1, num_notepads + 1):
-                if i not in items or not items[i].initialized:
-                    tab = i + (self.start_tab_idx - 1)
-                    if num_notepads > 1:
-                        self.window.ui.tabs['output'].setTabText(
-                            tab,
-                            trans('output.tab.notepad') + " " + str(i),
-                        )
-                    else:
-                        self.window.ui.tabs['output'].setTabText(
-                            tab,
-                            trans('output.tab.notepad'),
-                        )
-                    self.window.ui.tabs['output'].setTabIcon(
-                        tab,
-                        QIcon(":/icons/paste.svg"),
-                    )
-
-        for idx in items:
-            title = items[idx].title
-            if items[idx].initialized and title is not None and len(title) > 0:
-                self.update_name(
-                    idx,
-                    items[idx].title,
-                    False,
-                )
 
     def get_notepad_name(self, idx: int):
         """
@@ -103,66 +93,6 @@ class Notepad:
             title = item.title
         return title
 
-    def rename(self, idx: int):
-        """
-        Rename tab
-
-        :param idx: notepad index (real, not tab idx)
-        """
-        # get attachment object by ID
-        item = self.window.core.notepad.get_by_id(idx)
-        if item is None:
-            return
-
-        # set dialog and show
-        self.window.ui.dialog['rename'].id = 'notepad'
-        self.window.ui.dialog['rename'].input.setText(item.title)
-        self.window.ui.dialog['rename'].current = idx
-        self.window.ui.dialog['rename'].show()
-        self.update()
-
-    def update_name(self, idx: int, name: str, close: bool = True):
-        """
-        Update notepad title
-
-        :param idx: notepad idx
-        :param name: notepad name
-        :param close: close dialog
-        """
-        num = self.get_num_notepads()
-        item = self.window.core.notepad.get_by_id(idx)
-        if item is None:
-            item = NotepadItem()
-            item.idx = idx
-            self.window.core.notepad.items[idx] = item
-
-        tab_idx = idx + (self.start_tab_idx - 1)  # calculate tab idx
-        if name is None or len(name) == 0:
-            # set default name
-            if num > 1:
-                self.window.ui.tabs['output'].setTabText(
-                    tab_idx,
-                    trans('output.tab.notepad') + " " + str(idx),
-                )
-            else:
-                self.window.ui.tabs['output'].setTabText(
-                    tab_idx,
-                    trans('output.tab.notepad'),
-                )
-            item.title = ""
-            item.initialized = False
-        else:
-            # set custom name
-            self.window.ui.tabs['output'].setTabText(
-                tab_idx,
-                name,
-            )
-            item.title = name
-            item.initialized = True
-        self.window.core.notepad.update(item)
-        if close:
-            self.window.ui.dialog['rename'].close()
-
     def save(self, idx: int):
         """
         Save notepad contents
@@ -187,11 +117,12 @@ class Notepad:
         items = self.window.core.notepad.get_all()
         num_notepads = self.get_num_notepads()
         if num_notepads > 0:
-            for idx in range(1, num_notepads + 1):
+            tabs = self.window.core.tabs.get_tabs_by_type(Tab.TAB_NOTEPAD)
+            for tab in tabs:
+                idx = tab.data_id
                 if idx in self.window.ui.notepad:
                     prev_content = str(items[idx].content)
                     items[idx].content = self.window.ui.notepad[idx].toPlainText()
-
                     # update only if content changed
                     if prev_content != items[idx].content:
                         self.window.core.notepad.update(items[idx])
@@ -230,15 +161,19 @@ class Notepad:
 
         :return: number of notepads
         """
-        return int(self.window.core.config.get('notepad.num') or self.default_num_notepads)
+        return self.window.core.tabs.count_by_type(Tab.TAB_NOTEPAD)
 
     def get_current_active(self) -> int:
         """
-        Get current notepad index
+        Get current notepad idx
 
         :return: current notepad index
         """
-        return self.window.ui.tabs['output'].currentIndex() - (self.start_tab_idx - 1)
+        if self.is_active():
+            tab = self.window.controller.ui.tabs.get_current_tab()
+            if tab is not None:
+                return tab.data_id
+        return 1
 
     def is_active(self) -> bool:
         """
@@ -246,34 +181,108 @@ class Notepad:
 
         :return: True if notepad tab is active
         """
-        return self.window.ui.tabs['output'].currentIndex() >= self.start_tab_idx
-
-    def rename_upd(self, idx: int, name: str):
-        """
-        Rename notepad tab
-
-        :param idx: notepad idx
-        :param name: new notepad name
-        """
-        item = self.window.core.notepad.get_by_id(idx)
-        if item is None:
-            item = NotepadItem()
-            item.idx = idx
-            self.window.core.notepad.items[idx] = item
-        item.title = name
-        self.window.core.notepad.update(item)
-        self.update()
+        return self.window.controller.ui.tabs.get_current_type() == Tab.TAB_NOTEPAD
 
     def open(self):
         """Open notepad"""
         # if notepad disabled, do nothing
         if self.get_num_notepads() == 0:
             return
+
         # switch to first notepad tab if current tab is not notepad
-        if self.window.controller.ui.current_tab < self.start_tab_idx:
-            self.window.ui.tabs['output'].setCurrentIndex(self.start_tab_idx)
+        tabs = self.window.ui.layout.get_active_tabs()
+        if self.window.controller.ui.tabs.get_current_type() != Tab.TAB_NOTEPAD:
+            idx = self.window.core.tabs.get_min_idx_by_type(Tab.TAB_NOTEPAD)
+            if idx is not None:
+                tabs.setCurrentIndex(idx)
+
         self.window.activateWindow()  # focus
 
     def update(self):
         """Update notepads UI"""
         pass
+
+    def reload(self):
+        """Reload notepads"""
+        self.window.core.notepad.locked = True
+        self.window.core.notepad.reset()
+        self.load()
+        self.window.core.notepad.locked = False
+
+    def switch_to_tab(self, idx: Optional[int] = None):
+        """
+        Switch to notepad tab
+
+        :param idx: notepad idx
+        """
+        if idx is None:
+            idx = self.get_first_notepad_tab_idx()
+        tabs = self.window.ui.layout.get_active_tabs()
+        tab = self.window.core.tabs.get_tab_by_index(idx)
+        if tab is not None:
+            tabs.setCurrentIndex(idx)
+        else:
+            tabs.setCurrentIndex(self.get_first_notepad_tab_idx())
+
+    def get_first_notepad_tab_idx(self) -> int:
+        """
+        Get first notepad tab index
+
+        :return: first notepad tab index
+        """
+        return self.window.core.tabs.get_min_idx_by_type(Tab.TAB_NOTEPAD)
+
+    def get_current_notepad_text(self) -> str:
+        """
+        Get current notepad text
+
+        :return: current notepad text
+        """
+        idx = self.get_current_active()
+        if idx in self.window.ui.notepad:
+            return self.window.ui.notepad[idx].toPlainText()
+        return ""
+
+    def get_notepad_text(self, idx: int) -> str:
+        """
+        Get notepad text
+
+        :param idx: notepad index
+        :return: notepad text
+        """
+        if idx in self.window.ui.notepad:
+            return self.window.ui.notepad[idx].toPlainText()
+        return ""
+
+    def clear(self, idx: int) -> bool:
+        """
+        Clear notepad contents
+
+        :param idx: notepad idx
+        """
+        if idx in self.window.ui.notepad:
+            self.window.ui.notepad[idx].textarea.clear()
+            self.save(idx)
+            return True
+        return False
+
+    def on_open(
+            self,
+            tab_idx: int,
+            column_idx: int = 0
+    ):
+        """
+        On open notepad tab
+
+        :param tab_idx: current tab idx
+        :param column_idx: column idx
+        """
+        tab = self.window.controller.ui.tabs.get_current_tab()
+        if tab is None:
+            return
+        if tab.type == Tab.TAB_NOTEPAD:
+            idx = tab.data_id
+            if idx in self.window.ui.notepad:
+                if not self.window.ui.notepad[idx].opened:
+                    self.window.ui.notepad[idx].scroll_to_bottom()
+                    self.window.ui.notepad[idx].opened = True

pygpt_net/controller/painter/__init__.py

@@ -6,11 +6,12 @@
 # GitHub:  https://github.com/szczyglis-dev/py-gpt   #
 # MIT License                                        #
 # Created By  : Marcin Szczygliński                  #
-# Updated Date: 2024.03.17 09:00:00                  #
+# Updated Date: 2024.11.20 21:00:00                  #
 # ================================================== #
 
 import os
 
+from pygpt_net.core.tabs.tab import Tab
 from .capture import Capture
 from .common import Common
 
@@ -42,7 +43,7 @@ class Painter:
         :param path: path to image
         """
         self.window.ui.painter.open_image(path)
-        self.window.ui.status("Image loaded: " + os.path.basename(path))
+        self.window.update_status("Image loaded: " + os.path.basename(path))
 
     def open_external(self, path: str):
         """
@@ -56,6 +57,8 @@ class Painter:
 
     def save(self):
         """Store current image"""
+        if not hasattr(self.window.ui, 'painter'):
+            return
         path = os.path.join(self.common.get_capture_dir(), '_current.png')
         self.window.ui.painter.image.save(path)
 
@@ -65,10 +68,15 @@ class Painter:
 
     def restore(self):
         """Restore previous image"""
+        if not hasattr(self.window.ui, 'painter'):
+            return
         path = os.path.join(self.common.get_capture_dir(), '_current.png')
         if os.path.exists(path):
             self.window.ui.painter.image.load(path)
-            self.window.ui.painter.update()
+        else:
+            # clear image
+            self.window.ui.painter.clear_image()
+        self.window.ui.painter.update()
 
     def is_active(self) -> bool:
         """
@@ -76,4 +84,8 @@ class Painter:
 
         :return: True if painter is current active tab
         """
-        return self.window.controller.ui.current_tab == self.window.controller.ui.tab_idx['draw']
+        return self.window.controller.ui.tabs.get_current_type() == Tab.TAB_TOOL_PAINTER
+
+    def reload(self):
+        """Reload painter"""
+        self.setup()

pygpt_net/controller/painter/capture.py

@@ -6,14 +6,22 @@
 # GitHub:  https://github.com/szczyglis-dev/py-gpt   #
 # MIT License                                        #
 # Created By  : Marcin Szczygliński                  #
-# Updated Date: 2024.01.23 19:00:00                  #
+# Updated Date: 2024.12.14 08:00:00                  #
 # ================================================== #
 
 import datetime
+import math
 import os
+from typing import Optional, Union
+
+import mss
+import mss.tools
+from PIL import Image, ImageDraw
+from pynput.mouse import Controller
 
 from PySide6.QtGui import QImage
 
+from pygpt_net.core.events import KernelEvent
 from pygpt_net.utils import trans
 
 
@@ -39,14 +47,58 @@ class Capture:
         image = QImage(frame.data, width, height, bytes, QImage.Format_RGB888)
         self.window.ui.painter.set_image(image)
 
-    def screenshot(self):
-        """Make screenshot and append to attachments"""
-        # switch to vision mode if needed
-        self.window.controller.chat.vision.switch_to_vision()
+    def capture_screen_with_custom_cursor(self, save_path: str) -> str:
+        """
+        Capture screen with custom cursor
 
-        # clear attachments before capture if needed
-        if self.window.controller.attachment.is_capture_clear():
-            self.window.controller.attachment.clear(True)
+        :param save_path: Save path
+        :return: Save path
+        """
+        cursor_path = os.path.join(self.window.core.config.get_app_path(), "data", "icons", "cursor.png")
+
+        with mss.mss() as sct:
+            monitor = sct.monitors[1]
+            screenshot = sct.grab(monitor)
+            img = Image.frombytes('RGB', screenshot.size, screenshot.rgb)
+
+        mouse = Controller()
+        cursor_x, cursor_y = mouse.position
+
+        cursor_x -= monitor['left']
+        cursor_y -= monitor['top']
+
+        img = img.convert('RGBA')
+
+        cursor_img = Image.open(cursor_path).convert('RGBA')
+        cursor_width, cursor_height = cursor_img.size
+
+        paste_x = int(cursor_x - 20)
+        paste_y = int(cursor_y - 20)
+
+        img.paste(cursor_img, (paste_x, paste_y), cursor_img)
+
+        img.save(save_path)
+        return save_path
+
+    def screenshot(
+            self,
+            attach_cursor: bool = False,
+            silent: bool = False
+    ) -> Optional[Union[str, bool]]:
+        """
+        Make screenshot and append to attachments
+
+        :param attach_cursor: True to with custom cursor
+        :param silent: Silent mode
+        :return: Path to screenshot or False if failed
+        """
+        if not silent:
+            # switch to vision mode if needed
+            self.window.controller.chat.vision.switch_to_vision()
+
+            # clear attachments before capture if needed
+            if self.window.controller.attachment.is_capture_clear():
+                self.window.controller.attachment.clear(True, auto=True)
 
         try:
             # prepare filename
@@ -56,16 +108,26 @@ class Capture:
             path = os.path.join(self.window.controller.painter.common.get_capture_dir(), name + '.png')
 
             # capture screenshot
-            screen = self.window.app.primaryScreen()
-            screenshot = screen.grabWindow(0)
-            screenshot.save(path, 'png')
-            self.attach(name, path, 'screenshot')
-            self.window.controller.painter.open(path)
-
-            # show last capture time in status
-            dt_info = now.strftime("%Y-%m-%d %H:%M:%S")
-            self.window.statusChanged.emit(trans("painter.capture.manual.captured.success") + ' ' + dt_info)
-            return True
+            if attach_cursor:
+                if not self.capture_screen_with_custom_cursor(path):  # capture with custom cursor
+                    return False
+            else:
+                with mss.mss(with_cursor=False) as sct:
+                    monitor = sct.monitors[1]
+                    sct_img = sct.grab(monitor)
+                    mss.tools.to_png(sct_img.rgb, sct_img.size, output=path)
+
+            self.attach(name, path, 'screenshot', silent=silent)
+
+            if not silent:
+                self.window.controller.painter.open(path)
+                # show last capture time in status
+                dt_info = now.strftime("%Y-%m-%d %H:%M:%S")
+                event = KernelEvent(KernelEvent.STATUS, {
+                    'status': trans("painter.capture.manual.captured.success") + ' ' + dt_info,
+                })
+                self.window.dispatch(event)
+            return path
 
         except Exception as e:
             print("Screenshot capture exception", e)
@@ -78,7 +140,7 @@ class Capture:
 
         # clear attachments before capture if needed
         if self.window.controller.attachment.is_capture_clear():
-            self.window.controller.attachment.clear(True)
+            self.window.controller.attachment.clear(True, auto=True)
 
         try:
             # prepare filename
@@ -93,20 +155,30 @@ class Capture:
 
             # show last capture time in status
             dt_info = now.strftime("%Y-%m-%d %H:%M:%S")
-            self.window.statusChanged.emit(trans("painter.capture.manual.captured.success") + ' ' + dt_info)
+            event = KernelEvent(KernelEvent.STATUS, {
+                'status': trans("painter.capture.manual.captured.success") + ' ' + dt_info,
+            })
+            self.window.dispatch(event)
             return True
 
         except Exception as e:
             print("Image capture exception", e)
             self.window.core.debug.log(e)
 
-    def attach(self, name: str, path: str, type: str = 'drawing'):
+    def attach(
+            self,
+            name: str,
+            path: str,
+            type: str = 'drawing',
+            silent: bool = False
+    ):
         """
         Attach image to attachments
 
         :param name: image name
         :param path: image path
         :param type: capture type (drawing, screenshot)
+        :param silent: silent mode
         """
         mode = self.window.core.config.get('mode')
         if type == 'drawing':
@@ -120,4 +192,6 @@ class Capture:
         # make attachment
         self.window.core.attachments.new(mode, title, path, False)
         self.window.core.attachments.save()
-        self.window.controller.attachment.update()
+
+        if not silent:
+            self.window.controller.attachment.update()

pygpt_net/controller/painter/common.py

@@ -6,9 +6,11 @@
 # GitHub:  https://github.com/szczyglis-dev/py-gpt   #
 # MIT License                                        #
 # Created By  : Marcin Szczygliński                  #
-# Updated Date: 2024.02.17 15:00:00                  #
+# Updated Date: 2024.12.14 08:00:00                  #
 # ================================================== #
 
+from typing import Tuple, Optional, Dict, List
+
 from PySide6.QtCore import Qt, QSize
 from PySide6.QtGui import QColor
 
@@ -22,7 +24,7 @@ class Common:
         """
         self.window = window
 
-    def convert_to_size(self, canvas_size: str) -> tuple:
+    def convert_to_size(self, canvas_size: str) -> Tuple[int, int]:
         """
         Convert string to size
 
@@ -64,7 +66,7 @@ class Common:
             self.window.core.config.set('painter.brush.mode', "erase")
             self.window.core.config.save()
 
-    def change_canvas_size(self, selected=None):
+    def change_canvas_size(self, selected: Optional[str] = None):
         """
         Change the canvas size
 
@@ -79,7 +81,7 @@ class Common:
             self.window.core.config.set('painter.canvas.size', selected)
             self.window.core.config.save()
 
-    def change_brush_size(self, size):
+    def change_brush_size(self, size: int):
         """
         Change the brush size
 
@@ -143,7 +145,7 @@ class Common:
                 self.window.ui.nodes['painter.select.brush.size'].findText(str(size))
         )
 
-    def get_colors(self) -> dict:
+    def get_colors(self) -> Dict[str, QColor]:
         """
         Get colors dict
 
@@ -161,7 +163,7 @@ class Common:
             "Violet": QColor('violet')
         }
 
-    def get_sizes(self) -> list:
+    def get_sizes(self) -> List[str]:
         """
         Get brush sizes
 
@@ -169,7 +171,7 @@ class Common:
         """
         return ['1', '2', '3', '5', '8', '12', '15', '20', '25', '30', '50', '100', '200']
 
-    def get_canvas_sizes(self) -> list:
+    def get_canvas_sizes(self) -> List[str]:
         """
         Get canvas sizes