pygpt-net 2.6.63__py3-none-any.whl → 2.6.65__py3-none-any.whl

pygpt_net/ui/widget/filesystem/explorer.py

@@ -6,13 +6,13 @@
 # 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.28 08:00:00                  #
 # ================================================== #
 
 import datetime
 import os
 
-from PySide6.QtCore import Qt, QModelIndex, QDir
+from PySide6.QtCore import Qt, QModelIndex, QDir, QObject, QEvent
 from PySide6.QtGui import QAction, QIcon, QCursor, QResizeEvent
 from PySide6.QtWidgets import QTreeView, QMenu, QWidget, QVBoxLayout, QFileSystemModel, QLabel, QHBoxLayout, \
     QPushButton, QSizePolicy
@@ -23,6 +23,117 @@ from pygpt_net.ui.widget.element.labels import HelpLabel
 from pygpt_net.utils import trans
 
 
+class ExplorerDropHandler(QObject):
+    """
+    Drag & drop handler for FileExplorer (uploads into target directory).
+    - Accepts local file and directory URLs.
+    - Determines target directory from drop position:
+      * directory item -> that directory
+      * file item      -> parent directory
+      * empty area     -> explorer root directory
+    - Uses Files controller to perform the actual copy and refresh view.
+    """
+    def __init__(self, explorer):
+        super().__init__(explorer)
+        self.explorer = explorer
+        self.view = explorer.treeView
+
+        # Enable drops on both the view and its viewport
+        try:
+            self.view.setAcceptDrops(True)
+        except Exception:
+            pass
+        vp = self.view.viewport()
+        if vp is not None:
+            try:
+                vp.setAcceptDrops(True)
+            except Exception:
+                pass
+            vp.installEventFilter(self)
+        self.view.installEventFilter(self)
+
+    def _mime_has_local_urls(self, md) -> bool:
+        try:
+            if md and md.hasUrls():
+                for url in md.urls():
+                    if url.isLocalFile():
+                        return True
+        except Exception:
+            pass
+        return False
+
+    def _local_paths_from_mime(self, md) -> list:
+        out = []
+        try:
+            if not (md and md.hasUrls()):
+                return out
+            for url in md.urls():
+                try:
+                    if url.isLocalFile():
+                        p = url.toLocalFile()
+                        if p:
+                            out.append(p)
+                except Exception:
+                    continue
+        except Exception:
+            pass
+        return out
+
+    def _target_dir_from_pos(self, event) -> str:
+        # QDropEvent in Qt6: use position() -> QPointF
+        try:
+            pos = event.position().toPoint()
+        except Exception:
+            pos = event.pos()
+        idx = self.view.indexAt(pos)
+        if idx.isValid():
+            path = self.explorer.model.filePath(idx)
+            if os.path.isdir(path):
+                return path
+            return os.path.dirname(path)
+        # Fallback: explorer root directory
+        return self.explorer.directory
+
+    def eventFilter(self, obj, event):
+        et = event.type()
+
+        if et in (QEvent.DragEnter, QEvent.DragMove):
+            md = getattr(event, 'mimeData', lambda: None)()
+            if self._mime_has_local_urls(md):
+                try:
+                    event.setDropAction(Qt.CopyAction)
+                    event.acceptProposedAction()
+                except Exception:
+                    event.accept()
+                return True
+            return False
+
+        if et == QEvent.Drop:
+            md = getattr(event, 'mimeData', lambda: None)()
+            if not self._mime_has_local_urls(md):
+                return False
+
+            paths = self._local_paths_from_mime(md)
+            target_dir = self._target_dir_from_pos(event)
+            try:
+                self.explorer.window.controller.files.upload_paths(paths, target_dir)
+            except Exception as e:
+                try:
+                    self.explorer.window.core.debug.log(e)
+                except Exception:
+                    pass
+
+            try:
+                event.setDropAction(Qt.CopyAction)
+                event.acceptProposedAction()
+            except Exception:
+                event.accept()
+            # Swallow so the view does not try to handle the drop itself
+            return True
+
+        return False
+
+
 class FileExplorer(QWidget):
     def __init__(self, window, directory, index_data):
         """
@@ -138,6 +249,9 @@ class FileExplorer(QWidget):
             'db': QIcon(":/icons/db.svg"),
         }
 
+        # Drag & Drop upload support
+        self._dnd_handler = ExplorerDropHandler(self)
+
     def eventFilter(self, source, event):
         """
         Focus event filter

