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

pygpt_net/core/render/web/renderer.py

@@ -6,19 +6,21 @@
 # GitHub:  https://github.com/szczyglis-dev/py-gpt   #
 # MIT License                                        #
 # Created By  : Marcin Szczygliński                  #
-# Updated Date: 2024.11.26 04:00:00                  #
+# Updated Date: 2024.12.14 08:00:00                  #
 # ================================================== #
 
 import json
 import os
 import re
 from datetime import datetime
+from typing import Optional, List
 
 from pygpt_net.core.render.base import BaseRenderer
 from pygpt_net.core.text.utils import has_unclosed_code_tag
 from pygpt_net.item.ctx import CtxItem, CtxMeta
 from pygpt_net.ui.widget.textarea.input import ChatInput
 from pygpt_net.utils import trans
+from pygpt_net.core.tabs.tab import Tab
 
 from .body import Body
 from .helpers import Helpers
@@ -59,16 +61,21 @@ class Renderer(BaseRenderer):
         node.set_meta(meta)
         self.reset(meta)
 
-    def on_page_loaded(self, meta: CtxMeta = None):
+    def on_page_loaded(
+            self,
+            meta: Optional[CtxMeta] = None,
+            tab: Optional[Tab] = None
+    ):
         """
         On page loaded callback from WebEngine widget
 
         :param meta: context meta
+        :param tab: Tab
         """
         if meta is None:
             return
-        pid = self.get_or_create_pid(meta)
-        if pid is None:
+        pid = tab.pid
+        if pid is None or pid not in self.pids:
             return
         self.pids[pid].loaded = True
         if self.pids[pid].html != "" and not self.pids[pid].use_buffer:
@@ -98,7 +105,11 @@ class Renderer(BaseRenderer):
                 self.pid_create(pid, meta)
             return pid
 
-    def pid_create(self, pid, meta: CtxMeta):
+    def pid_create(
+            self,
+            pid: Optional[int],
+            meta: CtxMeta
+    ):
         """
         Create PID data
         
@@ -108,7 +119,7 @@ class Renderer(BaseRenderer):
         if pid is not None:
             self.pids[pid] = PidData(pid, meta)
 
-    def init(self, pid):
+    def init(self, pid: Optional[int]):
         """
         Initialize renderer
 
@@ -120,7 +131,12 @@ class Renderer(BaseRenderer):
         else:
             self.clear_chunks(pid)
 
-    def begin(self, meta: CtxMeta, ctx: CtxItem, stream: bool = False):
+    def begin(
+            self,
+            meta: CtxMeta,
+            ctx: CtxItem,
+            stream: bool = False
+    ):
         """
         Render begin
 
@@ -133,7 +149,12 @@ class Renderer(BaseRenderer):
         self.reset_names(meta)
         self.tool_output_end()  # reset tools
 
-    def end(self, meta: CtxMeta, ctx: CtxItem, stream: bool = False):
+    def end(
+            self,
+            meta: CtxMeta,
+            ctx: CtxItem,
+            stream: bool = False
+    ):
         """
         Render end
 
@@ -148,7 +169,12 @@ class Renderer(BaseRenderer):
             self.append_context_item(meta, self.pids[pid].item)
             self.pids[pid].item = None
 
-    def end_extra(self, meta: CtxMeta, ctx: CtxItem, stream: bool = False):
+    def end_extra(
+            self,
+            meta: CtxMeta,
+            ctx: CtxItem,
+            stream: bool = False
+    ):
         """
         Render end extra
         
@@ -158,16 +184,24 @@ class Renderer(BaseRenderer):
         """
         self.to_end(ctx)
 
-    def stream_begin(self, meta: CtxMeta, ctx: CtxItem):
+    def stream_begin(
+            self,
+            meta: CtxMeta,
+            ctx: CtxItem
+    ):
         """
         Render stream begin
         
         :param meta: context meta
         :param ctx: context item
         """
-        pass  # do nothing
+        pass
 
