pygpt-net 2.6.3__py3-none-any.whl → 2.6.6__py3-none-any.whl

pygpt_net/controller/chat/render.py

@@ -6,7 +6,7 @@
 # GitHub:  https://github.com/szczyglis-dev/py-gpt   #
 # MIT License                                        #
 # Created By  : Marcin Szczygliński                  #
-# Updated Date: 2025.08.15 03:00:00                  #
+# Updated Date: 2025.08.15 23:00:00                  #
 # ================================================== #
 
 from typing import Optional, List
@@ -24,6 +24,13 @@ from pygpt_net.item.ctx import CtxItem, CtxMeta
 
 
 class Render:
+
+    _STATE_EVENTS = (
+        RenderEvent.STATE_IDLE,
+        RenderEvent.STATE_BUSY,
+        RenderEvent.STATE_ERROR,
+    )
+
     def __init__(self, window=None):
         """
         Render controller
@@ -38,130 +45,128 @@ class Render:
         self.scroll = 0
         self.renderer = None
 
-    def setup(self):
+    def setup(self) -> None:
         """Setup render"""
         self.engine = self.window.core.config.get("render.engine")
+        if self.window.core.config.get('render.plain'):
+            self.renderer = self.plaintext_renderer
+        else:
+            self.renderer = self.web_renderer if self.engine == "web" else self.markdown_renderer
 
-    def prepare(self):
+    def prepare(self) -> None:
         """Prepare render"""
         self.markdown_renderer.prepare()
         self.plaintext_renderer.prepare()
         self.web_renderer.prepare()
 
-    def handle(self, event: RenderEvent):
+    def handle(self, event: RenderEvent) -> None:
         """
         Handle render event
 
         :param event: RenderEvent
         """
         name = event.name
-        data = event.data
-        if data is None:
-            data = {}
-
-        chunk = data.get("chunk", "")
-        begin = data.get("begin", False)
-        stream = data.get("stream", False)
-        ctx = data.get("ctx")
-        meta = data.get("meta")
-        tool_data = data.get("tool_data")
-        items = data.get("items")
-        clear = data.get("clear", False)
-        flush = data.get("flush", False)
-        append = data.get("append", False)
-        footer = data.get("footer", False)
-        initialized = data.get("initialized", False)
-        tab = data.get("tab")
+        data = event.data or {}
 
         if name == RenderEvent.BEGIN:
-            self.begin(meta, ctx, stream)
+            self.begin(data.get("meta"), data.get("ctx"), data.get("stream", False))
         elif name == RenderEvent.END:
-            self.end(meta, ctx, stream)
+            self.end(data.get("meta"), data.get("ctx"), data.get("stream", False))
         elif name == RenderEvent.RELOAD:
             self.reload()
         elif name == RenderEvent.RESET:
-            self.reset(meta)
+            self.reset(data.get("meta"))
         elif name == RenderEvent.PREPARE:
             self.prepare()
 
         elif name == RenderEvent.STREAM_BEGIN:
-            self.stream_begin(meta, ctx)
+            self.stream_begin(data.get("meta"), data.get("ctx"))
         elif name == RenderEvent.STREAM_APPEND:
-            self.instance().append_chunk(meta, ctx, chunk, begin)
+            self.instance().append_chunk(
+                data.get("meta"),
+                data.get("ctx"),
+                data.get("chunk", ""),
+                data.get("begin", False),
+            )
         elif name == RenderEvent.STREAM_NEXT:
-            self.next_chunk(meta, ctx)
+            self.next_chunk(data.get("meta"), data.get("ctx"))
         elif name == RenderEvent.STREAM_END:
-            self.stream_end(meta, ctx)
+            self.stream_end(data.get("meta"), data.get("ctx"))
 
         elif name == RenderEvent.ON_PAGE_LOAD:
-            self.on_page_loaded(meta, tab)
+            self.on_page_loaded(data.get("meta"), data.get("tab"))
         elif name == RenderEvent.ON_THEME_CHANGE:
             self.on_theme_change()
         elif name == RenderEvent.ON_LOAD:
-            self.on_load(meta)
+            self.on_load(data.get("meta"))
         elif name == RenderEvent.FRESH:
-            self.fresh(meta)
+            self.fresh(data.get("meta"))
         elif name == RenderEvent.ON_TS_ENABLE:
-            self.on_enable_timestamp(live=initialized)
+            self.on_enable_timestamp(live=data.get("initialized", False))
         elif name == RenderEvent.ON_TS_DISABLE:
-            self.on_disable_timestamp(live=initialized)
+            self.on_disable_timestamp(live=data.get("initialized", False))
         elif name == RenderEvent.ON_EDIT_ENABLE:
-            self.on_enable_edit(live=initialized)
+            self.on_enable_edit(live=data.get("initialized", False))
         elif name == RenderEvent.ON_EDIT_DISABLE:
-            self.on_disable_edit(live=initialized)
+            self.on_disable_edit(live=data.get("initialized", False))
         elif name == RenderEvent.ON_SWITCH:
             self.switch()
 
         elif name == RenderEvent.CLEAR_INPUT:
             self.clear_input()
         elif name == RenderEvent.CLEAR_OUTPUT:
-            self.clear_output(meta)
+            self.clear_output(data.get("meta"))
         elif name == RenderEvent.CLEAR_ALL:
             self.clear_all()
         elif name == RenderEvent.CLEAR:
-            self.clear(meta)
+            self.clear(data.get("meta"))
 
         elif name == RenderEvent.TOOL_UPDATE:
-            self.tool_output_update(meta, tool_data)
+            self.tool_output_update(data.get("meta"), data.get("tool_data"))
         elif name == RenderEvent.TOOL_CLEAR:
-            self.tool_output_clear(meta)
+            self.tool_output_clear(data.get("meta"))
         elif name == RenderEvent.TOOL_BEGIN:
-            self.tool_output_begin(meta)
+            self.tool_output_begin(data.get("meta"))
         elif name == RenderEvent.TOOL_END:
             self.tool_output_end()
 
         elif name == RenderEvent.CTX_APPEND:
-            self.append_context(meta, items, clear)
+            self.append_context(data.get("meta"), data.get("items"), data.get("clear", True))
         elif name == RenderEvent.INPUT_APPEND:
-            self.append_input(meta, ctx, flush, append)
+            self.append_input(
+                data.get("meta"),
+                data.get("ctx"),
+                data.get("flush", True),
+                data.get("append", False),
+            )
         elif name == RenderEvent.OUTPUT_APPEND:
-            self.append_output(meta, ctx)
+            self.append_output(data.get("meta"), data.get("ctx"))
 
         elif name == RenderEvent.EXTRA_APPEND:
-            self.append_extra(meta, ctx, footer)
+            self.append_extra(data.get("meta"), data.get("ctx"), data.get("footer", False))
         elif name == RenderEvent.EXTRA_END:
-            self.end_extra(meta, ctx)
+            self.end_extra(data.get("meta"), data.get("ctx"))
 
         elif name == RenderEvent.LIVE_APPEND:
-            self.append_live(meta, ctx, chunk, begin)
+            self.append_live(
+                data.get("meta"),
+                data.get("ctx"),
+                data.get("chunk", ""),
+                data.get("begin", False),
+            )
         elif name == RenderEvent.LIVE_CLEAR:
-            self.clear_live(meta, ctx)
+            self.clear_live(data.get("meta"), data.get("ctx"))
 
         elif name == RenderEvent.ACTION_REGEN_SUBMIT:
-            self.on_reply_submit(ctx)
+            self.on_reply_submit(data.get("ctx"))
         elif name == RenderEvent.ACTION_EDIT_SUBMIT:
-            self.on_edit_submit(ctx)
-
-        # kernel state changed
-        elif name in [
-            RenderEvent.STATE_IDLE,
-            RenderEvent.STATE_BUSY,
-            RenderEvent.STATE_ERROR,
-        ]:
-            meta = meta or self.window.core.ctx.get_current_meta()
+            self.on_edit_submit(data.get("ctx"))
+
+        elif name in self._STATE_EVENTS:
+            meta = data.get("meta") or self.window.core.ctx.get_current_meta()
             self.on_state_changed(name, meta)
 
-    def on_state_changed(self, state: str, meta: Optional[CtxMeta] = None):
+    def on_state_changed(self, state: str, meta: Optional[CtxMeta] = None) -> None:
         """
         Handle state change event
 
@@ -170,7 +175,7 @@ class Render:
         """
         self.instance().state_changed(state, meta)
 
-    def append_live(self, meta: CtxMeta, ctx: CtxItem, text_chunk: str, begin: bool = False):
+    def append_live(self, meta: CtxMeta, ctx: CtxItem, text_chunk: str, begin: bool = False) -> None:
         """
         Append live text chunk to output
 
@@ -181,7 +186,7 @@ class Render:
         """
         self.instance().append_live(meta, ctx, text_chunk, begin)
 
-    def clear_live(self, meta: CtxMeta, ctx: CtxItem):
+    def clear_live(self, meta: CtxMeta, ctx: CtxItem) -> None:
         """
         Clear live output
 
@@ -200,12 +205,7 @@ class Render:
         """
         return self.instance().get_pid(meta)
 
-    def begin(
-            self,
-            meta: CtxMeta,
-            ctx: CtxItem,
-            stream: bool = False
-    ):
+    def begin(self, meta: CtxMeta, ctx: CtxItem, stream: bool = False) -> None:
         """
         Render begin
 
@@ -216,12 +216,7 @@ class Render:
         self.instance().begin(meta, ctx, stream)
         self.update()
 
-    def end(
-            self,
-            meta: CtxMeta,
-            ctx: CtxItem,
-            stream: bool = False
-    ):
+    def end(self, meta: CtxMeta, ctx: CtxItem, stream: bool = False) -> None:
         """
         Render end
 
@@ -232,15 +227,10 @@ class Render:
         self.instance().end(meta, ctx, stream)
         self.update()
 
-    def end_extra(
-            self,
-            meta: CtxMeta,
-            ctx: CtxItem,
-            stream: bool = False
-    ):
+    def end_extra(self, meta: CtxMeta, ctx: CtxItem, stream: bool = False) -> None:
         """
         Render end extra
-        
+
         :param meta: context meta
         :param ctx: context item
         :param stream: True if it is a stream
@@ -248,38 +238,27 @@ class Render:
         self.instance().end_extra(meta, ctx, stream)
         self.update()
 
-    def stream_begin(
-            self,
-            meta: CtxMeta,
-            ctx: CtxItem
-    ):
+    def stream_begin(self, meta: CtxMeta, ctx: CtxItem) -> None:
         """
         Render stream begin
-        
+
         :param meta: context meta
         :param ctx: context item
         """
         self.instance().stream_begin(meta, ctx)
         self.update()
 
-    def stream_end(
-            self,
-            meta: CtxMeta,
-            ctx: CtxItem
-    ):
+    def stream_end(self, meta: CtxMeta, ctx: CtxItem) -> None:
         """
         Render stream end
-        
+
         :param meta: context meta
         :param ctx: context item
         """
         self.instance().stream_end(meta, ctx)
         self.update()
 
-    def clear_output(
-            self,
-            meta: Optional[CtxMeta] = None
-    ):
+    def clear_output(self, meta: Optional[CtxMeta] = None) -> None:
         """
         Clear current active output
 
@@ -288,14 +267,11 @@ class Render:
         self.instance().clear_output(meta) # TODO: get meta id on load
         self.update()
 
-    def clear_input(self):
+    def clear_input(self) -> None:
         """Clear input"""
         self.instance().clear_input()
 
-    def on_load(
-            self,
-            meta: Optional[CtxMeta] = None
-    ):
+    def on_load(self, meta: Optional[CtxMeta] = None) -> None:
         """
         On load (meta)
 
@@ -305,10 +281,7 @@ class Render:
         self.update()
         self.window.controller.ui.tabs.update_tooltip(meta.name)  # update tab tooltip
 
-    def fresh(
-            self,
-            meta: Optional[CtxMeta] = None
-    ):
+    def fresh(self, meta: Optional[CtxMeta] = None) -> None:
         """
         On load (meta)
 
@@ -316,10 +289,7 @@ class Render:
         """
         self.instance().fresh(meta)
 
-    def reset(
-            self,
-            meta: Optional[CtxMeta] = None
-    ):
+    def reset(self, meta: Optional[CtxMeta] = None) -> None:
         """
         Reset current meta
 
@@ -328,17 +298,12 @@ class Render:
         self.instance().reset(meta)  # TODO: get meta id on load
         self.update()
 
-    def reload(self):
+    def reload(self) -> None:
         """Reload current output"""
         self.instance().reload()  # TODO: or all outputs?
         self.update()
 
-    def append_context(
-            self,
-            meta: CtxMeta,
-            items: List[CtxItem],
-            clear: bool = True
-    ):
+    def append_context(self, meta: CtxMeta, items: List[CtxItem], clear: bool = True) -> None:
         """
         Append all context to output
 
@@ -349,16 +314,10 @@ class Render:
         self.instance().append_context(meta, items, clear)
         self.update()
 
-    def append_input(
-            self,
-            meta: CtxMeta,
-            ctx: CtxItem,
-            flush: bool = True,
-            append: bool = False
-    ):
+    def append_input(self, meta: CtxMeta, ctx: CtxItem, flush: bool = True, append: bool = False) -> None:
         """
         Append text input to output
-        
+
         :param meta: context meta
         :param ctx: context item
         :param flush: True if flush output
@@ -367,29 +326,20 @@ class Render:
         self.instance().append_input(meta, ctx, flush=flush, append=append)
         self.update()
 
-    def append_output(
-            self,
-            meta: CtxMeta,
-            ctx: CtxItem
-    ):
+    def append_output(self, meta: CtxMeta, ctx: CtxItem) -> None:
         """
         Append text output to output
-        
+
         :param meta: context meta
         :param ctx: context item
         """
         self.instance().append_output(meta, ctx)
         self.update()
 
-    def append_extra(
-            self,
-            meta: CtxMeta,
-            ctx: CtxItem,
-            footer: bool = False
-    ):
+    def append_extra(self, meta: CtxMeta, ctx: CtxItem, footer: bool = False) -> None:
         """
         Append extra data (images, files, etc.) to output
-        
+
         :param meta: context meta
         :param ctx: context item
         :param footer: True if it is a footer
@@ -397,16 +347,10 @@ class Render:
         self.instance().append_extra(meta, ctx, footer)
         self.update()
 
-    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) -> None:
         """
         Append output stream chunk to output
-        
+
         :param meta: context meta
         :param ctx: context item
         :param text_chunk: text chunk
@@ -414,21 +358,17 @@ class Render:
         """
         self.instance().append_chunk(meta, ctx, text_chunk, begin)
 
-    def next_chunk(
-            self,
-            meta: CtxMeta,
-            ctx: CtxItem,
-    ):
+    def next_chunk(self, meta: CtxMeta, ctx: CtxItem) -> None:
         """
         Flush current stream and start with new chunks
-        
+
         :param meta: context meta
         :param ctx: context item
         """
         self.instance().next_chunk(meta, ctx)
         self.update()
 
-    def on_enable_edit(self, live: bool = True):
+    def on_enable_edit(self, live: bool = True) -> None:
         """
         On enable edit icons - global
 
@@ -437,7 +377,7 @@ class Render:
         self.instance().on_enable_edit(live)
         self.update()
 
-    def on_disable_edit(self, live: bool = True):
+    def on_disable_edit(self, live: bool = True) -> None:
         """
         On disable edit icons - global
 
@@ -446,7 +386,7 @@ class Render:
         self.instance().on_disable_edit(live)
         self.update()
 
-    def on_enable_timestamp(self, live: bool = True):
+    def on_enable_timestamp(self, live: bool = True) -> None:
         """
         On enable timestamp - global
 
@@ -455,7 +395,7 @@ class Render:
         self.instance().on_enable_timestamp(live)
         self.update()
 
-    def on_disable_timestamp(self, live: bool = True):
+    def on_disable_timestamp(self, live: bool = True) -> None:
         """
         On disable timestamp - global
 
@@ -464,7 +404,7 @@ class Render:
         self.instance().on_disable_timestamp(live)
         self.update()
 
-    def remove_item(self, id: int):
+    def remove_item(self, id: int) -> None:
         """
         Remove item from output
 
@@ -473,7 +413,7 @@ class Render:
         self.instance().remove_item(id)
         self.update()
 
-    def remove_items_from(self, id: int):
+    def remove_items_from(self, id: int) -> None:
         """
         Remove item from output
 
@@ -482,7 +422,7 @@ class Render:
         self.instance().remove_items_from(id)
         self.update()
 
-    def on_edit_submit(self, ctx: CtxItem):
+    def on_edit_submit(self, ctx: CtxItem) -> None:
         """
         On edit submit
 
@@ -491,7 +431,7 @@ class Render:
         self.instance().on_edit_submit(ctx)
         self.update()
 
-    def on_remove_submit(self, ctx: CtxItem):
+    def on_remove_submit(self, ctx: CtxItem) -> None:
         """
         On remove submit
 
@@ -500,7 +440,7 @@ class Render:
         self.instance().on_remove_submit(ctx)
         self.update()
 
-    def on_reply_submit(self, ctx: CtxItem):
+    def on_reply_submit(self, ctx: CtxItem) -> None:
         """
         On regenerate submit
 
@@ -509,11 +449,7 @@ class Render:
         self.instance().on_reply_submit(ctx)
         self.update()
 
-    def on_page_loaded(
-            self,
-            meta: CtxMeta,
-            tab: Optional[Tab] = None
-    ):
+    def on_page_loaded(self, meta: CtxMeta, tab: Optional[Tab] = None) -> None:
         """
         On page loaded callback
 
@@ -523,7 +459,7 @@ class Render:
         self.instance().on_page_loaded(meta, tab)
         self.update()
 
-    def on_theme_change(self):
+    def on_theme_change(self) -> None:
         """On theme change - global"""
         if self.get_engine() == "web":
             self.web_renderer.on_theme_change()
@@ -539,7 +475,7 @@ class Render:
         """
         return self.instance().get_scroll_position()
 
-    def set_scroll_position(self, position: int):
+    def set_scroll_position(self, position: int) -> None:
         """
         Set scroll position - active
 
@@ -548,26 +484,32 @@ class Render:
         self.instance().set_scroll_position(position)
         self.update()
 
-    def update(self):
+    def update(self) -> None:
         """On update - active"""
-        for pid in self.window.ui.nodes['output']:
-            self.window.ui.nodes['output'][pid].on_update()
+        nodes = self.window.ui.nodes
+        outputs = nodes.get('output')
+        if not outputs:
+            return
+        for node in outputs.values():
+            node.on_update()
 
-    def clear(self, meta: CtxMeta):
+    def clear(self, meta: CtxMeta) -> None:
         """
         Clear renderer
 
         :param meta: ctx meta instance
         """
-        self.reset(meta)
-        self.clear_output(meta)
+        inst = self.instance()
+        inst.reset(meta)
+        inst.clear_output(meta)
+        self.update()
 
-    def clear_all(self):
+    def clear_all(self) -> None:
         """Clear all"""
         self.instance().clear_all()
         self.update()
 
-    def remove_pid(self, pid: int):
+    def remove_pid(self, pid: int) -> None:
         """
         Remove PID from renderer
 
@@ -577,11 +519,7 @@ class Render:
         self.markdown_renderer.remove_pid(pid)
         self.web_renderer.remove_pid(pid)
 
-    def tool_output_append(
-            self,
-            meta: CtxMeta,
-            content: str
-    ):
+    def tool_output_append(self, meta: CtxMeta, content: str) -> None:
         """
         Add tool output (append)
 
@@ -591,11 +529,7 @@ class Render:
         self.instance().tool_output_append(meta, content)
         self.update()
 
-    def tool_output_update(
-            self,
-            meta: CtxMeta,
-            content: str
-    ):
+    def tool_output_update(self, meta: CtxMeta, content: str) -> None:
         """
         Replace tool output
 
@@ -605,7 +539,7 @@ class Render:
         self.instance().tool_output_update(meta, content)
         self.update()
 
-    def tool_output_clear(self, meta: CtxMeta):
+    def tool_output_clear(self, meta: CtxMeta) -> None:
         """
         Clear tool output
 
@@ -614,7 +548,7 @@ class Render:
         self.instance().tool_output_clear(meta)
         self.update()
 
-    def tool_output_begin(self, meta: CtxMeta):
+    def tool_output_begin(self, meta: CtxMeta) -> None:
         """
         Begin tool output
 
@@ -623,7 +557,7 @@ class Render:
         self.instance().tool_output_begin(meta)
         self.update()
 
-    def tool_output_end(self):
+    def tool_output_end(self) -> None:
         """
         End tool output
 
@@ -640,35 +574,34 @@ class Render:
         """
         return self.engine
 
-    def switch(self):
+    def switch(self) -> None:
         """
         Switch renderer (markdown/web <==> plain text) - active, TODO: remove from settings, leave only checkbox
         """
         plain = self.window.core.config.get('render.plain')
+        nodes = self.window.ui.nodes
         if plain:
             self.window.controller.theme.markdown.clear()
-            self.window.ui.nodes['output.timestamp'].setVisible(True)
-            for pid in self.window.ui.nodes['output_plain']:
-                try:
-                    if self.window.ui.nodes['output_plain'][pid] is not None:
-                        self.window.ui.nodes['output'][pid].setVisible(False)
-                        self.window.ui.nodes['output_plain'][pid].setVisible(True)
-                except Exception as e:
-                    pass
+            nodes['output.timestamp'].setVisible(True)
+            outputs = nodes.get('output', {})
+            outputs_plain = nodes.get('output_plain', {})
+            for pid, w_plain in outputs_plain.items():
+                w = outputs.get(pid)
+                if w and w_plain:
+                    w.setVisible(False)
+                    w_plain.setVisible(True)
         else:
-            self.window.ui.nodes['output.timestamp'].setVisible(False)
-
+            nodes['output.timestamp'].setVisible(False)
             self.window.controller.theme.markdown.update(force=True)
-            for pid in self.window.ui.nodes['output']:
-                try:
-                    if self.window.ui.nodes['output'][pid] is not None:
-                        self.window.ui.nodes['output'][pid].setVisible(True)
-                        self.window.ui.nodes['output_plain'][pid].setVisible(False)
-                except Exception as e:
-                    pass
-
-        # cache renderer instance
-        if self.window.core.config.get('render.plain'):
+            outputs = nodes.get('output', {})
+            outputs_plain = nodes.get('output_plain', {})
+            for pid, w in outputs.items():
+                w_plain = outputs_plain.get(pid)
+                if w and w_plain:
+                    w.setVisible(True)
+                    w_plain.setVisible(False)
+
+        if plain:
             self.renderer = self.plaintext_renderer
         else:
             if self.engine == "web":
@@ -685,9 +618,7 @@ class Render:
         :return: Renderer instance
         """
         if self.renderer:
-            return self.renderer  # return cached renderer instance
-
-        # get selected renderer
+            return self.renderer
         if self.window.core.config.get('render.plain'):
             return self.plaintext_renderer
         else:
@@ -697,11 +628,7 @@ class Render:
                 return self.markdown_renderer
 
     @Slot(str, str)
-    def handle_save_as(
-            self,
-            text: str,
-            type: str = 'txt'
-    ):
+    def handle_save_as(self, text: str, type: str = 'txt') -> None:
         """
         Handle save as signal  # TODO: move to another class
 
@@ -722,4 +649,4 @@ class Render:
 
         :param text: Text to read  # TODO: move to another class
         """
-        self.window.controller.audio.read_text(text)
+        self.window.controller.audio.read_text(text)