pygpt_net/ui/widget/lists/context.py

@@ -6,7 +6,7 @@
 # GitHub:  https://github.com/szczyglis-dev/py-gpt   #
 # MIT License                                        #
 # Created By  : Marcin Szczygliński                  #
-# Updated Date: 2025.09.15 22:00:00                  #
+# Updated Date: 2025.09.28 00:00:00                  #
 # ================================================== #
 
 import datetime
@@ -40,7 +40,7 @@ class ContextList(BaseList):
             'chat': QIcon(":/icons/chat.svg"),
             'copy': QIcon(":/icons/copy.svg"),
             'close': QIcon(":/icons/close.svg"),
-            'pin': QIcon(":/icons/pin.svg"),
+            'pin': QIcon(":/icons/pin3.svg"),
             'clock': QIcon(":/icons/clock.svg"),
             'db': QIcon(":/icons/db.svg"),
             'folder': QIcon(":/icons/folder_filled.svg"),
@@ -49,7 +49,8 @@ class ContextList(BaseList):
         self._color_icon_cache = {}
 
         # Use a custom delegate for labels/pinned/attachment indicators and group border indicator
-        self.setItemDelegate(ImportantItemDelegate(self, self._icons['attachment']))
+        # Pass both: attachment icon and pin icon (pin2.svg) for pinned indicator rendering
+        self.setItemDelegate(ImportantItemDelegate(self, self._icons['attachment'], self._icons['pin']))
 
         # Ensure context menu works as before
         self.setContextMenuPolicy(Qt.CustomContextMenu)
@@ -467,15 +468,17 @@ class ImportantItemDelegate(QtWidgets.QStyledItemDelegate):
     """
     Item delegate that paints:
     - Attachment icon on the right side (centered vertically),
-    - Pinned indicator (small circle) in the top-right corner (overlays if needed),
+    - Pinned indicator (pin.svg icon) in the top-right corner (overlays if needed),
     - Label color as a full-height vertical bar on the left for labeled items,
     - Group enclosure indicator for expanded groups:
         - thin vertical bar (default 2 px) on the left side of child rows area,
         - thin horizontal bar (default 2 px) at the bottom of the last child row.
     """
-    def __init__(self, parent=None, attachment_icon: QIcon = None):
+    def __init__(self, parent=None, attachment_icon: QIcon = None, pin_icon: QIcon = None):
         super().__init__(parent)
         self._attachment_icon = attachment_icon or QIcon(":/icons/attachment.svg")
+        # Use provided pin icon (transparent background) as pinned indicator
+        self._pin_icon = pin_icon or QIcon(":/icons/pin.svg")
 
         # Predefined label colors (status -> QColor)
         self._status_colors = {
@@ -490,8 +493,8 @@ class ImportantItemDelegate(QtWidgets.QStyledItemDelegate):
         }
 
         # Visual tuning constants
-        self._pin_pen = QtGui.QPen(QtCore.Qt.black, 0.5, QtCore.Qt.SolidLine)
-        self._pin_diameter = 4            # Small pinned circle diameter
+        self._pin_pen = QtGui.QPen(QtCore.Qt.black, 0.5, QtCore.Qt.SolidLine)  # kept for compatibility
+        self._pin_diameter = 4            # legacy circle diameter (not used anymore)
         self._pin_margin = 3              # Margin from top and right edges
         self._attach_spacing = 4          # Kept for potential future layout tweaks
         self._label_bar_width = 4         # Full-height label bar width (left side)
