langroid 0.50.10__py3-none-any.whl → 0.50.12__py3-none-any.whl

langroid/language_models/openai_gpt.py

@@ -157,7 +157,7 @@ class AccessWarning(Warning):
 def gpt_3_5_warning() -> None:
     warnings.warn(
         f"""
-        {OpenAIChatModel.GPT4o} is not available, 
+        {OpenAIChatModel.GPT4o} is not available,
         falling back to {OpenAIChatModel.GPT3_5_TURBO}.
         Examples may not work properly and unexpected behavior may occur.
         Adjustments to prompts may be necessary.
@@ -435,8 +435,8 @@ class OpenAIGPT(LanguageModel):
                     self.config.formatter = formatter
                     logging.warning(
                         f"""
-                        Using completions (not chat) endpoint with HuggingFace 
-                        chat_template for {formatter} for 
+                        Using completions (not chat) endpoint with HuggingFace
+                        chat_template for {formatter} for
                         model {self.config.chat_model}
                         """
                     )
@@ -758,13 +758,8 @@ class OpenAIGPT(LanguageModel):
         return tmp
 
     def get_stream(self) -> bool:
-        """Get streaming status. Note we disable streaming in quiet mode."""
-        return (
-            self.config.stream
-            and settings.stream
-            and self.info().allows_streaming
-            and not settings.quiet
-        )
+        """Get streaming status."""
+        return self.config.stream and settings.stream and self.info().allows_streaming
 
     @no_type_check
     def _process_stream_event(
@@ -813,6 +808,7 @@ class OpenAIGPT(LanguageModel):
         event_args = ""
         event_fn_name = ""
         event_tool_deltas: Optional[List[Dict[str, Any]]] = None
+        silent = settings.quiet
         # The first two events in the stream of Azure OpenAI is useless.
         # In the 1st: choices list is empty, in the 2nd: the dict delta has null content
         if chat:
@@ -852,25 +848,29 @@ class OpenAIGPT(LanguageModel):
 
         if event_text:
             completion += event_text
-            sys.stdout.write(Colors().GREEN + event_text)
-            sys.stdout.flush()
+            if not silent:
+                sys.stdout.write(Colors().GREEN + event_text)
+                sys.stdout.flush()
             self.config.streamer(event_text, StreamEventType.TEXT)
         if event_reasoning:
             reasoning += event_reasoning
-            sys.stdout.write(Colors().GREEN_DIM + event_reasoning)
-            sys.stdout.flush()
+            if not silent:
+                sys.stdout.write(Colors().GREEN_DIM + event_reasoning)
+                sys.stdout.flush()
             self.config.streamer(event_reasoning, StreamEventType.TEXT)
         if event_fn_name:
             function_name = event_fn_name
             has_function = True
-            sys.stdout.write(Colors().GREEN + "FUNC: " + event_fn_name + ": ")
-            sys.stdout.flush()
+            if not silent:
+                sys.stdout.write(Colors().GREEN + "FUNC: " + event_fn_name + ": ")
+                sys.stdout.flush()
             self.config.streamer(event_fn_name, StreamEventType.FUNC_NAME)
 
         if event_args:
             function_args += event_args
-            sys.stdout.write(Colors().GREEN + event_args)
-            sys.stdout.flush()
+            if not silent:
+                sys.stdout.write(Colors().GREEN + event_args)
+                sys.stdout.flush()
             self.config.streamer(event_args, StreamEventType.FUNC_ARGS)
 
         if event_tool_deltas is not None:
@@ -878,15 +878,17 @@ class OpenAIGPT(LanguageModel):
             for td in event_tool_deltas:
                 if td["function"]["name"] is not None:
                     tool_fn_name = td["function"]["name"]
-                    sys.stdout.write(
-                        Colors().GREEN + "OAI-TOOL: " + tool_fn_name + ": "
-                    )
-                    sys.stdout.flush()
+                    if not silent:
+                        sys.stdout.write(
+                            Colors().GREEN + "OAI-TOOL: " + tool_fn_name + ": "
+                        )
+                        sys.stdout.flush()
                     self.config.streamer(tool_fn_name, StreamEventType.TOOL_NAME)
                 if td["function"]["arguments"] != "":
                     tool_fn_args = td["function"]["arguments"]
-                    sys.stdout.write(Colors().GREEN + tool_fn_args)
-                    sys.stdout.flush()
+                    if not silent:
+                        sys.stdout.write(Colors().GREEN + tool_fn_args)
+                        sys.stdout.flush()
                     self.config.streamer(tool_fn_args, StreamEventType.TOOL_ARGS)
 
         # show this delta in the stream
@@ -953,7 +955,7 @@ class OpenAIGPT(LanguageModel):
         event_args = ""
         event_fn_name = ""
         event_tool_deltas: Optional[List[Dict[str, Any]]] = None
-        silent = self.config.async_stream_quiet
+        silent = self.config.async_stream_quiet or settings.quiet
         # The first two events in the stream of Azure OpenAI is useless.
         # In the 1st: choices list is empty, in the 2nd: the dict delta has null content
         if chat:
@@ -980,46 +982,46 @@ class OpenAIGPT(LanguageModel):
             if not silent:
                 sys.stdout.write(Colors().GREEN + event_text)
                 sys.stdout.flush()
-                await self.config.streamer_async(event_text, StreamEventType.TEXT)
+            await self.config.streamer_async(event_text, StreamEventType.TEXT)
         if event_reasoning:
             reasoning += event_reasoning
             if not silent:
                 sys.stdout.write(Colors().GREEN + event_reasoning)
                 sys.stdout.flush()
-                await self.config.streamer_async(event_reasoning, StreamEventType.TEXT)
+            await self.config.streamer_async(event_reasoning, StreamEventType.TEXT)
         if event_fn_name:
             function_name = event_fn_name
             has_function = True
             if not silent:
                 sys.stdout.write(Colors().GREEN + "FUNC: " + event_fn_name + ": ")
                 sys.stdout.flush()
-                await self.config.streamer_async(
-                    event_fn_name, StreamEventType.FUNC_NAME
-                )
+            await self.config.streamer_async(event_fn_name, StreamEventType.FUNC_NAME)
 
         if event_args:
             function_args += event_args
             if not silent:
                 sys.stdout.write(Colors().GREEN + event_args)
                 sys.stdout.flush()
-                await self.config.streamer_async(event_args, StreamEventType.FUNC_ARGS)
+            await self.config.streamer_async(event_args, StreamEventType.FUNC_ARGS)
 
-        if event_tool_deltas is not None and not silent:
+        if event_tool_deltas is not None:
             # print out streaming tool calls, if not async
             for td in event_tool_deltas:
                 if td["function"]["name"] is not None:
                     tool_fn_name = td["function"]["name"]
-                    sys.stdout.write(
-                        Colors().GREEN + "OAI-TOOL: " + tool_fn_name + ": "
-                    )
-                    sys.stdout.flush()
+                    if not silent:
+                        sys.stdout.write(
+                            Colors().GREEN + "OAI-TOOL: " + tool_fn_name + ": "
+                        )
+                        sys.stdout.flush()
                     await self.config.streamer_async(
                         tool_fn_name, StreamEventType.TOOL_NAME
                     )
                 if td["function"]["arguments"] != "":
                     tool_fn_args = td["function"]["arguments"]
-                    sys.stdout.write(Colors().GREEN + tool_fn_args)
-                    sys.stdout.flush()
+                    if not silent:
+                        sys.stdout.write(Colors().GREEN + tool_fn_args)
+                        sys.stdout.flush()
                     await self.config.streamer_async(
                         tool_fn_args, StreamEventType.TOOL_ARGS
                     )
@@ -1103,7 +1105,8 @@ class OpenAIGPT(LanguageModel):
         except Exception as e:
             logging.warning("Error while processing stream response: %s", str(e))
 
-        print("")
+        if not settings.quiet:
+            print("")
         # TODO- get usage info in stream mode (?)
 
         return self._create_stream_response(
@@ -1178,7 +1181,8 @@ class OpenAIGPT(LanguageModel):
         except Exception as e:
             logging.warning("Error while processing stream response: %s", str(e))
 
-        print("")
+        if not settings.quiet:
+            print("")
         # TODO- get usage info in stream mode (?)
 
         return self._create_stream_response(
@@ -1300,7 +1304,7 @@ class OpenAIGPT(LanguageModel):
             if not isinstance(dict_or_list, dict):
                 raise ValueError(
                     f"""
-                        Invalid function args: {stripped_fn_args} 
+                        Invalid function args: {stripped_fn_args}
                         parsed as {dict_or_list},
                         which is not a valid dict.
                         """

langroid/utils/configuration.py

@@ -1,16 +1,17 @@
-import copy
 import os
+import threading
 from contextlib import contextmanager
-from typing import Iterator, List, Literal
+from typing import Any, Dict, Iterator, List, Literal, cast
 
 from dotenv import find_dotenv, load_dotenv
 
 from langroid.pydantic_v1 import BaseSettings
 
+# Global reentrant lock to serialize any modifications to the global settings.
+_global_lock = threading.RLock()
+
 
 class Settings(BaseSettings):
-    # NOTE all of these can be overridden in your .env file with upper-case names,
-    # for example CACHE_TYPE=momento
     debug: bool = False  # show debug messages?
     max_turns: int = -1  # maximum number of turns in a task (to avoid inf loop)
     progress: bool = False  # show progress spinners/bars?
@@ -25,74 +26,112 @@ class Settings(BaseSettings):
         extra = "forbid"
 
 
-load_dotenv(find_dotenv(usecwd=True))  # get settings from .env file
-settings = Settings()
+# Load environment variables from .env file.
+load_dotenv(find_dotenv(usecwd=True))
+
+# The global (default) settings instance.
+# This is updated by update_global_settings() and set_global().
+_global_settings = Settings()
+
+# Thread-local storage for temporary (per-thread) settings overrides.
+_thread_local = threading.local()
+
+
+class SettingsProxy:
+    """
+    A proxy for the settings that returns a thread‐local override if set,
+    or else falls back to the global settings.
+    """
+
+    def __getattr__(self, name: str) -> Any:
+        # If the calling thread has set an override, use that.
+        if hasattr(_thread_local, "override"):
+            return getattr(_thread_local.override, name)
+        return getattr(_global_settings, name)
+
+    def __setattr__(self, name: str, value: Any) -> None:
+        # All writes go to the global settings.
+        setattr(_global_settings, name, value)
+
+    def update(self, new_settings: Settings) -> None:
+        _global_settings.__dict__.update(new_settings.__dict__)
+
+    def dict(self) -> Dict[str, Any]:
+        # Return a dict view of the settings as seen by the caller.
+        # Note that temporary overrides are not “merged” with global settings.
+        if hasattr(_thread_local, "override"):
+            return cast(Dict[str, Any], cast(Settings, _thread_local.override.dict()))
+        return _global_settings.dict()
+
+
+settings = SettingsProxy()
 
 
 def update_global_settings(cfg: BaseSettings, keys: List[str]) -> None:
     """
-    Update global settings so modules can access them via (as an example):
-    ```
-    from langroid.utils.configuration import settings
-    if settings.debug...
-    ```
-    Caution we do not want to have too many such global settings!
-    Args:
-        cfg: pydantic config, typically from a main script
-        keys: which keys from cfg to use, to update the global settings object
+    Update global settings so that modules can later access them via, e.g.,
+
+        from langroid.utils.configuration import settings
+        if settings.debug: ...
+
+    This updates the global default.
     """
     config_dict = cfg.dict()
-
-    # Filter the config_dict based on the keys
     filtered_config = {key: config_dict[key] for key in keys if key in config_dict}
-
-    # create a new Settings() object to let pydantic validate it
     new_settings = Settings(**filtered_config)
-
-    # Update the unique global settings object
-    settings.__dict__.update(new_settings.__dict__)
+    _global_settings.__dict__.update(new_settings.__dict__)
 
 
 def set_global(key_vals: Settings) -> None:
-    """Update the unique global settings object"""
-    settings.__dict__.update(key_vals.__dict__)
+    """
+    Update the global settings object.
+    """
+    _global_settings.__dict__.update(key_vals.__dict__)
 
 
 @contextmanager
 def temporary_settings(temp_settings: Settings) -> Iterator[None]:
-    """Temporarily update the global settings and restore them afterward."""
-    original_settings = copy.deepcopy(settings)
-
-    set_global(temp_settings)
+    """
+    Temporarily override the settings for the calling thread.
 
+    Within the context, any access to "settings" will use the provided temporary
+    settings. Once the context is exited, the thread reverts to the global settings.
+    """
+    saved = getattr(_thread_local, "override", None)
+    _thread_local.override = temp_settings
     try:
         yield
     finally:
-        settings.__dict__.update(original_settings.__dict__)
+        if saved is not None:
+            _thread_local.override = saved
+        else:
+            del _thread_local.override
 
 
 @contextmanager
 def quiet_mode(quiet: bool = True) -> Iterator[None]:
-    """Temporarily set quiet=True in global settings and restore afterward."""
-    original_settings = copy.deepcopy(settings)
-    if quiet:
-        temp_settings = original_settings.copy(update={"quiet": True})
-        set_global(temp_settings)
-
-    try:
+    """
+    Temporarily override settings.quiet for the current thread.
+    This implementation builds on the thread‑local temporary_settings context manager.
+    The effective quiet mode is merged:
+    if quiet is already True (from an outer context),
+    then it remains True even if a nested context passes quiet=False.
+    """
+    current_effective = settings.dict()  # get the current thread's effective settings
+    # Create a new settings instance from the current effective state.
+    temp = Settings(**current_effective)
+    # Merge the new flag: once quiet is enabled, it stays enabled.
+    temp.quiet = settings.quiet or quiet
+    with temporary_settings(temp):
         yield
-    finally:
-        if quiet:
-            settings.__dict__.update(original_settings.__dict__)
 
 
-def set_env(settings: BaseSettings) -> None:
+def set_env(settings_instance: BaseSettings) -> None:
     """
-    Set environment variables from a BaseSettings instance
-    Args:
-        settings (BaseSettings): desired settings
-    Returns:
+    Set environment variables from a BaseSettings instance.
+
+    Each field in the settings is written to os.environ.
     """
-    for field_name, field in settings.__class__.__fields__.items():
+    for field_name, field in settings_instance.__class__.__fields__.items():
         env_var_name = field.field_info.extra.get("env", field_name).upper()
-        os.environ[env_var_name] = str(settings.dict()[field_name])
+        os.environ[env_var_name] = str(settings_instance.dict()[field_name])

{langroid-0.50.10.dist-info → langroid-0.50.12.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: langroid
-Version: 0.50.10
+Version: 0.50.12
 Summary: Harness LLMs with Multi-Agent Programming
 Author-email: Prasad Chalasani <pchalasani@gmail.com>
 License: MIT

{langroid-0.50.10.dist-info → langroid-0.50.12.dist-info}/RECORD

@@ -73,7 +73,7 @@ langroid/language_models/base.py,sha256=sCDC02hqIgjY73KnCvc-YGxZJm_LAs4Z1VVQpIFW
 langroid/language_models/config.py,sha256=9Q8wk5a7RQr8LGMT_0WkpjY8S4ywK06SalVRjXlfCiI,378
 langroid/language_models/mock_lm.py,sha256=5BgHKDVRWFbUwDT_PFgTZXz9-k8wJSA2e3PZmyDgQ1k,4022
 langroid/language_models/model_info.py,sha256=tfBBxL0iUf2mVN6CjcvqflzFUVg2oZqOJZexZ8jHTYA,12216
-langroid/language_models/openai_gpt.py,sha256=t5oFJFxfm0ZwbD5kS73TY8Hal6aCFUWX7O7dBZc-7fw,84480
+langroid/language_models/openai_gpt.py,sha256=FG3eMWedko0kN-n-SkSbwnrm5hSxoW2wmJSBAvOAOYU,84731
 langroid/language_models/utils.py,sha256=hC5p61P_Qlrowkm5wMap1A1b5ZUCwK_XhPIzAQk1T1s,5483
 langroid/language_models/prompt_formatter/__init__.py,sha256=2-5cdE24XoFDhifOLl8yiscohil1ogbP1ECkYdBlBsk,372
 langroid/language_models/prompt_formatter/base.py,sha256=eDS1sgRNZVnoajwV_ZIha6cba5Dt8xjgzdRbPITwx3Q,1221
@@ -104,7 +104,7 @@ langroid/prompts/templates.py,sha256=VV84HVf_amOx6xdWQyIsN9i5dNfrbl8rsfFp6hyfOss
 langroid/pydantic_v1/__init__.py,sha256=HxPGVERapVueRUORgSpj2JX_vTZxVlVbWvhpQlpjygE,283
 langroid/pydantic_v1/main.py,sha256=p_k7kDY9eDrsA5dxNNqXusKLgx7mS_icGnS7fu4goqY,147
 langroid/utils/__init__.py,sha256=Sruos2tB4G7Tn0vlblvYlX9PEGR0plI2uE0PJ4d_EC4,353
-langroid/utils/configuration.py,sha256=V3RS8OP7AC0_bDKczxfortD0F5H3cnsZL0ulKBxuoHU,3213
+langroid/utils/configuration.py,sha256=FJVoseN3mkqx5vzpmtkzCLuQEYlWZEK_11YJ-Ge-L5o,4812
 langroid/utils/constants.py,sha256=CK09kda9bNDEhnwClq7ZTWZOh38guJlfcZ5hKUS1Ijo,1075
 langroid/utils/git_utils.py,sha256=WnflJ3R3owhlD0LNdSJakcKhExcEehE1UW5jYVQl8JY,7955
 langroid/utils/globals.py,sha256=Az9dOFqR6n9CoTYSqa2kLikQWS0oCQ9DFQIQAnG-2q8,1355
@@ -129,7 +129,7 @@ langroid/vector_store/pineconedb.py,sha256=otxXZNaBKb9f_H75HTaU3lMHiaR2NUp5MqwLZ
 langroid/vector_store/postgres.py,sha256=wHPtIi2qM4fhO4pMQr95pz1ZCe7dTb2hxl4VYspGZoA,16104
 langroid/vector_store/qdrantdb.py,sha256=O6dSBoDZ0jzfeVBd7LLvsXu083xs2fxXtPa9gGX3JX4,18443
 langroid/vector_store/weaviatedb.py,sha256=Yn8pg139gOy3zkaPfoTbMXEEBCiLiYa1MU5d_3UA1K4,11847
-langroid-0.50.10.dist-info/METADATA,sha256=XAXiPJuTaCrL_WyihMNOfVxm1BZxk_aAxxg_OCQSQqQ,63642
-langroid-0.50.10.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-langroid-0.50.10.dist-info/licenses/LICENSE,sha256=EgVbvA6VSYgUlvC3RvPKehSg7MFaxWDsFuzLOsPPfJg,1065
-langroid-0.50.10.dist-info/RECORD,,
+langroid-0.50.12.dist-info/METADATA,sha256=b1vQBIkydfimg9r80ud7w07d7540XJAdhpegeqAPPTw,63642
+langroid-0.50.12.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+langroid-0.50.12.dist-info/licenses/LICENSE,sha256=EgVbvA6VSYgUlvC3RvPKehSg7MFaxWDsFuzLOsPPfJg,1065
+langroid-0.50.12.dist-info/RECORD,,