-    def stream_end(self, meta: CtxMeta, ctx: CtxItem):
+    def stream_end(
+            self,
+            meta: CtxMeta,
+            ctx: CtxItem
+    ):
         """
         Render stream end
         
@@ -180,7 +214,12 @@ class Renderer(BaseRenderer):
                 self.append_context_item(meta, self.pids[pid].item)
                 self.pids[pid].item = None
 
-    def append_context(self, meta: CtxMeta, items: list, clear: bool = True):
+    def append_context(
+            self,
+            meta: CtxMeta,
+            items: List[CtxItem],
+            clear: bool = True
+    ):
         """
         Append all context to output
         
@@ -201,22 +240,37 @@ class Renderer(BaseRenderer):
 
         self.pids[pid].use_buffer = True
         self.pids[pid].html = ""
+        prev_ctx = None
         for item in items:
             self.update_names(meta, item)
             item.idx = i
             if i == 0:
                 item.first = True
             next_item = items[i + 1] if i + 1 < len(items) else None   # append next item if exists
-            self.append_context_item(meta, item, next_item)  # to html buffer
+            self.append_context_item(
+                meta,
+                item,
+                prev_ctx=prev_ctx,
+                next_ctx=next_item
+            )  # to html buffer
+            prev_ctx = item
             i += 1
         self.pids[pid].use_buffer = False
 
         # flush
         if self.pids[pid].html != "":
-            self.append(pid, self.pids[pid].html,
-                        flush=True)  # flush buffer if page loaded, otherwise it will be flushed on page load
-
-    def append_input(self, meta: CtxMeta, ctx: CtxItem, flush: bool = True, append: bool = False):
+            self.append(
+                pid,
+                self.pids[pid].html,
+                flush=True
+            )  # flush buffer if page loaded, otherwise it will be flushed on page load
+
+    def append_input(
+            self, meta: CtxMeta,
+            ctx: CtxItem,
+            flush: bool = True,
+            append: bool = False
+    ):
         """
         Append text input to output
 
@@ -248,29 +302,49 @@ class Renderer(BaseRenderer):
                 text = re.sub(r'^user: ', '> ', ctx.input)
 
         if flush:  # to chunk buffer
-            content = self.prepare_node(meta, ctx, text.strip(), self.NODE_INPUT)
             if self.is_stream() and not append:
+                content = self.prepare_node(meta, ctx, text.strip(), self.NODE_INPUT)
                 self.append_chunk_input(meta, ctx, content, False)
-            else:
-                self.append_node(meta, ctx, text.strip(), self.NODE_INPUT)
-        else:
-            self.append_node(meta, ctx, text.strip(), self.NODE_INPUT)
+                return
+
+        self.append_node(meta, ctx, text.strip(), self.NODE_INPUT)
 
-    def append_output(self, meta: CtxMeta, ctx: CtxItem, flush: bool = True, next_ctx: CtxItem = None):
+    def append_output(
+            self,
+            meta: CtxMeta,
+            ctx: CtxItem,
+            flush: bool = True,
+            prev_ctx: Optional[CtxItem] = None,
+            next_ctx: Optional[CtxItem] = None
+    ):
         """
         Append text output to output
         
         :param meta: context meta
         :param ctx: context item
         :param flush: flush HTML
+        :param prev_ctx: previous context
         :param next_ctx: next context
         """
         self.tool_output_end()  # reset tools
         if ctx.output is None or ctx.output == "":
             return
-        self.append_node(meta, ctx, ctx.output.strip(), self.NODE_OUTPUT, next_ctx)
+        self.append_node(
+            meta=meta,
+            ctx=ctx,
+            html=ctx.output.strip(),
+            type=self.NODE_OUTPUT,
+            prev_ctx=prev_ctx,
+            next_ctx=next_ctx
+        )
 
-    def append_chunk(self, meta: CtxMeta, ctx: CtxItem, text_chunk: str, begin: bool = False):
+    def append_chunk(
+            self,
+            meta: CtxMeta,
+            ctx: CtxItem,
+            text_chunk: str,
+            begin: bool = False
+    ):
         """
         Append output chunk to output
         