@@ -507,6 +510,10 @@ class ImportantItemDelegate(QtWidgets.QStyledItemDelegate):
         self._group_indicator_gap = 6  # gap between child content left and the vertical bar
         self._group_indicator_bottom_offset = 6
 
+        # Pinned icon sizing (kept deliberately small, similar to previous yellow dot)
+        # The actual painted size is min(max_size, availableHeightWithMargins)
+        self._pin_icon_max_size = 12  # px
+
         # Try to load customization from application config (safe if missing)
         self._init_group_indicator_from_config()
 
@@ -665,20 +672,23 @@ class ImportantItemDelegate(QtWidgets.QStyledItemDelegate):
                     )
                     self._attachment_icon.paint(painter, icon_rect, QtCore.Qt.AlignCenter)
 
-                # Pinned indicator (small circle) kept at a fixed top-right position.
-                # It does not shift left when the attachment is present; it overlays above it.
+                # Pinned indicator: small pin.svg painted at fixed top-right position.
+                # It overlays above any other right-side icons.
                 if is_important:
                     painter.setRenderHint(QtGui.QPainter.Antialiasing, True)
                     painter.setCompositionMode(QtGui.QPainter.CompositionMode_SourceOver)
-                    color = self.get_color_for_status(3)
 
-                    x = option.rect.x() + option.rect.width() - self._pin_margin - self._pin_diameter
-                    y = option.rect.y() + self._pin_margin
-                    pin_rect = QtCore.QRect(x, y, self._pin_diameter, self._pin_diameter)
+                    # Compute a compact size similar in footprint to previous circle,
+                    # but readable for vector icon; clamp to available height.
+                    available = max(8, option.rect.height() - 2 * self._pin_margin)
+                    pin_size = min(self._pin_icon_max_size, available)
 
-                    painter.setBrush(color)
-                    painter.setPen(self._pin_pen)
-                    painter.drawEllipse(pin_rect)
+                    x = option.rect.right() - self._pin_margin - pin_size
+                    y = option.rect.top() + self._pin_margin
+                    pin_rect = QtCore.QRect(x, y, pin_size, pin_size)
+
+                    # Paint the pin icon (transparent background)
+                    self._pin_icon.paint(painter, pin_rect, QtCore.Qt.AlignCenter)
 
                 # Label bar on the left with 3px vertical margins
                 if label > 0:

pygpt_net/ui/widget/option/combo.py

@@ -11,26 +11,118 @@
 
 from PySide6.QtCore import Qt
 from PySide6.QtWidgets import QHBoxLayout, QWidget, QComboBox
-from PySide6.QtGui import QFontMetrics
+from PySide6.QtGui import QFontMetrics, QStandardItem, QStandardItemModel  # keep existing imports, extend with items
 
 from pygpt_net.utils import trans
 
 class SeparatorComboBox(QComboBox):
-    """A combo box that supports adding separator items."""
+    """A combo box that supports adding separator items and prevents selecting them."""
+
+    def __init__(self, parent=None):
+        super().__init__(parent)
+        # Custom role used to mark separator rows without interfering with existing UserRole data
+        self._SEP_ROLE = Qt.UserRole + 1000
+        # Internal guard to avoid recursive index changes
+        self._block_guard = False
 
     def addSeparator(self, text):
         """
-        Adds a separator item to the combo box.
+        Adds a separator item to the combo box that cannot be selected.
+        This keeps separators visible but disabled/unselectable.
 
         :param text: The text to display for the separator.
         """
-        index = self.count()
-        self.addItem(text)
+        model = self.model()
+        if isinstance(model, QStandardItemModel):
+            item = QStandardItem(text)
+            # Disable and make the row unselectable
+            item.setFlags(item.flags() & ~Qt.ItemIsEnabled & ~Qt.ItemIsSelectable)
+            # Mark explicitly as separator using custom role
+            item.setData(True, self._SEP_ROLE)
+            model.appendRow(item)
+        else:
+            # Fallback: keep previous behavior and additionally tag item with custom role
+            index = self.count()
+            self.addItem(text)
+            try:
+                role = Qt.UserRole - 1
+                self.setItemData(index, 0, role)  # legacy approach used sometimes to indicate non-enabled
+            except Exception:
+                pass
+            # Tag as separator via custom role for later checks
+            self.setItemData(index, True, self._SEP_ROLE)
+
+    def is_separator(self, index: int) -> bool:
+        """Returns True if item at index is a separator."""
+        if index < 0 or index >= self.count():
+            return False
         try:
-            role = Qt.UserRole - 1
-            self.setItemData(index, 0, role)
-        except:
+            if self.itemData(index, self._SEP_ROLE):
+                return True
+        except Exception:
             pass
+        # Fallback: check flags (works with item models)
+        try:
+            idx = self.model().index(index, self.modelColumn(), self.rootModelIndex())
+            flags = self.model().flags(idx)
+            if not (flags & Qt.ItemIsEnabled) or not (flags & Qt.ItemIsSelectable):
+                return True
+        except Exception:
+            pass
+        return False
+
+    def first_valid_index(self) -> int:
+        """Returns the first non-separator index, or -1 if none."""
+        for i in range(self.count()):
+            if not self.is_separator(i):
+                return i
+        return -1
+
+    def _sanitize_index(self, index: int) -> int:
+        """Returns a corrected non-separator index, or -1 if none available."""
+        if index is None:
+            index = -1
+        if index < 0 or index >= self.count():
+            return self.first_valid_index()
+        if self.is_separator(index):
+            # Prefer the next valid item; if none, scan backwards; else -1
+            for i in range(index + 1, self.count()):
+                if not self.is_separator(i):
+                    return i
+            for i in range(index - 1, -1, -1):
+                if not self.is_separator(i):
+                    return i
+            return -1
+        return index
+
+    def ensure_valid_current(self) -> int:
+        """
+        Ensures the current index is not a separator.
+        Returns the final valid index (or -1) after correction.
+        """
+        current = super().currentIndex()
+        corrected = self._sanitize_index(current)
+        if corrected != current:
+            try:
+                self._block_guard = True
+                super().setCurrentIndex(corrected if corrected != -1 else -1)
+            finally:
+                self._block_guard = False
+        return corrected
+
+    def setCurrentIndex(self, index: int) -> None:
+        """
+        Prevent setting the current index to a separator from any caller.
+        """
+        if self._block_guard:
+            # When guarded, pass through without checks to avoid recursion
+            return super().setCurrentIndex(index)
+        corrected = self._sanitize_index(index)
+        try:
+            self._block_guard = True
+            super().setCurrentIndex(corrected if corrected != -1 else -1)
+        finally:
+            self._block_guard = False
 
 
 class NoScrollCombo(SeparatorComboBox):
@@ -116,7 +208,11 @@ class OptionCombo(QWidget):
                         else:
                             self.combo.addItem(value, key)
                 else:
-                    self.combo.addItem(item, item)
+                    # Support simple string keys including "separator::" entries
+                    if isinstance(item, str) and item.startswith("separator::"):
+                        self.combo.addSeparator(item.split("separator::", 1)[1])
+                    else:
+                        self.combo.addItem(item, item)
         elif type(self.keys) is dict:
             for key, value in self.keys.items():
                 if not isinstance(key, str):
@@ -126,6 +222,32 @@ class OptionCombo(QWidget):
                 else:
                     self.combo.addItem(value, key)
 
+        # Ensure a valid non-separator selection after population
+        self._apply_initial_selection()
+
+    def _apply_initial_selection(self):
+        """
+        Ensures that after building the list the combobox does not end up on a separator.
+        Prefers self.current_id if present; otherwise selects the first valid non-separator.
+        Signals are suppressed during this operation.
+        """
+        # lock on_change during initial selection
+        prev_locked = self.locked
+        self.locked = True
+        try:
+            index = -1
+            if self.current_id is not None and self.current_id != "":
+                index = self.combo.findData(self.current_id)
+            if index == -1:
+                index = self.combo.first_valid_index()
+            if index != -1:
+                self.combo.setCurrentIndex(index)
+            else:
+                # No valid items, clear selection
+                self.combo.setCurrentIndex(-1)
+        finally:
+            self.locked = prev_locked
+
     def set_value(self, value):
         """
         Set value
@@ -137,6 +259,9 @@ class OptionCombo(QWidget):
         index = self.combo.findData(value)
         if index != -1:
             self.combo.setCurrentIndex(index)
+        else:
+            # If requested value is not present, keep current selection but make sure it is valid.
+            self.combo.ensure_valid_current()
 
     def get_value(self):
         """
@@ -159,6 +284,8 @@ class OptionCombo(QWidget):
         self.option["keys"] = keys
         self.combo.clear()
         self.update()
+        # After rebuilding, guarantee a non-separator selection
+        self.combo.ensure_valid_current()
         if lock:
             self.locked = False
 
@@ -171,10 +298,21 @@ class OptionCombo(QWidget):
         """
         if self.locked:
             return
+
+        # If somehow a separator got focus, correct it immediately and do not propagate invalid IDs
+        if self.combo.is_separator(index):
+            self.locked = True
+            corrected = self.combo.ensure_valid_current()
+            self.locked = False
+            if corrected == -1:
+                # Nothing valid to select
+                self.current_id = None
+                return
+            index = corrected
+
         self.current_id = self.combo.itemData(index)
         self.window.controller.config.combo.on_update(self.parent_id, self.id, self.option, self.current_id)
 
     def fit_to_content(self):
         """Fit to content"""
-        self.combo.setSizeAdjustPolicy(QComboBox.AdjustToContents)
-
+        self.combo.setSizeAdjustPolicy(QComboBox.AdjustToContents)

pygpt_net/ui/widget/textarea/input.py

@@ -6,11 +6,12 @@
 # GitHub:  https://github.com/szczyglis-dev/py-gpt   #
 # MIT License                                        #
 # Created By  : Marcin Szczygliński                  #
-# Updated Date: 2025.09.26 12:00:00                  #
+# Updated Date: 2025.09.28 08:00:00                  #
 # ================================================== #
 
 from typing import Optional
 import math
+import os
 
 from PySide6.QtCore import Qt, QSize, QTimer, QEvent
 from PySide6.QtGui import QAction, QIcon, QImage
@@ -24,6 +25,8 @@ from PySide6.QtWidgets import (
 
 from pygpt_net.core.events import Event
 from pygpt_net.utils import trans
+from pygpt_net.core.attachments.clipboard import AttachmentDropHandler
+
 
 class ChatInput(QTextEdit):
 
@@ -127,6 +130,12 @@ class ChatInput(QTextEdit):
         # Paste/input safety limits
         self._paste_max_chars = 1000000000  # hard cap to prevent pathological pastes from freezing/crashing
 
+        # One-shot guard to avoid duplicate attachment processing on drops that also insert text.
+        self._skip_clipboard_on_next_insert = False
+
+        # Drag & Drop: add as attachments; do not insert file paths into text
+        self._dnd_handler = AttachmentDropHandler(self.window, self, policy=AttachmentDropHandler.INPUT_MIX)
+
     def _on_text_changed_tokens(self):
         """Schedule token count update with debounce."""
         self._tokens_timer.start()
@@ -157,27 +166,46 @@ class ChatInput(QTextEdit):
         except Exception:
             return False
 
+    def _mime_has_local_file_urls(self, source) -> bool:
+        """
+        Detects whether mime data contains any local file/directory URLs.
+        """
+        try:
+            if source and source.hasUrls():
+                for url in source.urls():
+                    if url.isLocalFile():
+                        return True
+        except Exception:
+            pass
+        return False
+
     def insertFromMimeData(self, source):
         """
         Insert from mime data
 
         :param source: source
         """
-        # Always process attachments first; never break input pipeline on errors.
-        try:
-            self.handle_clipboard(source)
-        except Exception as e:
+        has_local_files = self._mime_has_local_file_urls(source)
+
+        # Avoid double-processing when drop is allowed to fall through to default insertion.
+        should_skip = bool(getattr(self, "_skip_clipboard_on_next_insert", False))
+        if should_skip:
+            self._skip_clipboard_on_next_insert = False
+        else:
+            # Always process attachments first; never break input pipeline on errors.
             try:
-                self.window.core.debug.log(e)
-            except Exception:
-                pass
+                self.handle_clipboard(source)
+            except Exception as e:
+                try:
+                    self.window.core.debug.log(e)
+                except Exception:
+                    pass
 
-        # If an image is present, we treat it as attachment-only and do not insert textual representation.
+        # Do not insert textual representation for images nor local file URLs (including directories).
         try:
-            if source and source.hasImage():
+            if source and (source.hasImage() or has_local_files):
                 return
         except Exception:
-            # fallback to text extraction below
             pass
 
         # Insert only sanitized plain text (no HTML, no custom formats).
@@ -194,24 +222,27 @@ class ChatInput(QTextEdit):
     def _safe_text_from_mime(self, source) -> str:
         """
         Extracts plain text from QMimeData safely, normalizes and sanitizes it.
