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

pygpt_net/core/debug/debug.py

@@ -6,7 +6,7 @@
 # GitHub:  https://github.com/szczyglis-dev/py-gpt   #
 # MIT License                                        #
 # Created By  : Marcin Szczygliński                  #
-# Updated Date: 2025.08.11 18:00:00                  #
+# Updated Date: 2025.08.15 23:00:00                  #
 # ================================================== #
 
 import gc
@@ -38,6 +38,7 @@ class Debug:
         self.window = window
         self.console = Console(window)
         self.pause_idx = 1
+        self._process = psutil.Process(os.getpid())
 
     @staticmethod
     def init(level: int = logging.ERROR):
@@ -46,13 +47,13 @@ class Debug:
 
         :param level: log level (default: ERROR)
         """
-        if not Config.prepare_workdir():
-            os.makedirs(Config.prepare_workdir())
+        workdir = Config.prepare_workdir()
+        Path(workdir).mkdir(parents=True, exist_ok=True)
 
         logging.basicConfig(
             level=level,
             format='%(asctime)s - %(levelname)s - %(message)s',
-            filename=str(Path(os.path.join(Config.prepare_workdir(), 'app.log'))),
+            filename=str(Path(workdir) / 'app.log'),
             filemode='a',
             encoding='utf-8',
         )
@@ -66,11 +67,13 @@ class Debug:
             :param tb: traceback
             """
             logger = logging.getLogger()
-            if not hasattr(logging, '_is_handling_exception'):
-                logging._is_handling_exception = True
-                logger.error("Uncaught exception:", exc_info=(exc_type, value, tb))
-                traceback.print_exception(exc_type, value, tb)
-                del logging._is_handling_exception  # remove flag when done
+            if not getattr(handle_exception, "_handling", False):
+                handle_exception._handling = True
+                try:
+                    logger.error("Uncaught exception:", exc_info=(exc_type, value, tb))
+                    traceback.print_exception(exc_type, value, tb)
+                finally:
+                    handle_exception._handling = False
             else:
                 traceback.print_exception(exc_type, value, tb)
 
@@ -84,7 +87,7 @@ class Debug:
         for handler in logger.handlers[:]:
             logger.removeHandler(handler)
             handler.close()
-        file_handler = logging.FileHandler(filename=Path(path), mode='a', encoding='utf-8')
+        file_handler = logging.FileHandler(filename=str(Path(path)), mode='a', encoding='utf-8')
         formatter = logging.Formatter('%(asctime)s - %(levelname)s - %(message)s')
         file_handler.setFormatter(formatter)
         file_handler.setLevel(level)
@@ -124,16 +127,13 @@ class Debug:
         :param id: log level id
         :return: log level name
         """
-        if id == logging.ERROR:
-            return "error"
-        elif id == logging.WARNING:
-            return "warning"
-        elif id == logging.INFO:
-            return "info"
-        elif id == logging.DEBUG:
-            return "debug"
-        else:
-            return "unknown"
+        mapping = {
+            logging.ERROR: "error",
+            logging.WARNING: "warning",
+            logging.INFO: "info",
+            logging.DEBUG: "debug",
+        }
+        return mapping.get(id, "unknown")
 
     def info(self, message: Any = None, console: bool = True):
         """
@@ -200,43 +200,36 @@ class Debug:
             return
 
         logger = logging.getLogger()
+        enabled = self.has_level(level)
 
         try:
-            # string message
             if isinstance(message, str):
-                if self.has_level(level):
+                if enabled:
                     logger.log(level, message)
                     if console:
                         print(message)
-
-            # exception
             elif isinstance(message, Exception):
                 is_sys, data = self.parse_exception(message)
-                msg = "Exception: {}".format(str(message))
+                msg = f"Exception: {message}"
                 if not is_sys:
-                    msg += "\n{}".format(data)
+                    msg += f"\n{data}"
                 logger.log(level, msg, exc_info=is_sys)
-                if self.has_level(level) and console and data:
+                if enabled and console and data:
                     print(data)
-
-            # other messages
             else:
-                if self.has_level(level):
+                if enabled:
                     logger.log(level, message)
                     if console:
                         print(message)
-        except Exception as e:
+        except Exception:
             pass
 
         try:
-            # send to logger window
-            if self.has_level(level) and self.window is not None:
-                # append thread ID
-                thread_suffix = ""
-                if not threading.current_thread() is threading.main_thread():
-                    thread_suffix = " [THREAD: {}]".format(threading.current_thread().ident)
+            if enabled and self.window is not None:
+                t = threading.current_thread()
+                thread_suffix = "" if t is threading.main_thread() else f" [THREAD: {t.ident}]"
                 self.window.logger_message.emit(str(message) + thread_suffix)
-        except Exception as e:
+        except Exception:
             pass
 
     def parse_exception(self, e: Any = None, limit: int = 4) -> Tuple[bool, str]:
@@ -249,9 +242,9 @@ class Debug:
         """
         is_sys = False
         type_name = ""
-        etype, value, tb = sys.exc_info()  # from sys by default
+        etype, value, tb = sys.exc_info()
         if etype is None and e is not None:
-            tb = e.__traceback__  # from exception
+            tb = e.__traceback__
             type_name = type(e).__name__
             value = str(e)
         else:
@@ -259,7 +252,6 @@ class Debug:
                 is_sys = True
                 type_name = etype.__name__
 
-        # traceback
         traceback_details = traceback.extract_tb(tb)
         if len(traceback_details) >= limit:
             last_calls = traceback_details[-limit:]
@@ -269,7 +261,6 @@ class Debug:
         if last_calls:
             formatted_traceback = "".join(traceback.format_list(last_calls))
 
-        # parse data
         data = ""
         if type_name:
             data += "Type: {}".format(type_name)
@@ -299,7 +290,7 @@ class Debug:
         :param level: logging level
         :return: True if enabled
         """
-        return level >= logging.getLogger().getEffectiveLevel()
+        return logging.getLogger().isEnabledFor(level)
 
     def enabled(self) -> bool:
         """
@@ -346,8 +337,7 @@ class Debug:
         :param label: label for memory usage
         :return: formatted memory usage string
         """
-        process = psutil.Process(os.getpid())
-        mem_mb = process.memory_info().rss / (1024 * 1024)
+        mem_mb = self._process.memory_info().rss / (1024 * 1024)
         data = f"Memory Usage: {mem_mb:.2f} MB"
         print(f"[{label}] {data}")
         return data
@@ -376,24 +366,25 @@ class Debug:
         res += self.print_memory_usage(label)
 
         try:
-            from pympler import asizeof, summary, muppy  # pip install pympler
+            from pympler import asizeof, summary, muppy
             objs = muppy.get_objects()
-            # objs_by_type = muppy.filter(objs, Type=dict)
             sum_by_type = summary.summarize(objs)
-            # sum_by_type = summary.summarize(objs_by_type)
             summary.print_(sum_by_type)
 
-            total_bytes = asizeof.asizeof(self.window.controller.chat.render.web_renderer.pids)
+            pids = self.window.controller.chat.render.web_renderer.pids
+            total_bytes = asizeof.asizeof(pids)
             pids_total_mb = total_bytes / (1024 * 1024)
-            count_pids = len(self.window.controller.chat.render.web_renderer.pids)
+            count_pids = len(pids)
 
-            total_bytes = asizeof.asizeof(self.window.core.ctx.meta)
+            meta = self.window.core.ctx.meta
+            total_bytes = asizeof.asizeof(meta)
             meta_total_mb = total_bytes / (1024 * 1024)
-            count_meta = len(self.window.core.ctx.meta)
+            count_meta = len(meta)
 
-            total_bytes = asizeof.asizeof(self.window.core.ctx.get_items())
+            ctx_items = self.window.core.ctx.get_items()
+            total_bytes = asizeof.asizeof(ctx_items)
             ctx_total_mb = total_bytes / (1024 * 1024)
-            count_ctx = len(self.window.core.ctx.get_items())
+            count_ctx = len(ctx_items)
 
             stats.append(f"Pids: {pids_total_mb:.4f} MB ({count_pids})")
             stats.append(f"CtxMeta: {meta_total_mb:.4f} MB ({count_meta})")
@@ -420,14 +411,13 @@ class Debug:
         :param args: objects to dump
         """
         dt = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())
-        thread_info = "[MAIN THREAD]" if threading.current_thread() is threading.main_thread() \
-            else f"[THREAD: {threading.current_thread().ident}]"
+        t = threading.current_thread()
+        thread_info = "[MAIN THREAD]" if t is threading.main_thread() else f"[THREAD: {t.ident}]"
         print(f"\n{Color.FAIL}{Color.BOLD}<DEBUG: PAUSED> #{self.pause_idx} {dt}{Color.ENDC}")
         print(f"\n{Color.BOLD}{thread_info}{Color.ENDC}")
         print("------------------------------>")
         self.pause_idx += 1
 
-        # dump args
         for index, arg in enumerate(args):
             print(f"\n{Color.BOLD}Dump {index + 1}:{Color.ENDC}")
             print(f"{Color.BOLD}Type: {type(arg)}{Color.ENDC}")
@@ -439,4 +429,4 @@ class Debug:
         traceback.print_stack()
 
         input(f"<------------------------------\n\n{Color.OKGREEN}Paused. Press Enter to continue...{Color.ENDC}")
-        print(f"------------------------------\n{Color.OKGREEN}{Color.BOLD}<RESUMED>{Color.ENDC}\n")
+        print(f"------------------------------\n{Color.OKGREEN}{Color.BOLD}<RESUMED>{Color.ENDC}\n")

pygpt_net/core/models/models.py

@@ -6,7 +6,7 @@
 # GitHub:  https://github.com/szczyglis-dev/py-gpt   #
 # MIT License                                        #
 # Created By  : Marcin Szczygliński                  #
-# Updated Date: 2025.08.08 19:00:00                  #
+# Updated Date: 2025.08.15 23:00:00                  #
 # ================================================== #
 
 import copy
@@ -72,47 +72,37 @@ class Models:
         """
         base_items = self.get_base()
         updated = False
-        added_keys = []
 
-        # check for missing keys
-        for key in base_items:
+        for key, base in base_items.items():
             if key not in self.items:
-                self.items[key] = copy.deepcopy(base_items[key])
+                self.items[key] = copy.deepcopy(base)
                 updated = True
 
-        # check for missing models ids
-        for key in base_items:
-            model_id = base_items[key].id
-            old_exists = False
-            for old_key in self.items:
-                if self.items[old_key].id == model_id:
-                    old_exists = True
-                    break
-            if not old_exists and key not in added_keys:
-                self.items[key] = copy.deepcopy(base_items[key])
-                added_keys.append(key)
+        existing_ids = {it.id for it in self.items.values()}
+        for key, base in base_items.items():
+            if base.id not in existing_ids:
+                self.items[key] = copy.deepcopy(base)
+                existing_ids.add(base.id)
                 updated = True
 
-        # update multimodal options
-        for key in self.items:
-            if key in base_items:
-                if base_items[key].input != self.items[key].input:
-                    self.items[key].input = base_items[key].input
-                    updated = True
-                if base_items[key].output != self.items[key].output:
-                    self.items[key].output = base_items[key].output
-                    updated = True
-
-        # update empty multimodal options
-        for key in self.items:
-            if isinstance(self.items[key].input, list):
-                if len(self.items[key].input) == 0:
-                    self.items[key].input = ["text"]
-                    updated = True
-            if isinstance(self.items[key].output, list):
-                if len(self.items[key].output) == 0:
-                    self.items[key].output = ["text"]
-                    updated = True
+        for key, base in base_items.items():
+            item = self.items.get(key)
+            if not item:
+                continue
+            if base.input != item.input:
+                item.input = base.input
+                updated = True
+            if base.output != item.output:
+                item.output = base.output
+                updated = True
+
+        for item in self.items.values():
+            if isinstance(item.input, list) and not item.input:
+                item.input = ["text"]
+                updated = True
+            if isinstance(item.output, list) and not item.output:
+                item.output = ["text"]
+                updated = True
 
         if updated:
             self.save()
@@ -126,8 +116,7 @@ class Models:
         :param key: model name
         :return: model config object
         """
-        if key in self.items:
-            return self.items[key]
+        return self.items.get(key)
 
     def get_ids(self) -> List[str]:
         """
@@ -167,9 +156,7 @@ class Models:
         :param mode: mode name
         :return: True if model is allowed for mode
         """
-        if model in self.items:
-            return mode in self.items[model].mode
-        return False
+        return model in self.items and mode in self.items[model].mode
 
     def get_id(
             self,
@@ -181,8 +168,8 @@ class Models:
         :param key: model key
         :return: model id
         """
-        if key in self.items:
-            return self.items[key].id
+        item = self.items.get(key)
+        return item.id if item else None
 
     def get_by_idx(
             self,
@@ -209,11 +196,7 @@ class Models:
         :param mode: mode name
         :return: models dict for mode
         """
-        items = {}
-        for key in self.items:
-            if mode in self.items[key].mode:
-                items[key] = self.items[key]
-        return items
+        return {k: v for k, v in self.items.items() if mode in v.mode}
 
     def get_next(
             self,
@@ -259,10 +242,17 @@ class Models:
 
         :return: new model id
         """
-        id = "model-000"
-        while id in self.items:
-            id = "model-" + str(int(id.split("-")[1]) + 1).zfill(3)
-        return id
+        prefix = "model-"
+        used = set()
+        for k in self.items.keys():
+            if isinstance(k, str) and k.startswith(prefix):
+                suffix = k[len(prefix):]
+                if suffix.isdigit():
+                    used.add(int(suffix))
+        n = 0
+        while n in used:
+            n += 1
+        return f"{prefix}{n:03d}"
 
     def get_multimodal_list(self) -> List[str]:
         """
@@ -336,8 +326,8 @@ class Models:
         :param model: model name
         :return: True if model exists for mode
         """
-        items = self.get_by_mode(mode)
-        return model in items
+        item = self.items.get(model)
+        return bool(item and mode in item.mode)
 
     def get_default(self, mode: str) -> Optional[str]:
         """
@@ -346,13 +336,10 @@ class Models:
         :param mode: mode name
         :return: default model name
         """
-        models = {}
         items = self.get_by_mode(mode)
-        for k in items:
-            models[k] = items[k]
-        if len(models) == 0:
+        if not items:
             return None
-        return list(models.keys())[0]
+        return next(iter(items))
 
     def get_tokens(self, model: str) -> int:
         """
@@ -385,12 +372,10 @@ class Models:
 
         :param model: model name
         """
-        # restore all models
         if model is None:
             self.load_base()
             return
 
-        # restore single model
         items = self.provider.load_base()
         if model in items:
             self.items[model] = items[model]
@@ -435,34 +420,24 @@ class Models:
         :return: mode (supported)
         """
         prev_mode = mode
-        # if OpenAI API model and not llama_index mode, switch to Chat mode
-        if model.is_supported(MODE_CHAT) and mode != MODE_LLAMA_INDEX:  # do not switch if llama_index mode!
+        if model.is_supported(MODE_CHAT) and mode != MODE_LLAMA_INDEX:
             if prev_mode != MODE_CHAT:
                 self.window.core.debug.info(
                     "WARNING: Switching to chat mode (model not supported in: {})".format(prev_mode))
             return MODE_CHAT
 
-        # Research / Perplexity
         if model.is_supported(MODE_RESEARCH):
             if prev_mode != MODE_RESEARCH:
                 self.window.core.debug.info(
                     "WARNING: Switching to research mode (model not supported in: {})".format(mode))
             mode = MODE_RESEARCH
 
-        # Llama Index / Chat with Files
         elif model.is_supported(MODE_LLAMA_INDEX):
             if prev_mode != MODE_LLAMA_INDEX:
                 self.window.core.debug.info(
                     "WARNING: Switching to llama_index mode (model not supported in: {})".format(mode))
             mode = MODE_LLAMA_INDEX
 
-        # LangChain
-        """
-        elif model.is_supported(MODE_LANGCHAIN):
-            self.window.core.debug.info(
-                "WARNING: Switching to langchain mode (model not supported in: {})".format(mode))
-            mode = MODE_LANGCHAIN
-        """
         return mode
 
     def prepare_client_args(
@@ -477,65 +452,55 @@ class Models:
         :param model: ModelItem
         :return: client arguments dict
         """
+        cfg = self.window.core.config
         args = {
-            "api_key": self.window.core.config.get('api_key'),
-            "organization": self.window.core.config.get('organization_key'),
+            "api_key": cfg.get('api_key'),
+            "organization": cfg.get('organization_key'),
         }
-        # api endpoint
-        if self.window.core.config.has('api_endpoint'):
-            endpoint = self.window.core.config.get('api_endpoint')
+
+        if cfg.has('api_endpoint'):
+            endpoint = cfg.get('api_endpoint')
             if endpoint:
                 args["base_url"] = endpoint
-        # proxy
-        if self.window.core.config.has('api_proxy'):
-            proxy = self.window.core.config.get('api_proxy')
+
+        if cfg.has('api_proxy'):
+            proxy = cfg.get('api_proxy')
             if proxy:
                 transport = SyncProxyTransport.from_url(proxy)
-                args["http_client"] = DefaultHttpxClient(
-                    transport=transport,
-                )
+                args["http_client"] = DefaultHttpxClient(transport=transport)
 
-        # research mode endpoint - Perplexity
         if model is not None:
-            # xAI / grok
             if model.provider == "x_ai":
-                args["api_key"] = self.window.core.config.get('api_key_xai', "")
-                args["base_url"] = self.window.core.config.get('api_endpoint_xai', "")
+                args["api_key"] = cfg.get('api_key_xai', "")
+                args["base_url"] = cfg.get('api_endpoint_xai', "")
                 self.window.core.debug.info("[api] Using client: xAI")
-            # Perplexity
             elif model.provider == "perplexity":
-                args["api_key"] = self.window.core.config.get('api_key_perplexity', "")
-                args["base_url"] = self.window.core.config.get('api_endpoint_perplexity', "")
+                args["api_key"] = cfg.get('api_key_perplexity', "")
+                args["base_url"] = cfg.get('api_endpoint_perplexity', "")
                 self.window.core.debug.info("[api] Using client: Perplexity")
-            # Google
             elif model.provider == "google":
-                args["api_key"] = self.window.core.config.get('api_key_google', "")
-                args["base_url"] = self.window.core.config.get('api_endpoint_google', "")
+                args["api_key"] = cfg.get('api_key_google', "")
+                args["base_url"] = cfg.get('api_endpoint_google', "")
                 self.window.core.debug.info("[api] Using client: Google")
-            # Anthropic
             elif model.provider == "anthropic":
-                args["api_key"] = self.window.core.config.get('api_key_anthropic', "")
-                args["base_url"] = self.window.core.config.get('api_endpoint_anthropic', "")
+                args["api_key"] = cfg.get('api_key_anthropic', "")
+                args["base_url"] = cfg.get('api_endpoint_anthropic', "")
                 self.window.core.debug.info("[api] Using client: Anthropic")
-            # Deepseek
             elif model.provider == "deepseek_api":
-                args["api_key"] = self.window.core.config.get('api_key_deepseek', "")
-                args["base_url"] = self.window.core.config.get('api_endpoint_deepseek', "")
+                args["api_key"] = cfg.get('api_key_deepseek', "")
+                args["base_url"] = cfg.get('api_endpoint_deepseek', "")
                 self.window.core.debug.info("[api] Using client: Deepseek API")
-            # Mistral AI
             elif model.provider == "mistral_ai":
-                args["api_key"] = self.window.core.config.get('api_key_mistral', "")
-                args["base_url"] = self.window.core.config.get('api_endpoint_mistral', "")
+                args["api_key"] = cfg.get('api_key_mistral', "")
+                args["base_url"] = cfg.get('api_endpoint_mistral', "")
                 self.window.core.debug.info("[api] Using client: Mistral AI API")
-            # HuggingFace Router
             elif model.provider == "huggingface_router":
-                args["api_key"] = self.window.core.config.get('api_key_hugging_face', "")
-                args["base_url"] = self.window.core.config.get('api_endpoint_hugging_face', "")
+                args["api_key"] = cfg.get('api_key_hugging_face', "")
+                args["base_url"] = cfg.get('api_endpoint_hugging_face', "")
                 self.window.core.debug.info("[api] Using client: HuggingFace Router API")
             else:
                 self.window.core.debug.info("[api] Using client: OpenAI (default)")
 
-            # do not include organization for non-OpenAI providers
             if model.provider != "openai":
                 if "organization" in args:
                     del args["organization"]
@@ -554,12 +519,9 @@ class Models:
         if mode == MODE_LLAMA_INDEX:
             if model.provider == "google":
                 stream = self.window.core.config.get('stream', False)
-                use_react = self.window.core.config.get("llama.idx.react", False)  # use ReAct agent for tool calls
+                use_react = self.window.core.config.get("llama.idx.react", False)
                 if stream:
-                    if use_react:
-                        return True
-                    else:
-                        return False
+                    return bool(use_react)
         if model.tool_calls:
             return True
         return False
@@ -570,4 +532,4 @@ class Models:
 
         :return: config version
         """
-        return self.provider.get_version()
+        return self.provider.get_version()

pygpt_net/core/modes/modes.py

@@ -6,7 +6,7 @@
 # GitHub:  https://github.com/szczyglis-dev/py-gpt   #
 # MIT License                                        #
 # Created By  : Marcin Szczygliński                  #
-# Updated Date: 2025.07.30 00:00:00                  #
+# Updated Date: 2025.08.15 23:00:00                  #
 # ================================================== #
 
 from typing import Dict, List
@@ -41,7 +41,7 @@ class Modes:
         self.window = window
         self.provider = JsonFileProvider(window)
         self.initialized = False
-        self.all = [
+        self.all = (
             MODE_AGENT,
             MODE_AGENT_LLAMA,
             MODE_AGENT_OPENAI,
@@ -56,7 +56,7 @@ class Modes:
             MODE_VISION,
             MODE_RESEARCH,
             MODE_COMPUTER,
-        ]
+        )
         self.items = {}
 
     def get_by_idx(self, idx) -> str:
@@ -66,8 +66,8 @@ class Modes:
         :param idx: index of mode
         :return: mode name
         """
-        modes = self.get_all()
-        return list(modes.keys())[idx]
+        keys = tuple(self.items)
+        return keys[idx]
 
     def get_idx_by_name(self, name) -> int:
         """
@@ -76,8 +76,8 @@ class Modes:
         :param name: mode name
         :return: mode index
         """
-        modes = self.get_all()
-        return list(modes.keys()).index(name)
+        keys = tuple(self.items)
+        return keys.index(name)
 
     def get_all(self) -> Dict[str, List[str]]:
         """
@@ -93,9 +93,7 @@ class Modes:
 
         :return: default mode name
         """
-        for id in self.items:
-            if self.items[id].default:
-                return id
+        return next((k for k, v in self.items.items() if v.default), None)
 
     def get_next(self, mode: str) -> str:
         """
@@ -104,12 +102,9 @@ class Modes:
         :param mode: current mode
         :return: next mode
         """
-        modes = self.get_all()
-        keys = list(modes.keys())
+        keys = tuple(self.items)
         idx = keys.index(mode)
-        if idx + 1 < len(keys):
-            return keys[idx + 1]
-        return keys[0]
+        return keys[(idx + 1) % len(keys)]
 
     def get_prev(self, mode: str) -> str:
         """
@@ -118,12 +113,9 @@ class Modes:
         :param mode: current mode
         :return: previous mode
         """
-        modes = self.get_all()
-        keys = list(modes.keys())
+        keys = tuple(self.items)
         idx = keys.index(mode)
-        if idx - 1 >= 0:
-            return keys[idx - 1]
-        return keys[-1]
+        return keys[(idx - 1) % len(keys)]
 
     def load(self):
         """Load modes"""
@@ -131,4 +123,4 @@ class Modes:
 
     def save(self):
         """Save modes"""
-        self.provider.save(self.items)
+        self.provider.save(self.items)