@@ -289,6 +363,12 @@ class Renderer(BaseRenderer):
         self.update_names(meta, ctx)
         raw_chunk = str(text_chunk)
         if begin:
+            # debug
+            debug = ""
+            if self.is_debug():
+                debug = self.append_debug(ctx, pid, "stream")
+            if debug:
+                raw_chunk = debug + raw_chunk
             self.pids[pid].buffer = ""  # reset buffer
             self.pids[pid].is_cmd = False  # reset command flag
             self.clear_chunks_output(pid)
@@ -316,7 +396,13 @@ class Renderer(BaseRenderer):
         except Exception as e:
             pass
 
-    def append_chunk_input(self, meta: CtxMeta, ctx: CtxItem, text_chunk: str, begin: bool = False):
+    def append_chunk_input(
+            self,
+            meta: CtxMeta,
+            ctx: CtxItem,
+            text_chunk: str,
+            begin: bool = False
+    ):
         """
         Append output chunk to output
 
@@ -339,7 +425,15 @@ class Renderer(BaseRenderer):
         except Exception as e:
             pass
 
-    def append_node(self, meta: CtxMeta, ctx: CtxItem, html: str, type: int = 1, next_ctx: CtxItem = None):
+    def append_node(
+            self,
+            meta: CtxMeta,
+            ctx: CtxItem,
+            html: str,
+            type: int = 1,
+            prev_ctx: Optional[CtxItem] = None,
+            next_ctx: Optional[CtxItem] = None
+    ):
         """
         Append and format raw text to output
 
@@ -347,15 +441,31 @@ class Renderer(BaseRenderer):
         :param html: text to append
         :param type: type of message
         :param ctx: CtxItem instance
+        :param prev_ctx: previous context item
         :param next_ctx: next context item
         """
         if ctx.hidden:
             return
 
         pid = self.get_or_create_pid(meta)
-        self.append(pid, self.prepare_node(meta, ctx, html, type, next_ctx))
+        self.append(
+            pid,
+            self.prepare_node(
+                meta=meta,
+                ctx=ctx,
+                html=html,
+                type=type,
+                prev_ctx=prev_ctx,
+                next_ctx=next_ctx
+            )
+        )
 
-    def append(self, pid, html: str, flush: bool = False):
+    def append(
+            self,
+            pid,
+            html: str,
+            flush: bool = False
+    ):
         """
         Append text to output
         
@@ -371,18 +481,41 @@ class Renderer(BaseRenderer):
             if not flush:
                 self.pids[pid].html += html  # to buffer
 
-    def append_context_item(self, meta: CtxMeta, ctx: CtxItem, next_ctx: CtxItem = None):
+    def append_context_item(
+            self,
+            meta: CtxMeta,
+            ctx: CtxItem,
+            prev_ctx: Optional[CtxItem] = None,
+            next_ctx: Optional[CtxItem] = None
+    ):
         """
         Append context item to output
 
         :param meta: context meta
         :param ctx: context item
+        :param prev_ctx: previous context item
         :param next_ctx: next context item
         """
-        self.append_input(meta, ctx, flush=False)
-        self.append_output(meta, ctx, flush=False, next_ctx=next_ctx)  # + extra
+        self.append_input(
+            meta,
+            ctx,
+            flush=False
+        )
+        self.append_output(
+            meta,
+            ctx,
+            flush=False,
+            prev_ctx=prev_ctx,
+            next_ctx=next_ctx
+        )  # + extra
 
-    def append_extra(self, meta: CtxMeta, ctx: CtxItem, footer: bool = False, render: bool = True) -> str:
+    def append_extra(
+            self,
+            meta: CtxMeta,
+            ctx: CtxItem,
+            footer: bool = False,
+            render: bool = True
+    ) -> str:
         """
         Append extra data (images, files, etc.) to output
         
@@ -405,8 +538,8 @@ class Renderer(BaseRenderer):
                 if image is None:
                     continue
                 # don't append if it is an external url
-                if image.startswith("http"):
-                    continue
+                # if image.startswith("http"):
+                    # continue
                 if image in appended or image in self.pids[pid].images_appended:
                     continue
                 try:
@@ -473,7 +606,12 @@ class Renderer(BaseRenderer):
 
         return html
 
-    def append_timestamp(self, ctx: CtxItem, text: str, type: int = None) -> str:
+    def append_timestamp(
+            self,
+            ctx: CtxItem,
+            text: str,
+            type: Optional[int] = None
+    ) -> str:
         """
         Append timestamp to text
 