-        Falls back to URLs joined by space if textual content is not provided.
+        Falls back to URLs joined by space only for non-local URLs.
         """
         try:
             if source is None:
                 return ""
+            # Prefer real text if present
             if source.hasText():
                 return self._sanitize_text(source.text())
+            # Fallback: for non-local URLs we allow insertion as text (e.g., http/https)
             if source.hasUrls():
                 parts = []
                 for url in source.urls():
                     try:
                         if url.isLocalFile():
-                            parts.append(url.toLocalFile())
-                        else:
-                            parts.append(url.toString())
+                            # Skip local files/dirs textual fallback; they are handled as attachments
+                            continue
+                        parts.append(url.toString())
                     except Exception:
                         continue
-                return self._sanitize_text(" ".join([p for p in parts if p]))
+                if parts:
+                    return self._sanitize_text(" ".join([p for p in parts if p]))
         except Exception as e:
             try:
                 self.window.core.debug.log(e)
@@ -286,13 +317,36 @@ class ChatInput(QTextEdit):
                 image = source.imageData()
                 if isinstance(image, QImage):
                     self.window.controller.attachment.from_clipboard_image(image)
+                else:
+                    # Some platforms provide QPixmap; convert to QImage if possible
+                    try:
+                        img = image.toImage()
+                        if isinstance(img, QImage):
+                            self.window.controller.attachment.from_clipboard_image(img)
+                    except Exception:
+                        pass
             elif source.hasUrls():
                 urls = source.urls()
                 for url in urls:
                     try:
                         if url.isLocalFile():
                             local_path = url.toLocalFile()
-                            self.window.controller.attachment.from_clipboard_url(local_path)
+                            if not local_path:
+                                continue
+                            if os.path.isdir(local_path):
+                                # Recursively add all files from the dropped directory
+                                for root, _, files in os.walk(local_path):
+                                    for name in files:
+                                        fpath = os.path.join(root, name)
+                                        try:
+                                            self.window.controller.attachment.from_clipboard_url(fpath, all=True)
+                                        except Exception:
+                                            continue
+                            else:
+                                self.window.controller.attachment.from_clipboard_url(local_path, all=True)
+                        else:
+                            # Non-local URLs are handled as text (if any) by _safe_text_from_mime
+                            pass
                     except Exception:
                         # Ignore broken URL entries
                         continue

pygpt_net/ui/widget/textarea/web.py

@@ -531,7 +531,7 @@ class CustomWebEnginePage(QWebEnginePage):
         return super().acceptNavigationRequest(url, _type, isMainFrame)
 
     def javaScriptConsoleMessage(self, level, message, line_number, source_id):
-        #  print("[JS CONSOLE] Line", line_number, ":", message)
+        print("[JS CONSOLE] Line", line_number, ":", message)
         self.signals.js_message.emit(line_number, message, source_id)  # handled in debug controller
 
     def cleanup(self):