pygpt-net 2.6.19.post1__py3-none-any.whl → 2.6.21__py3-none-any.whl

pygpt_net/controller/chat/common.py

@@ -6,7 +6,7 @@
 # GitHub:  https://github.com/szczyglis-dev/py-gpt   #
 # MIT License                                        #
 # Created By  : Marcin Szczygliński                  #
-# Updated Date: 2025.08.18 01:00:00                  #
+# Updated Date: 2025.08.23 15:00:00                  #
 # ================================================== #
 
 import os
@@ -14,7 +14,7 @@ import os
 from PySide6.QtGui import QTextCursor
 from PySide6.QtWidgets import QFileDialog, QApplication
 
-from pygpt_net.core.events import Event, AppEvent, RenderEvent
+from pygpt_net.core.events import Event, AppEvent, RenderEvent, KernelEvent
 from pygpt_net.core.types import MODE_ASSISTANT
 from pygpt_net.item.ctx import CtxItem
 from pygpt_net.item.model import ModelItem
@@ -250,6 +250,21 @@ class Common:
             unlock = False
         return unlock
 
+    def auto_unlock(self, ctx: CtxItem) -> bool:
+        """
+        Auto unlock input after end
+
+        :param ctx: CtxItem
+        :return: True if unlocked
+        """
+        # don't unlock input and leave stop btn if assistant mode or if agent/autonomous is enabled
+        # send btn will be unlocked in agent mode on stop
+        if self.can_unlock(ctx):
+            if not self.window.controller.kernel.stopped():
+                self.unlock_input()  # unlock input
+                return True
+        return False
+
     def stop(self, exit: bool = False):
         """
         Stop all
@@ -257,41 +272,42 @@ class Common:
         :param exit: True if called on app exit
         """
         QApplication.processEvents()
-        mode = self.window.core.config.get('mode')
-        event = Event(Event.FORCE_STOP, {
+
+        core = self.window.core
+        controller = self.window.controller
+        dispatch = self.window.dispatch
+        dispatch(Event(Event.FORCE_STOP, {
             "value": True,
-        })
-        self.window.dispatch(event)  # stop event
-        event = Event(Event.AUDIO_INPUT_TOGGLE, {
+        })) # stop event
+
+        controller.kernel.stack.clear()  # pause reply stack
+        controller.agent.experts.stop()
+        controller.agent.legacy.on_stop()
+        controller.assistant.threads.stop = True
+        controller.assistant.threads.reset()  # reset run and func calls
+        dispatch(Event(Event.AUDIO_INPUT_TOGGLE, {
             "value": False,
-        })
-        self.window.controller.kernel.stack.clear()  # pause reply stack
-        self.window.controller.agent.experts.stop()
-        self.window.controller.agent.legacy.on_stop()
-        self.window.controller.assistant.threads.stop = True
-        self.window.controller.assistant.threads.reset()  # reset run and func calls
-        self.window.dispatch(event)  # stop audio input
-        self.window.controller.kernel.halt = True
-
-        event = RenderEvent(RenderEvent.TOOL_END)
-        self.window.dispatch(event)  # show waiting
-
-        self.window.core.gpt.stop()
+        }))  # stop audio input
+        controller.kernel.halt = True
+        dispatch(RenderEvent(RenderEvent.TOOL_END))  # show waiting
+
+        core.gpt.stop()
         self.unlock_input()
 
-        self.window.controller.chat.input.generating = False
+        controller.chat.input.generating = False
         self.window.update_status(trans('status.stopped'))
-        self.window.stateChanged.emit(self.window.STATE_IDLE)
+        dispatch(KernelEvent(KernelEvent.STATE_IDLE))  # state: idle
 
         # remotely stop assistant
+        mode = core.config.get('mode')
         if mode == MODE_ASSISTANT and not exit:
             try:
-                self.window.controller.assistant.run_stop()
+                controller.assistant.run_stop()
             except Exception as e:
-                self.window.core.debug.log(e)
+                core.debug.log(e)
 
         if not exit:
-            self.window.dispatch(AppEvent(AppEvent.INPUT_STOPPED))  # app event
+            dispatch(AppEvent(AppEvent.INPUT_STOPPED))  # app event
 
     def check_api_key(
             self,
@@ -310,15 +326,16 @@ class Common:
         if model is None:
             return True
 
+        config = self.window.core.config
         provider_keys = {
-            "openai": self.window.core.config.get('api_key', None),
-            "azure_openai": self.window.core.config.get('api_key', None),
-            "anthropic": self.window.core.config.get('api_key_anthropic', None),
-            "google": self.window.core.config.get('api_key_google', None),
-            "x_ai": self.window.core.config.get('api_key_xai', None),
-            "perplexity": self.window.core.config.get('api_key_perplexity', None),
-            "deepseek_api": self.window.core.config.get('api_key_deepseek', None),
-            "mistral_ai": self.window.core.config.get('api_key_mistral', None),
+            "openai": config.get('api_key', None),
+            "azure_openai": config.get('api_key', None),
+            "anthropic": config.get('api_key_anthropic', None),
+            "google": config.get('api_key_google', None),
+            "x_ai": config.get('api_key_xai', None),
+            "perplexity": config.get('api_key_perplexity', None),
+            "deepseek_api": config.get('api_key_deepseek', None),
+            "mistral_ai": config.get('api_key_mistral', None),
         }
 
         if model.provider in provider_keys:

pygpt_net/controller/chat/image.py

@@ -6,8 +6,9 @@
 # GitHub:  https://github.com/szczyglis-dev/py-gpt   #
 # MIT License                                        #
 # Created By  : Marcin Szczygliński                  #
-# Updated Date: 2025.08.06 01:00:00                  #
+# Updated Date: 2025.08.23 15:00:00                  #
 # ================================================== #
+
 import os
 from typing import Optional, List
 
@@ -33,16 +34,19 @@ class Image:
             self,
             text: str,
             prev_ctx: Optional[CtxItem] = None,
-            parent_id: Optional[int] = None,
     ) -> CtxItem:
         """
         Send prompt for image generate
 
         :param text: prompt for image generation
         :param prev_ctx: previous ctx item
-        :param parent_id: parent ctx id
         :return: ctx item
         """
+        core = self.window.core
+        controller = self.window.controller
+        update_status = self.window.update_status
+        dispatch = self.window.dispatch
+
         num = int(self.window.ui.config['global']['img_variants'].input.text() or 1)
         if num < 1:
             num = 1
@@ -50,79 +54,72 @@ class Image:
             num = 4
 
         # force 1 image if dall-e-3 model is used
-        mode = self.window.core.config.get('mode')
-        model = self.window.core.config.get('model')
-        model_data = self.window.core.models.get(model)
+        mode = core.config.get('mode')
+        model = core.config.get('model')
+        model_data = core.models.get(model)
         if model_data.id == 'dall-e-3' or model_data.id == 'gpt-image-1':
             num = 1
 
-        self.window.update_status(trans('status.sending'))
+        update_status(trans('status.sending'))
 
         # create ctx item
         ctx = CtxItem()
         ctx.current = True  # mark as current context item
-        ctx.meta = self.window.core.ctx.get_current_meta()  # CtxMeta (owner object)
-        ctx.set_input(text, self.window.core.config.get('user_name'))
+        ctx.meta = core.ctx.get_current_meta()  # CtxMeta (owner object)
+        ctx.set_input(text, core.config.get('user_name'))
         ctx.prev_ctx = prev_ctx  # store previous context item
         ctx.live = True
 
         # event: context before
         event = Event(Event.CTX_BEFORE)
         event.ctx = ctx
-        self.window.dispatch(event)
+        dispatch(event)
 
         # add ctx to DB
-        self.window.core.ctx.add(ctx)
+        core.ctx.add(ctx)
 
         # render: begin
-        data = {
+        dispatch(RenderEvent(RenderEvent.STREAM_BEGIN, {
             "meta": ctx.meta,
             "ctx": ctx,
             "stream": False,
-        }
-        event = RenderEvent(RenderEvent.STREAM_BEGIN, data)
-        self.window.dispatch(event)
+        }))
 
-        # append input to chat
-        data = {
+        # render: append input
+        dispatch(RenderEvent(RenderEvent.INPUT_APPEND, {
             "meta": ctx.meta,
             "ctx": ctx,
-        }
-        event = RenderEvent(RenderEvent.INPUT_APPEND, data)
-        self.window.dispatch(event)
+        }))
 
         # handle ctx name (generate title from summary if not initialized)
-        if self.window.core.config.get('ctx.auto_summary'):
-            self.window.controller.ctx.prepare_name(ctx)
+        if core.config.get('ctx.auto_summary'):
+            controller.ctx.prepare_name(ctx)
 
         # get attachments
-        files = self.window.core.attachments.get_all(mode)
+        files = core.attachments.get_all(mode)
         num_files = len(files)
         if num_files > 0:
-            self.window.controller.chat.log("Attachments ({}): {}".format(mode, num_files))
+            controller.chat.log(f"Attachments ({mode}): {num_files}")
 
         # generate image
-        bridge_context = BridgeContext(
+        context = BridgeContext(
             ctx=ctx,
             mode=MODE_IMAGE,
             model=model_data,  # model instance
             prompt=text,
             attachments=files,
         )
-        extra = {
-            "num": num,
-        }
         try:
-            event = KernelEvent(KernelEvent.REQUEST, {
-                'context': bridge_context,
-                'extra': extra,
-            })
-            self.window.dispatch(event)
+            dispatch(KernelEvent(KernelEvent.REQUEST, {
+                'context': context,
+                'extra': {
+                    "num": num,
+                },
+            }))
         except Exception as e:
-            self.window.core.debug.log(e)
+            core.debug.log(e)
             self.window.ui.dialogs.alert(e)
-            self.window.update_status(trans('status.error'))
-
+            update_status(trans('status.error'))
         return ctx
 
     @Slot(object, list, str)
@@ -139,37 +136,39 @@ class Image:
         :param paths: list with paths to downloaded images
         :param prompt: prompt used to generate images
         """
-        self.window.dispatch(KernelEvent(KernelEvent.STATE_IDLE, {
+        core = self.window.core
+        dispatch = self.window.dispatch
+
+        dispatch(KernelEvent(KernelEvent.STATE_IDLE, {
             "id": "img",
         }))
         string = ""
         i = 1
         for path in paths:
             basename = os.path.basename(path)
-            string += "[{}]({})".format(basename, path) + "\n"
+            string += f"[{basename}]({path})\n"
             i += 1
 
-        if not self.window.core.config.get('img_raw'):
-            string += "\nPrompt: "
-            string += prompt
+        if not core.config.get('img_raw'):
+            string += f"\nPrompt: {prompt}"
 
-        local_urls = self.window.core.filesystem.make_local_list(paths)
+        local_urls = core.filesystem.make_local_list(paths)
         ctx.images = local_urls  # save images paths
         ctx.set_output(string.strip())
 
         # event: after context
         event = Event(Event.CTX_AFTER)
         event.ctx = ctx
-        self.window.dispatch(event)
+        dispatch(event)
 
         # store last mode (in text mode this is handled in send_text)
-        mode = self.window.core.config.get('mode')
-        self.window.core.ctx.post_update(mode)  # post update context, store last mode, etc.
-        self.window.core.ctx.store()  # save current ctx to DB
+        mode = core.config.get('mode')
+        core.ctx.post_update(mode)  # post update context, store last mode, etc.
+        core.ctx.store()  # save current ctx to DB
         self.window.update_status(trans('status.img.generated'))
 
         # update ctx in DB
-        self.window.core.ctx.update_item(ctx)
+        core.ctx.update_item(ctx)
 
         self.window.controller.chat.common.unlock_input()  # unlock input
 
@@ -187,19 +186,23 @@ class Image:
         :param paths: list with paths to downloaded images
         :param prompt: prompt used to generate images
         """
-        self.window.dispatch(KernelEvent(KernelEvent.STATE_IDLE, {
+        core = self.window.core
+        controller = self.window.controller
+        dispatch = self.window.dispatch
+
+        dispatch(KernelEvent(KernelEvent.STATE_IDLE, {
             "id": "img",
         }))
         string = ""
         i = 1
         for path in paths:
-            string += "{}) `{}`".format(i, path) + "\n"
+            string += f"{i}) `{path}`\n"
             i += 1
 
-        local_urls = self.window.core.filesystem.make_local_list(paths)
+        local_urls = core.filesystem.make_local_list(paths)
         ctx.images = local_urls  # save images paths in ctx item here
         
-        self.window.core.ctx.update_item(ctx)  # update in DB
+        core.ctx.update_item(ctx)  # update in DB
         self.window.update_status(trans('status.img.generated'))  # update status
 
         # WARNING:
@@ -221,41 +224,28 @@ class Image:
                 "meta": ctx.meta,
                 "ctx": ctx,
             }
-            event = RenderEvent(RenderEvent.EXTRA_APPEND, data)
-            self.window.dispatch(event)  # show image first
-
-            event = RenderEvent(RenderEvent.EXTRA_END, data)
-            self.window.dispatch(event)  # end extra
+            dispatch(RenderEvent(RenderEvent.EXTRA_APPEND, data))  # show image first
+            dispatch(RenderEvent(RenderEvent.EXTRA_APPEND, data))  # end extra
 
             context = BridgeContext()
             context.ctx = ctx
-            extra = {
-                "flush": True,
-            }
-            event = KernelEvent(KernelEvent.REPLY_ADD, {
+            dispatch(KernelEvent(KernelEvent.REPLY_ADD, {
                 'context': context,
-                'extra': extra,
-            })
-            self.window.dispatch(event)
-            self.window.controller.chat.common.unlock_input()  # unlock input
-
-            event = RenderEvent(RenderEvent.TOOL_UPDATE, data)
-            self.window.dispatch(event)  # end of tool, hide spinner icon
+                'extra': {
+                    "flush": True,
+                },
+            }))
+            controller.chat.common.unlock_input()  # unlock input
+            dispatch(RenderEvent(RenderEvent.TOOL_UPDATE, data))  # end of tool, hide spinner icon
             return
 
         # NOT internal-mode, user called, so append only img output to chat (show images now):
-
         data = {
             "meta": ctx.meta,
             "ctx": ctx,
         }
-        event = RenderEvent(RenderEvent.EXTRA_APPEND, data)
-        self.window.dispatch(event)  # show image first
-
-        event = RenderEvent(RenderEvent.EXTRA_END, data)
-        self.window.dispatch(event)  # end extra
-
-        self.window.controller.chat.common.unlock_input()  # unlock input
+        dispatch(RenderEvent(RenderEvent.EXTRA_APPEND, data))  # show image first
+        dispatch(RenderEvent(RenderEvent.EXTRA_END, data))  # end extra
 
-        event = RenderEvent(RenderEvent.TOOL_UPDATE, data)
-        self.window.dispatch(event)  # end of tool, hide spinner icon
+        controller.chat.common.unlock_input()  # unlock input
+        dispatch(RenderEvent(RenderEvent.TOOL_UPDATE, data))  # end of tool, hide spinner icon