pygpt-net 2.6.44__py3-none-any.whl → 2.6.46__py3-none-any.whl

pygpt_net/core/render/web/body.py

@@ -6,14 +6,14 @@
 # GitHub:  https://github.com/szczyglis-dev/py-gpt   #
 # MIT License                                        #
 # Created By  : Marcin Szczygliński                  #
-# Updated Date: 2025.09.12 23:00:00                  #
+# Updated Date: 2025.09.13 06:05:00                  #
 # ================================================== #
 
 import os
 from json import dumps as _json_dumps
 from random import shuffle as _shuffle
 
-from typing import Optional, List, Dict
+from typing import Optional, List, Dict, Tuple
 
 from pygpt_net.core.text.utils import elide_filename
 from pygpt_net.core.events import Event
@@ -208,33 +208,34 @@ class Body:
         """
 
     def __init__(self, window=None):
+        """
+        Initialize Body with reference to main window and syntax highlighter.
+
+        :param window: Window reference
+        """
         self.window = window
         self.highlight = SyntaxHighlight(window)
         self._tip_keys = tuple(f"output.tips.{i}" for i in range(1, self.NUM_TIPS + 1))
         self._syntax_dark = (
-            "dracula",
-            "fruity",
-            "github-dark",
-            "gruvbox-dark",
-            "inkpot",
-            "material",
-            "monokai",
-            "native",
-            "nord",
-            "nord-darker",
-            "one-dark",
-            "paraiso-dark",
-            "rrt",
-            "solarized-dark",
-            "stata-dark",
-            "vim",
-            "zenburn",
+            "dracula", "fruity", "github-dark", "gruvbox-dark", "inkpot", "material",
+            "monokai", "native", "nord", "nord-darker", "one-dark", "paraiso-dark",
+            "rrt", "solarized-dark", "stata-dark", "vim", "zenburn",
         )
 
     def is_timestamp_enabled(self) -> bool:
+        """
+        Check if timestamp display is enabled in config.
+
+        :return: True if enabled, False otherwise.
+        """
         return self.window.core.config.get('output_timestamp')
 
     def prepare_styles(self) -> str:
+        """
+        Prepare combined CSS styles for the web view.
+
+        :return: Combined CSS string.
+        """
         cfg = self.window.core.config
         fonts_path = os.path.join(cfg.get_app_path(), "data", "fonts").replace("\\", "/")
         syntax_style = self.window.core.config.get("render.code_syntax") or "default"
@@ -250,12 +251,25 @@ class Body:
         return "\n".join(parts)
 
     def prepare_action_icons(self, ctx: CtxItem) -> str:
+        """
+        Prepare HTML for message-level action icons.
+
+        :param ctx: CtxItem
+        :return: HTML string or empty if no icons.
+        """
         icons_html = "".join(self.get_action_icons(ctx, all=True))
         if icons_html:
             return f'<div class="action-icons" data-id="{ctx.id}">{icons_html}</div>'
         return ""
 
     def get_action_icons(self, ctx: CtxItem, all: bool = False) -> List[str]:
+        """
+        Return HTML snippets for message-level action icons.
+
+        :param ctx: CtxItem
+        :param all: If True, return all icons; otherwise, return only available ones.
+        :return: List of HTML strings for icons.
+        """
         icons: List[str] = []
         if ctx.output:
             cid = ctx.id
@@ -275,12 +289,71 @@ class Body:
                     f'<a href="extra-join:{cid}" class="action-icon edit-icon" data-id="{cid}" role="button"><span class="cmd">{self.get_icon("playlist_add", t("ctx.extra.join"), ctx)}</span></a>')
         return icons
 
-    def get_icon(self, icon: str, title: Optional[str] = None, item: Optional[CtxItem] = None) -> str:
+    def get_action_icon_data(self, ctx: CtxItem) -> List[Dict]:
+        """
+        Return raw data for message-level action icons (href/title/icon path).
+        This allows JS templates to render actions without Python-side HTML.
+
+        1. extra-audio-read
+        2. extra-copy
+        3. extra-replay
+        4. extra-edit
+        5. extra-delete
+        6. extra-join (if not the first item)
+        7. (future actions...)
+
+        :param ctx: CtxItem
+        :return: List of action dicts
+        """
+        items: List[Dict] = []
+        if ctx.output:
+            cid = ctx.id
+            t = trans
+            app_path = self.window.core.config.get_app_path()
+            def icon_path(name: str) -> str:
+                return os.path.join(app_path, "data", "icons", f"{name}.svg").replace("\\", "/")
+
+            items.append({"href": f"extra-audio-read:{cid}", "title": t("ctx.extra.audio"), "icon": f"file://{icon_path('volume')}", "id": cid})
+            items.append({"href": f"extra-copy:{cid}", "title": t("ctx.extra.copy"), "icon": f"file://{icon_path('copy')}", "id": cid})
+            items.append({"href": f"extra-replay:{cid}", "title": t("ctx.extra.reply"), "icon": f"file://{icon_path('reload')}", "id": cid})
+            items.append({"href": f"extra-edit:{cid}", "title": t("ctx.extra.edit"), "icon": f"file://{icon_path('edit')}", "id": cid})
+            items.append({"href": f"extra-delete:{cid}", "title": t("ctx.extra.delete"), "icon": f"file://{icon_path('delete')}", "id": cid})
+            if not self.window.core.ctx.is_first_item(cid):
+                items.append({"href": f"extra-join:{cid}", "title": t("ctx.extra.join"), "icon": f"file://{icon_path('playlist_add')}", "id": cid})
+        return items
+
+    def get_icon(
+            self,
+            icon: str,
+            title: Optional[str] = None,
+            item: Optional[CtxItem] = None
+    ) -> str:
+        """
+        Get HTML for an icon image with title and optional data-id.
+
+        :param icon: Icon name (without extension)
+        :param title: Icon title (tooltip)
+        :param item: Optional CtxItem to get data-id from
+        :return: HTML string
+        """
         app_path = self.window.core.config.get_app_path()
         icon_path = os.path.join(app_path, "data", "icons", f"{icon}.svg")
         return f'<img src="file://{icon_path}" class="action-img" title="{title}" alt="{title}" data-id="{item.id}">'
 
-    def get_image_html(self, url: str, num: Optional[int] = None, num_all: Optional[int] = None) -> str:
+    def get_image_html(
+            self,
+            url: str,
+            num: Optional[int] = None,
+            num_all: Optional[int] = None
+    ) -> str:
+        """
+        Get HTML for an image or video link with optional numbering.
+
+        :param url: Image or video URL
+        :param num: Optional index (1-based)
+        :param num_all: Optional total number of images/videos
+        :return: HTML string
+        """
         url, path = self.window.core.filesystem.extract_local_url(url)
         basename = os.path.basename(path)
         ext = os.path.splitext(basename)[1].lower()
@@ -301,7 +374,20 @@ class Body:
             '''
         return f'<div class="extra-src-img-box" title="{url}"><div class="img-outer"><div class="img-wrapper"><a href="{url}"><img src="{path}" class="image"></a></div><a href="{url}" class="title">{elide_filename(basename)}</a></div></div><br/>'
 
-    def get_url_html(self, url: str, num: Optional[int] = None, num_all: Optional[int] = None) -> str:
+    def get_url_html(
+            self,
+            url: str,
+            num: Optional[int] = None,
+            num_all: Optional[int] = None
+    ) -> str:
+        """
+        Get HTML for a URL link with icon and optional numbering.
+
+        :param url: URL string
+        :param num: Optional index (1-based)
+        :param num_all: Optional total number of URLs
+        :return: HTML string
+        """
         app_path = self.window.core.config.get_app_path()
         icon_path = os.path.join(app_path, "data", "icons", "url.svg").replace("\\", "/")
         icon = f'<img src="file://{icon_path}" class="extra-src-icon">'
@@ -309,6 +395,12 @@ class Body:
         return f'{icon}<a href="{url}" title="{url}">{url}</a> <small>{num_str}</small>'
 
     def get_docs_html(self, docs: List[Dict]) -> str:
+        """
+        Get HTML for document references.
+
+        :param docs: List of document dicts {uuid: {meta_dict}}
+        :return: HTML string or empty if no docs.
+        """
         html_parts: List[str] = []
         src_parts: List[str] = []
         num = 1
@@ -338,7 +430,20 @@ class Body:
 
         return "".join(html_parts)
 
-    def get_file_html(self, url: str, num: Optional[int] = None, num_all: Optional[int] = None) -> str:
+    def get_file_html(
+            self,
+            url: str,
+            num: Optional[int] = None,
+            num_all: Optional[int] = None
+    ) -> str:
+        """
+        Get HTML for a file link with icon and optional numbering.
+
+        :param url: File URL
+        :param num: Optional file index (1-based)
+        :param num_all: Optional total number of files
+        :return: HTML string
+        """
         app_path = self.window.core.config.get_app_path()
         icon_path = os.path.join(app_path, "data", "icons", "attachments.svg").replace("\\", "/")
         icon = f'<img src="file://{icon_path}" class="extra-src-icon">'
@@ -347,6 +452,12 @@ class Body:
         return f'{icon} <b>{num_str}</b> <a href="{url}">{path}</a>'
 
     def prepare_tool_extra(self, ctx: CtxItem) -> str:
+        """
+        Prepare extra HTML for tool/plugin output.
+
+        :param ctx: CtxItem
+        :return: HTML string or empty if no extra.
+        """
         extra = ctx.extra
         if not extra:
             return ""
@@ -384,6 +495,11 @@ class Body:
         return "".join(parts)
 
     def get_all_tips(self) -> str:
+        """
+        Get all tips as a JSON array string.
+
+        :return: JSON array string of tips or "[]" if disabled.
+        """
         if not self.window.core.config.get("layout.tooltips", False):
             return "[]"
 
@@ -396,7 +512,149 @@ class Body:
         _shuffle(tips)
         return _json_dumps(tips)
 
+    def _extract_local_url(self, url: str) -> Tuple[str, str]:
+        """
+        Extract local URL and path using filesystem helper.
+
+        On failure, return (url, url).
+
+        :param url: URL to extract.
+        :return: Tuple of (url, path).
+        """
+        try:
+            return self.window.core.filesystem.extract_local_url(url)
+        except Exception:
+            return url, url
+
+    def build_extras_dicts(self, ctx: CtxItem, pid: int) -> Tuple[dict, dict, dict, dict]:
+        """
+        Build images/files/urls raw dicts to be rendered by JS templates.
+
+        1-based indexing for keys as strings: "1", "2", ...
+        0-based indexing is inconvenient in JS templates.
+        1-based indexing allows to show [n/m] in titles.
+
+        1. images_dict = { "1": {url, path, basename, ext, is_video, webm_path}, ... }
+        2. files_dict = { "1": {url, path}, ... }
+        3. urls_dict = { "1": {url}, ... }
+        4. actions_dict = { "actions": [ {href, title, icon, id}, ... ] }  # message-level actions
+
+        :param ctx: CtxItem
+        :param pid: Process ID
+        :return: Tuple of (images_dict, files_dict, urls_dict, actions_dict)
+        """
+        images = {}
+        files = {}
+        urls = {}
+
+        # images
+        if ctx.images:
+            video_exts = (".mp4", ".webm", ".ogg", ".mov", ".avi", ".mkv")
+            n = 1
+            for img in ctx.images:
+                if img is None:
+                    continue
+                try:
+                    url, path = self._extract_local_url(img)
+                    basename = os.path.basename(path)
+                    ext = os.path.splitext(basename)[1].lower()
+                    is_video = ext in video_exts
+                    webm_path = ""
+                    if is_video and ext != ".webm":
+                        wp = os.path.splitext(path)[0] + ".webm"
+                        if os.path.exists(wp):
+                            webm_path = wp
+                    images[str(n)] = {
+                        "url": url,
+                        "path": path,
+                        "basename": basename,
+                        "ext": ext,
+                        "is_video": is_video,
+                        "webm_path": webm_path,
+                    }
+                    n += 1
+                except Exception:
+                    pass
+
+        # files
+        if ctx.files:
+            n = 1
+            for f in ctx.files:
+                try:
+                    url, path = self._extract_local_url(f)
+                    files[str(n)] = {
+                        "url": url,
+                        "path": path,
+                    }
+                    n += 1
+                except Exception:
+                    pass
+
+        # urls
+        if ctx.urls:
+            n = 1
+            for u in ctx.urls:
+                try:
+                    urls[str(n)] = {"url": u}
+                    n += 1
+                except Exception:
+                    pass
+
+        # actions (message-level) – raw data for icons (href/title/icon)
+        actions = self.get_action_icon_data(ctx)
+
+        return images, files, urls, {"actions": actions}
+
+    def normalize_docs(self, doc_ids) -> list[dict]:
+        """
+        Normalize ctx.doc_ids into a list of {"uuid": str, "meta": dict}.
+        Accepts original shape: List[Dict[uuid -> meta_dict]] or already normalized.
+
+        Returns empty list on failure.
+
+        Example input:
+        [
+            {"123e4567-e89b-12d3-a456-426614174000": {"title": "Document 1", "source": "file1.txt"}},
+            {"123e4567-e89b-12d3-a456-426614174001": {"title": "Document 2", "source": "file2.txt"}}
+        ]
+        Example output:
+        [
+            {"uuid": "123e4567-e89b-12d3-a456-426614174000", "meta": {"title": "Document 1", "source": "file1.txt"}},
+            {"uuid": "123e4567-e89b-12d3-a456-426614174001", "meta": {"title": "Document 2", "source": "file2.txt"}}
+        ]
+
+        :param doc_ids: List of document IDs in original or normalized shape.
+        :return: List of normalized document dicts.
+        """
+        normalized = []
+        try:
+            for item in doc_ids or []:
+                if isinstance(item, dict):
+                    # Already normalized?
+                    if 'uuid' in item and 'meta' in item and isinstance(item['meta'], dict):
+                        normalized.append({
+                            "uuid": str(item['uuid']),
+                            "meta": dict(item['meta']),
+                        })
+                        continue
+                    # Original shape: { uuid: { ... } }
+                    keys = list(item.keys())
+                    if len(keys) == 1:
+                        uuid = str(keys[0])
+                        meta = item[uuid]
+                        if isinstance(meta, dict):
+                            normalized.append({"uuid": uuid, "meta": dict(meta)})
+        except Exception:
+            pass
+        return normalized
+
     def get_html(self, pid: int) -> str:
+        """
+        Build full HTML for the web view body.
+
+        :param pid: Process ID to embed in JS.
+        :return: Full HTML string.
+        """
         cfg_get = self.window.core.config.get
         style = cfg_get("theme.style", "blocks")
         classes = ["theme-" + style]
@@ -419,6 +677,10 @@ class Body:
         run_path = os.path.join(app_path, "data", "icons", "play.svg").replace("\\", "/")
         menu_path = os.path.join(app_path, "data", "icons", "menu.svg").replace("\\", "/")
 
+        url_path = os.path.join(app_path, "data", "icons", "url.svg").replace("\\", "/")
+        attach_path = os.path.join(app_path, "data", "icons", "attachments.svg").replace("\\", "/")
+        db_path = os.path.join(app_path, "data", "icons", "db.svg").replace("\\", "/")
+
         icons_js = (
             f'window.ICON_EXPAND="file://{expand_path}";'
             f'window.ICON_COLLAPSE="file://{collapse_path}";'
@@ -426,6 +688,9 @@ class Body:
             f'window.ICON_CODE_PREVIEW="file://{preview_path}";'
             f'window.ICON_CODE_RUN="file://{run_path}";'
             f'window.ICON_CODE_MENU="file://{menu_path}";'
+            f'window.ICON_URL="file://{url_path}";'
+            f'window.ICON_ATTACHMENTS="file://{attach_path}";'
+            f'window.ICON_DB="file://{db_path}";'
         )
 
         t_copy = trans('ctx.extra.copy_code')
@@ -434,6 +699,7 @@ class Body:
         t_copied = trans('ctx.extra.copied')
         t_preview = trans('ctx.extra.preview')
         t_run = trans('ctx.extra.run')
+        t_doc_prefix = trans("chat.prefix.doc")
 
         locales_js = (
             f'window.LOCALE_COPY={_json_dumps(t_copy)};'
@@ -442,6 +708,7 @@ class Body:
             f'window.LOCALE_RUN={_json_dumps(t_run)};'
             f'window.LOCALE_COLLAPSE={_json_dumps(t_collapse)};'
             f'window.LOCALE_EXPAND={_json_dumps(t_expand)};'
+            f'window.LOCALE_DOC_PREFIX={_json_dumps(t_doc_prefix)};'
         )
 
         syntax_style = cfg_get("render.code_syntax") or "default"

pygpt_net/core/render/web/helpers.py

@@ -24,6 +24,7 @@ class Helpers:
     #_RE_TOOL_TAG = re.compile(r"<tool>(.*?)</tool>", re.DOTALL)
     _RE_TOOL_TAG = re.compile(r"<tool>(.*?)</tool>", re.DOTALL)
     _RE_THINK_TAG = re.compile(r"<think>(.*?)</think>", re.DOTALL)
+    _RE_EXECUTE_TAG = re.compile(r"<execute>(.*?)</execute>", re.DOTALL)
     #_RE_MATH_PARENS = re.compile(r"\\\((.*?)\\\)", re.DOTALL)
 
     def __init__(self, window=None):
@@ -80,6 +81,15 @@ class Helpers:
         g = m.group(1).replace("\n", "<br>")
         return f'[!think]{html.escape(g)}[/!think]'
 
+    def _repl_execute(self, m: re.Match) -> str:
+        """
+        Replace execute tags with HTML paragraph
+
+        :param m: regex match object
+        :return: formatted HTML string
+        """
+        return f'[!exec]{html.escape(m.group(1))}[/!exec]'
+
     def _repl_math_fix(self, m: re.Match) -> str:
         """
         Fix math formula by replacing &lt; and &gt; with < and > inside \\( ... \\)
@@ -127,6 +137,21 @@ class Helpers:
 
         return s
 
+    def replace_execute_tags(self, text: str) -> str:
+        """
+        Replace execute tags
+
+        :param text:
+        :return: replaced text
+        """
+        s = text
+
+        # --- execute tags ---
+        if "<execute>" in s and "</execute>" in s:
+            s = self._RE_EXECUTE_TAG.sub(self._repl_execute, s)
+
+        return s
+
     def pre_format_text(self, text: str) -> str:
         """
         Pre-format text
@@ -151,6 +176,7 @@ class Helpers:
         # replace tags with markdown placeholders (will be converted to HTML in JS runtime)
         s = self.replace_code_tags(text.strip())
         s = self.replace_think_tags(s)
+        s = self.replace_execute_tags(s)
 
         # replace workdir token
         if "%workdir%" in s: