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

pygpt_net/controller/mode/mode.py

@@ -6,7 +6,7 @@
 # GitHub:  https://github.com/szczyglis-dev/py-gpt   #
 # MIT License                                        #
 # Created By  : Marcin Szczygliński                  #
-# Updated Date: 2025.06.28 16:00:00                  #
+# Updated Date: 2025.08.15 03:00:00                  #
 # ================================================== #
 
 from pygpt_net.core.events import Event, AppEvent
@@ -24,18 +24,21 @@ class Mode:
         self.window = window
         self.locked = False
 
+    @staticmethod
+    def _normalize_mode(mode: str) -> str:
+        if mode == "langchain":
+            print("Langchain mode is deprecated from v2.5.20 and no longer supported. "
+                  "Please use LlamaIndex or Chat mode instead.")
+            return "chat"
+        return mode
+
     def select(self, mode: str):
         """
         Select mode by id
 
         :param mode
         """
-        # --- deprecated from v2.5.20 ---
-        if mode == "langchain":
-            print("Langchain mode is deprecated from v2.5.20 and no longer supported. "
-                            "Please use LlamaIndex or Chat mode instead.")
-            mode = "chat"
-        # --- end of deprecated ---
+        mode = self._normalize_mode(mode)
 
         # check if mode change is not locked
         if self.change_locked() or mode is None:
@@ -45,11 +48,13 @@ class Mode:
         event = Event(Event.MODE_SELECT, {
             'value': mode,
         })
-        self.window.dispatch(event)
-        self.window.controller.attachment.update()
-        self.window.controller.chat.attachment.update()
-        self.window.controller.chat.audio.update()
-        self.window.dispatch(AppEvent(AppEvent.MODE_SELECTED))  # app event
+        w = self.window
+        w.dispatch(event)
+        c = w.controller
+        c.attachment.update()
+        c.chat.attachment.update()
+        c.chat.audio.update()
+        w.dispatch(AppEvent(AppEvent.MODE_SELECTED))  # app event
 
     def set(self, mode: str):
         """
@@ -57,49 +62,49 @@ class Mode:
 
         :param mode: mode name
         """
-        # --- deprecated from v2.5.20 ---
-        if mode == "langchain":
-            print("Langchain mode is deprecated from v2.5.20 and no longer supported. "
-                  "Please use LlamaIndex or Chat mode instead.")
-            mode = "chat"
-        # --- end of deprecated ---
+        mode = self._normalize_mode(mode)
 
         self.locked = True
-        # if ctx loaded with assistant ID assigned then switch to assistant from ctx
-        if mode == "assistant":
-            self.window.controller.presets.select_default()
-            if self.window.core.ctx.get_current() is not None \
-                    and self.window.core.ctx.get_assistant() is not None:
-                self.window.controller.assistant.select_by_id(
-                    self.window.core.ctx.get_assistant()
-                )
-            else:
-                self.window.controller.assistant.select_current()
-
-        self.window.core.config.set('mode', mode)
-
-        # reset model and preset at start
-        self.window.core.config.set('model', "")
-        self.window.core.config.set('preset', "")
-
-        # update
-        self.window.controller.attachment.update()
-        self.window.controller.ctx.update_ctx()
-
-        # update toolbox, mode, presets, model, assistant and rest of the UI
-        self.window.controller.ui.update()
-
-        # update model list
-        self.window.controller.model.init_list()
-        self.window.controller.model.select_current()
-
-        # set status: ready
-        self.window.update_status(trans('status.started'))
-
-        # if assistant mode then update ctx label
-        if mode == "assistant":
-            self.window.controller.ctx.common.update_label_by_current()
-        self.locked = False
+        w = self.window
+        c = w.controller
+        core = w.core
+        cfg = core.config
+        try:
+            if mode == "assistant":
+                c.presets.select_default()
+                core_ctx = core.ctx
+                current = core_ctx.get_current()
+                assistant_id = core_ctx.get_assistant()
+                if current is not None and assistant_id is not None:
+                    c.assistant.select_by_id(assistant_id)
+                else:
+                    c.assistant.select_current()
+
+            cfg.set('mode', mode)
+
+            # reset model and preset at start
+            cfg.set('model', "")
+            cfg.set('preset', "")
+
+            # update
+            c.attachment.update()
+            c.ctx.update_ctx()
+
+            # update toolbox, mode, presets, model, assistant and rest of the UI
+            c.ui.update()
+
+            # update model list
+            c.model.init_list()
+            c.model.select_current()
+
+            # set status: ready
+            w.update_status(trans('status.started'))
+
+            # if assistant mode then update ctx label
+            if mode == "assistant":
+                c.ctx.common.update_label_by_current()
+        finally:
+            self.locked = False
 
     def select_on_list(self, mode: str):
         """
@@ -107,21 +112,13 @@ class Mode:
 
         :param mode: mode name
         """
-        # --- deprecated from v2.5.20 ---
-        if mode == "langchain":
-            print("Langchain mode is deprecated from v2.5.20 and no longer supported. "
-                  "Please use LlamaIndex or Chat mode instead.")
-            mode = "chat"
-        # --- end of deprecated ---
-
+        mode = self._normalize_mode(mode)
         self.window.ui.nodes["prompt.mode"].set_value(mode)
 
     def init_list(self):
         """Init modes list"""
-        items = {}
         data = self.window.core.modes.get_all()
-        for k in data:
-            items[k] = trans(data[k].label)
+        items = {k: trans(v.label) for k, v in data.items()}
         self.window.ui.nodes["prompt.mode"].set_keys(items)
 
     def select_current(self):
@@ -132,16 +129,18 @@ class Mode:
 
     def select_default(self):
         """Set default mode"""
-        mode = self.window.core.config.get('mode')
+        cfg = self.window.core.config
+        mode = cfg.get('mode')
         if mode is None or mode == "":
-            self.window.core.config.set('mode', self.window.core.modes.get_default())
+            cfg.set('mode', self.window.core.modes.get_default())
 
     def default_all(self):
         """Set default mode, model and preset"""
+        c = self.window.controller
         self.select_default()
-        self.window.controller.model.select_default()
-        self.window.controller.presets.select_default()
-        self.window.controller.assistant.select_default()
+        c.model.select_default()
+        c.presets.select_default()
+        c.assistant.select_default()
 
     def update_temperature(self, temperature: float = None):
         """
@@ -151,13 +150,14 @@ class Mode:
         :type temperature: float or None
         """
         if temperature is None:
-            if self.window.core.config.get('preset') is None or self.window.core.config.get('preset') == "":
+            cfg = self.window.core.config
+            preset_id = cfg.get('preset')
+            if preset_id is None or preset_id == "":
                 temperature = 1.0  # default temperature
             else:
-                id = self.window.core.config.get('preset')
-                if id in self.window.core.presets.items:
-                    temperature = float(self.window.core.presets.items[id].temperature or 1.0)
-        option = self.window.controller.settings.editor.get_options()["temperature"]
+                items = self.window.core.presets.items
+                if preset_id in items:
+                    temperature = float(items[preset_id].temperature or 1.0)
         '''
         self.window.controller.config.slider.on_update("global", "current_temperature", option, temperature,
                                                        hooks=False)  # disable hooks to prevent circular update
@@ -178,11 +178,13 @@ class Mode:
             return  # accept call only from slider (has already validated min/max)
 
         temperature = value / 100
-        self.window.core.config.set("temperature", temperature)
-        preset_id = self.window.core.config.get('preset')
+        cfg = self.window.core.config
+        cfg.set("temperature", temperature)
+        preset_id = cfg.get('preset')
         if preset_id is not None and preset_id != "":
-            if preset_id in self.window.core.presets.items:
-                preset = self.window.core.presets.items[preset_id]
+            items = self.window.core.presets.items
+            if preset_id in items:
+                preset = items[preset_id]
                 preset.temperature = temperature
                 self.window.core.presets.save(preset_id)
 
@@ -215,21 +217,22 @@ class Mode:
 
     def reset_current(self):
         """Reset current setup"""
-        self.window.core.config.set('prompt', None)
-        self.window.core.config.set('ai_name', None)
-        self.window.core.config.set('user_name', None)
+        cfg = self.window.core.config
+        cfg.set('prompt', None)
+        cfg.set('ai_name', None)
+        cfg.set('user_name', None)
 
     def next(self):
         """Select next mode"""
         mode = self.window.core.config.get('mode')
-        next = self.window.core.modes.get_next(mode)
-        self.select(next)
+        nxt = self.window.core.modes.get_next(mode)
+        self.select(nxt)
 
     def prev(self):
         """Select previous mode"""
         mode = self.window.core.config.get('mode')
-        prev = self.window.core.modes.get_prev(mode)
-        self.select(prev)
+        prv = self.window.core.modes.get_prev(mode)
+        self.select(prv)
 
     def change_locked(self) -> bool:
         """
@@ -238,4 +241,4 @@ class Mode:
         :return: True if locked
         :rtype: bool
         """
-        return self.window.controller.chat.input.generating
+        return bool(self.window.controller.chat.input.generating)

pygpt_net/controller/model/model.py

@@ -6,7 +6,7 @@
 # GitHub:  https://github.com/szczyglis-dev/py-gpt   #
 # MIT License                                        #
 # Created By  : Marcin Szczygliński                  #
-# Updated Date: 2025.08.07 02:00:00                  #
+# Updated Date: 2025.08.15 03:00:00                  #
 # ================================================== #
 
 from typing import Optional
@@ -29,57 +29,55 @@ class Model:
         self.editor = Editor(window)
         self.importer = Importer(window)
 
+    def _ensure_current_model_map(self):
+        return self.window.core.config.data.setdefault('current_model', {})
+
     def select(self, model: str):
         """
         Select model
 
         :param model: model ID
         """
-        # check if model change is not locked
         if self.change_locked():
             return
 
-        mode = self.window.core.config.get('mode')
-        self.window.core.config.set('model', model)
-        if 'current_model' not in self.window.core.config.data:
-            self.window.core.config.data['current_model'] = {}
-        self.window.core.config.data['current_model'][mode] = model
-
-        event = Event(Event.MODEL_SELECT, {
-            'value': model,
-        })
-        self.window.dispatch(event)
+        w = self.window
+        cfg = w.core.config
+        mode = cfg.get('mode')
+        cfg.set('model', model)
+        self._ensure_current_model_map()[mode] = model
 
-        # update all layout
-        self.window.controller.ui.update()
-        self.window.dispatch(AppEvent(AppEvent.MODEL_SELECTED))  # app event
+        w.dispatch(Event(Event.MODEL_SELECT, {'value': model}))
+        w.controller.ui.update()
+        w.dispatch(AppEvent(AppEvent.MODEL_SELECTED))
 
-        # update model in preset
-        preset = self.window.core.config.get('preset')
+        preset = cfg.get('preset')
         if preset and preset != "*":
-            preset_data = self.window.core.presets.get_by_id(mode, preset)
+            preset_data = w.core.presets.get_by_id(mode, preset)
             if preset_data:
                 preset_data.model = model
-                self.window.core.presets.save(preset)
+                w.core.presets.save(preset)
 
-        # update model in current ctx meta
-        self.window.core.ctx.model = model
-        self.window.core.ctx.last_model = model
-        self.window.core.ctx.update_model_in_current(model)
+        ctx = w.core.ctx
+        ctx.model = model
+        ctx.last_model = model
+        ctx.update_model_in_current(model)
 
     def next(self):
         """Select next model"""
-        mode = self.window.core.config.get('mode')
-        model = self.window.core.config.get('model')
-        next = self.window.core.models.get_next(model, mode)
-        self.select(next)
+        w = self.window
+        mode = w.core.config.get('mode')
+        model = w.core.config.get('model')
+        next_model = w.core.models.get_next(model, mode)
+        self.select(next_model)
 
     def prev(self):
         """Select previous model"""
-        mode = self.window.core.config.get('mode')
-        model = self.window.core.config.get('model')
-        prev = self.window.core.models.get_prev(model, mode)
-        self.select(prev)
+        w = self.window
+        mode = w.core.config.get('mode')
+        model = w.core.config.get('model')
+        prev_model = w.core.models.get_prev(model, mode)
+        self.select(prev_model)
 
     def set(self, mode: str, model: str):
         """
@@ -88,10 +86,9 @@ class Model:
         :param mode: mode name
         :param model: model name
         """
-        self.window.core.config.set('model', model)
-        if 'current_model' not in self.window.core.config.data:
-            self.window.core.config.data['current_model'] = {}
-        self.window.core.config.data['current_model'][mode] = model
+        w = self.window
+        w.core.config.set('model', model)
+        self._ensure_current_model_map()[mode] = model
 
     def set_by_idx(self, mode: str, idx: int):
         """
@@ -100,16 +97,11 @@ class Model:
         :param mode: mode name
         :param idx: model index
         """
-        model = self.window.core.models.get_by_idx(idx, mode)
-        self.window.core.config.set('model', model)
-        if 'current_model' not in self.window.core.config.data:
-            self.window.core.config.data['current_model'] = {}
-        self.window.core.config.data['current_model'][mode] = model
-
-        event = Event(Event.MODEL_SELECT, {
-            'value': model,
-        })
-        self.window.dispatch(event)
+        w = self.window
+        model = w.core.models.get_by_idx(idx, mode)
+        w.core.config.set('model', model)
+        self._ensure_current_model_map()[mode] = model
+        w.dispatch(Event(Event.MODEL_SELECT, {'value': model}))
 
     def select_on_list(self, model: str):
         """
@@ -121,28 +113,29 @@ class Model:
 
     def select_current(self):
         """Select current model on list"""
-        mode = self.window.core.config.get('mode')
-        model = self.window.core.config.get('model')
-        items = self.window.core.models.get_by_mode(mode)
+        w = self.window
+        mode = w.core.config.get('mode')
+        model = w.core.config.get('model')
+        items = w.core.models.get_by_mode(mode)
         if model in items:
             self.select_on_list(model)
 
     def select_default(self):
         """Set default model"""
-        model = self.window.core.config.get('model')
+        w = self.window
+        model = w.core.config.get('model')
         if model is None or model == "":
-            mode = self.window.core.config.get('mode')
-
-            # set previous selected model
-            current_models = self.window.core.config.get('current_model')
-            if mode in current_models and \
-                    current_models[mode] is not None and \
-                    current_models[mode] != "" and \
-                    current_models[mode] in self.window.core.models.get_by_mode(mode):
-                self.window.core.config.set('model', current_models[mode])
+            mode = w.core.config.get('mode')
+            current_models = w.core.config.get('current_model') or {}
+            mode_items = w.core.models.get_by_mode(mode)
+            if (
+                mode in current_models
+                and current_models[mode]
+                and current_models[mode] in mode_items
+            ):
+                w.core.config.set('model', current_models[mode])
             else:
-                # or set default model
-                self.window.core.config.set('model', self.window.core.models.get_default(mode))
+                w.core.config.set('model', w.core.models.get_default(mode))
 
     def switch_inline(
             self,
@@ -158,7 +151,7 @@ class Model:
         """
         event = Event(Event.MODEL_BEFORE, {
             'mode': mode,
-            'model': model,  # model instance
+            'model': model,
         })
         self.window.dispatch(event)
         tmp_model = event.data['model']
@@ -168,21 +161,28 @@ class Model:
 
     def init_list(self):
         """Init models list"""
-        mode = self.window.core.config.get('mode')
-        items = {}
-        data = self.window.core.models.get_by_mode(mode)
-        for k in data:
-            items[k] = data[k].name
-
-        providers = self.window.core.llm.get_choices()
+        w = self.window
+        mode = w.core.config.get('mode')
+        data = w.core.models.get_by_mode(mode)
+
+        items_by_provider = {}
+        for k, item in data.items():
+            p = item.provider
+            d = items_by_provider.get(p)
+            if d is None:
+                d = {}
+                items_by_provider[p] = d
+            d[k] = item.name
+
+        providers = w.core.llm.get_choices()
         sorted_items = {}
-        for provider in providers.keys():
-            provider_items = {k: v for k, v in items.items() if data[k].provider == provider}
+        for provider, label in providers.items():
+            provider_items = items_by_provider.get(provider)
             if provider_items:
-                sorted_items[f"separator::{provider}"] = providers[provider]
+                sorted_items[f"separator::{provider}"] = label
                 sorted_items.update(provider_items)
 
-        self.window.ui.nodes["prompt.model"].set_keys(sorted_items)
+        w.ui.nodes["prompt.model"].set_keys(sorted_items)
 
     def reload(self):
         """Reload models"""
@@ -200,4 +200,4 @@ class Model:
 
         :return: True if locked
         """
-        return self.window.controller.chat.input.generating
+        return self.window.controller.chat.input.generating