@@ -494,7 +632,10 @@ class Renderer(BaseRenderer):
                 text = '<span class="ts">{}: </span>{}'.format(hour, text)
         return text
 
-    def reset(self, meta: CtxMeta = None):
+    def reset(
+            self,
+            meta: Optional[CtxMeta] = None
+    ):
         """
         Reset
 
@@ -510,7 +651,7 @@ class Renderer(BaseRenderer):
                 pid = self.get_or_create_pid(meta)
                 self.reset_by_pid(pid)
 
-    def reset_by_pid(self, pid):
+    def reset_by_pid(self, pid: Optional[int]):
         """
         Reset by PID
 
@@ -531,7 +672,10 @@ class Renderer(BaseRenderer):
         """Clear input"""
         self.get_input_node().clear()
 
-    def clear_output(self, meta: CtxMeta = None):
+    def clear_output(
+            self,
+            meta: Optional[CtxMeta] = None
+    ):
         """
         Clear output
 
@@ -550,12 +694,17 @@ class Renderer(BaseRenderer):
         self.clear_chunks_input(pid)
         self.clear_chunks_output(pid)
 
-    def clear_chunks_input(self, pid):
+    def clear_chunks_input(
+            self,
+            pid: Optional[int]
+    ):
         """
         Clear chunks from input
 
         :pid: context PID
         """
+        if pid is None:
+            return
         if not self.pids[pid].loaded:
             js = "var element = document.getElementById('_append_input_');"
             js += "if (element) { element.innerHTML = ''; }"
@@ -566,7 +715,10 @@ class Renderer(BaseRenderer):
         except Exception as e:
             pass
 
-    def clear_chunks_output(self, pid):
+    def clear_chunks_output(
+            self,
+            pid: Optional[int]
+    ):
         """
         Clear chunks from output
 
@@ -582,7 +734,10 @@ class Renderer(BaseRenderer):
         except Exception as e:
             pass
 
-    def clear_nodes(self, pid):
+    def clear_nodes(
+            self,
+            pid: Optional[int]
+    ):
         """
         Clear nodes from output
 
@@ -598,7 +753,15 @@ class Renderer(BaseRenderer):
         except Exception as e:
             pass
 
-    def prepare_node(self, meta: CtxMeta, ctx: CtxItem, html: str, type: int = 1, next_ctx: CtxItem = None) -> str:
+    def prepare_node(
+            self,
+            meta: CtxMeta,
+            ctx: CtxItem,
+            html: str,
+            type: int = 1,
+            prev_ctx: Optional[CtxItem] = None,
+            next_ctx: Optional[CtxItem] = None
+    ) -> str:
         """
         Prepare node HTML
         
@@ -606,20 +769,35 @@ class Renderer(BaseRenderer):
         :param ctx: CtxItem instance
         :param html: html text
         :param type: type of message
+        :param prev_ctx: previous context item
         :param next_ctx: next context item
         :return: prepared HTML
         """
         pid = self.get_or_create_pid(meta)
         if type == self.NODE_OUTPUT:
-            return self.prepare_node_output(meta, ctx, html, next_ctx)
+            return self.prepare_node_output(
+                meta=meta,
+                ctx=ctx,
+                html=html,
+                prev_ctx=prev_ctx,
+                next_ctx=next_ctx
+            )
         elif type == self.NODE_INPUT:
-            return self.prepare_node_input(pid, ctx, html)
+            return self.prepare_node_input(
+                pid=pid,
+                ctx=ctx,
+                html=html,
+                prev_ctx=prev_ctx,
+                next_ctx=next_ctx
+            )
 
     def prepare_node_input(
             self,
             pid,
             ctx: CtxItem,
-            html: str
+            html: str,
+            prev_ctx: Optional[CtxItem] = None,
+            next_ctx: Optional[CtxItem] = None
     ) -> str:
         """
         Prepare input node
@@ -627,6 +805,8 @@ class Renderer(BaseRenderer):
         :param pid: context PID
         :param ctx: CtxItem instance
         :param html: html text
+        :param prev_ctx: previous context item
+        :param next_ctx: next context item
         :return: prepared HTML
         """
         msg_id = "msg-user-" + str(ctx.id) if ctx is not None else ""
@@ -644,6 +824,11 @@ class Renderer(BaseRenderer):
         if type(ctx.extra) is dict and "agent_evaluate" in ctx.extra:
             name = trans("msg.name.evaluation")
 
+        # debug
+        debug = ""
+        if self.is_debug():
+            debug = self.append_debug(ctx, pid, "input")
+
         extra = ""
         if ctx.extra is not None and "footer" in ctx.extra:
             extra = ctx.extra["footer"]
@@ -653,6 +838,7 @@ class Renderer(BaseRenderer):
             '<div class="msg">'
             '{html}'
             '<div class="msg-extra">{extra}</div>'
+            '{debug}'
             '</div>'
             '</div>'
         ).format(
@@ -660,6 +846,7 @@ class Renderer(BaseRenderer):
             name=name,
             html=html,
             extra=extra,
+            debug=debug,
         )
 
         return html
@@ -669,7 +856,8 @@ class Renderer(BaseRenderer):
             meta: CtxMeta,
             ctx: CtxItem,
             html: str,
-            next_ctx: CtxItem = None
+            prev_ctx: Optional[CtxItem] = None,
+            next_ctx: Optional[CtxItem] = None
     ) -> str:
         """
         Prepare output node
@@ -677,7 +865,8 @@ class Renderer(BaseRenderer):
         :param meta: context meta
         :param ctx: CtxItem instance
         :param html: html text
-        :param next_ctx: previous context item
+        :param prev_ctx: previous context item
+        :param next_ctx: next context item
         :return: prepared HTML
         """
         is_cmd = False
@@ -689,8 +878,8 @@ class Renderer(BaseRenderer):
             is_cmd = True
         pid = self.get_or_create_pid(meta)
         msg_id = "msg-bot-" + str(ctx.id) if ctx is not None else ""
-        #if is_cmd:
-            #html = self.helpers.format_cmd_text(html)
+        # if is_cmd:
+        # html = self.helpers.format_cmd_text(html)
         html = self.helpers.pre_format_text(html)
         html = self.append_timestamp(ctx, html, type=self.NODE_OUTPUT)
         html = self.parser.parse(html)
@@ -730,7 +919,7 @@ class Renderer(BaseRenderer):
 
         # check if agent step and results in current ctx
         elif ctx.results is not None and len(ctx.results) > 0 \
-            and isinstance(ctx.extra, dict) and "agent_step" in ctx.extra:
+                and isinstance(ctx.extra, dict) and "agent_step" in ctx.extra:
             tool_output = self.helpers.format_cmd_text(str(ctx.input))
         else:
             # loading spinner
@@ -766,16 +955,21 @@ class Renderer(BaseRenderer):
         )
         tool_extra = self.body.prepare_tool_extra(ctx)
 
+        # debug
+        debug = ""
+        if self.is_debug():
+            debug = self.append_debug(ctx, pid, "output")
+
         html = (
             '<div class="msg-box msg-bot" id="{msg_id}">'
             '<div class="name-header name-bot">{name_bot}</div>'
             '<div class="msg">'
             '{html}'
-            
             '<div class="msg-tool-extra">{tool_extra}</div>'
             '{html_tools}'
             '<div class="msg-extra">{extra}</div>'
             '{footer}'
+            '{debug}'
             '</div>'
             '</div>'
         ).format(
@@ -786,11 +980,16 @@ class Renderer(BaseRenderer):
             extra=extra,
             footer=footer,
             tool_extra=tool_extra,
+            debug=debug,
         )
 
         return html
 
-    def flush_output(self, pid, html: str):
+    def flush_output(
+            self,
+            pid: Optional[int],
+            html: str
+    ):
         """
         Flush output
 
@@ -809,7 +1008,11 @@ class Renderer(BaseRenderer):
         """Reload output, called externally only on theme change to redraw content"""
         self.window.controller.ctx.refresh_output()  # if clear all and appends all items again
 
-    def flush(self, pid):
+    def flush(
+            self,
+            pid:
+            Optional[int]
+    ):
         """
         Flush output
 
@@ -818,11 +1021,14 @@ class Renderer(BaseRenderer):
         if self.pids[pid].loaded:
             return  # wait for page load
 
-        html = self.body.get_html()
+        html = self.body.get_html(pid)
         self.pids[pid].document = html
         self.get_output_node_by_pid(pid).setHtml(html, baseUrl="file://")
 
-    def get_output_node(self, meta: CtxMeta = None):
+    def get_output_node(
+            self,
+            meta: Optional[CtxMeta] = None
+    ):
         """
         Get output node
 
@@ -831,7 +1037,10 @@ class Renderer(BaseRenderer):
         """
         return self.window.core.ctx.output.get_current(meta)
 
-    def get_output_node_by_pid(self, pid):
+    def get_output_node_by_pid(
+            self,
+            pid: Optional[int]
+    ):
         """
         Get output node by PID
 
@@ -848,7 +1057,10 @@ class Renderer(BaseRenderer):
         """
         return self.window.ui.nodes['input']
 
-    def get_document(self, plain: bool = False):
+    def get_document(
+            self,
+            plain: bool = False
+    ):
         """
         Get document content (plain or HTML)
 
@@ -895,7 +1107,7 @@ class Renderer(BaseRenderer):
         pid = self.get_or_create_pid(meta)
         self.reset_names_by_pid(pid)
 
-    def reset_names_by_pid(self, pid):
+    def reset_names_by_pid(self, pid: int):
         """
         Reset names by PID
 
@@ -982,7 +1194,11 @@ class Renderer(BaseRenderer):
         except Exception as e:
             pass
 
-    def update_names(self, meta: CtxMeta, ctx: CtxItem):
+    def update_names(
+            self,
+            meta: CtxMeta,
+            ctx: CtxItem
+    ):
         """
         Update names
         
@@ -1050,7 +1266,11 @@ class Renderer(BaseRenderer):
                 self.reload_css()
                 return
 
-    def tool_output_append(self, meta: CtxMeta, content: str):
+    def tool_output_append(
+            self,
+            meta: CtxMeta,
+            content: str
+    ):
         """
         Add tool output (append)
 
@@ -1063,7 +1283,11 @@ class Renderer(BaseRenderer):
         except Exception as e:
             pass
 
-    def tool_output_update(self, meta: CtxMeta, content: str):
+    def tool_output_update(
+            self,
+            meta: CtxMeta,
+            content: str
+    ):
         """
         Replace tool output
 
@@ -1104,3 +1328,29 @@ class Renderer(BaseRenderer):
             self.get_output_node().page().runJavaScript(f"endToolOutput();")
         except Exception as e:
             pass
+
+    def append_debug(
+            self,
+            ctx: CtxItem,
+            pid,
+            title: Optional[str] = None
+    ) -> str:
+        """
+        Append debug info
+
+        :param ctx: context item
+        :param pid: context PID
+        :param title: debug title
+        """
+        if title is None:
+            title = "debug"
+        debug = "<b>" +title+ ":</b> pid: "+str(pid)+", ctx: " + str(ctx.to_dict())
+        return "<div class='debug'>" + debug + "</div>"
+
+    def is_debug(self) -> bool:
+        """
+        Check if debug mode is enabled
+
+        :return: True if debug mode is enabled
+        """
+        return self.window.core.config.get("debug.render", False)