langroid 0.1.85__py3-none-any.whl → 0.1.219__py3-none-any.whl

langroid/utils/configuration.py

@@ -1,7 +1,9 @@
+import copy
 import os
-from typing import List
+from contextlib import contextmanager
+from typing import Iterator, List, Literal
 
-from dotenv import load_dotenv
+from dotenv import find_dotenv, load_dotenv
 from pydantic import BaseSettings
 
 
@@ -12,17 +14,18 @@ class Settings(BaseSettings):
     progress: bool = False  # show progress spinners/bars?
     stream: bool = True  # stream output?
     cache: bool = True  # use cache?
-    cache_type: str = "redis"  # cache type: "redis" or "momento"
+    cache_type: Literal["redis", "fakeredis", "momento"] = "redis"  # cache type
     interactive: bool = True  # interactive mode?
     gpt3_5: bool = True  # use GPT-3.5?
-    nofunc: bool = False  # use model without function_call? (i.e. gpt-4)
     chat_model: str = ""  # language model name, e.g. litellm/ollama/llama2
+    quiet: bool = False  # quiet mode (i.e. suppress all output)?
+    notebook: bool = False  # running in a notebook?
 
     class Config:
         extra = "forbid"
 
 
-load_dotenv()  # get settings from .env file
+load_dotenv(find_dotenv(usecwd=True))  # get settings from .env file
 settings = Settings()
 
 
@@ -55,6 +58,34 @@ def set_global(key_vals: Settings) -> None:
     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)
+
+    try:
+        yield
+    finally:
+        settings.__dict__.update(original_settings.__dict__)
+
+
+@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:
+        yield
+    finally:
+        if quiet:
+            settings.__dict__.update(original_settings.__dict__)
+
+
 def set_env(settings: BaseSettings) -> None:
     """
     Set environment variables from a BaseSettings instance

langroid/utils/constants.py

@@ -16,3 +16,7 @@ class Colors(BaseModel):
 USER_QUIT = ["q", "x", "quit", "exit", "bye"]
 NO_ANSWER = "DO-NOT-KNOW"
 DONE = "DONE"
+PASS = "__PASS__"
+PASS_TO = PASS + ":"
+SEND_TO = "SEND:"
+TOOL = "TOOL"

langroid/utils/globals.py

@@ -1,4 +1,4 @@
-from typing import Any, Optional, Type, TypeVar
+from typing import Any, Dict, Optional, Type, TypeVar
 
 from pydantic import BaseModel
 
@@ -23,7 +23,7 @@ class GlobalState(BaseModel):
         return cls._instance
 
     @classmethod
-    def set_values(cls: Type[T], **kwargs) -> None:  # type: ignore
+    def set_values(cls: Type[T], **kwargs: Dict[str, Any]) -> None:
         """
         Set values on the global instance of the specific subclass.
 

langroid/utils/logging.py

@@ -72,12 +72,9 @@ def setup_file_logger(
     propagate: bool = False,
 ) -> logging.Logger:
     os.makedirs(os.path.dirname(filename), exist_ok=True)
-    if not append:
-        if os.path.exists(filename):
-            os.remove(filename)
-
+    file_mode = "a" if append else "w"
     logger = setup_logger(name)
-    handler = logging.FileHandler(filename)
+    handler = logging.FileHandler(filename, mode=file_mode)
     handler.setLevel(logging.INFO)
     if log_format:
         formatter = logging.Formatter(

langroid/utils/output/__init__.py

@@ -0,0 +1,21 @@
+from . import printing
+
+from .printing import (
+    shorten_text,
+    print_long_text,
+    show_if_debug,
+    SuppressLoggerWarnings,
+    PrintColored,
+)
+
+from .status import status
+
+__all__ = [
+    "printing",
+    "shorten_text",
+    "print_long_text",
+    "show_if_debug",
+    "SuppressLoggerWarnings",
+    "PrintColored",
+    "status",
+]

langroid/utils/output/printing.py

@@ -1,5 +1,7 @@
+import logging
 import sys
-from typing import Any, Optional
+from contextlib import contextmanager
+from typing import Any, Iterator, Optional
 
 from rich import print as rprint
 from rich.text import Text
@@ -46,3 +48,47 @@ class PrintColored:
 
     def __exit__(self, exc_type: Any, exc_val: Any, exc_tb: Any) -> None:
         print(Colors().RESET)
+
+
+@contextmanager
+def silence_stdout() -> Iterator[None]:
+    """
+    Temporarily silence all output to stdout and from rich.print.
+
+    This context manager redirects all output written to stdout (which includes
+    outputs from the built-in print function and rich.print) to /dev/null on
+    UNIX-like systems or NUL on Windows. Once the context block exits, stdout is
+    restored to its original state.
+
+    Example:
+        with silence_stdout_and_rich():
+            print("This won't be printed")
+            rich.print("This also won't be printed")
+
+    Note:
+        This suppresses both standard print functions and the rich library outputs.
+    """
+    platform_null = "/dev/null" if sys.platform != "win32" else "NUL"
+    original_stdout = sys.stdout
+    fnull = open(platform_null, "w")
+    sys.stdout = fnull
+    try:
+        yield
+    finally:
+        sys.stdout = original_stdout
+        fnull.close()
+
+
+class SuppressLoggerWarnings:
+    def __init__(self, logger: str | None = None):
+        # If no logger name is given, get the root logger
+        self.logger = logging.getLogger(logger)
+        self.original_level = self.logger.getEffectiveLevel()
+
+    def __enter__(self) -> None:
+        # Set the logging level to 'ERROR' to suppress warnings
+        self.logger.setLevel(logging.ERROR)
+
+    def __exit__(self, exc_type, exc_value, traceback) -> None:  # type: ignore
+        # Reset the logging level to its original value
+        self.logger.setLevel(self.original_level)

langroid/utils/output/status.py

@@ -0,0 +1,33 @@
+import logging
+from contextlib import AbstractContextManager, ExitStack
+from typing import Any
+
+from rich.console import Console
+
+from langroid.utils.configuration import quiet_mode, settings
+
+console = Console()
+logger = logging.getLogger(__name__)
+logger.setLevel(logging.INFO)
+
+
+def status(
+    msg: str,
+    log_if_quiet: bool = True,
+) -> AbstractContextManager[Any]:
+    """
+    Displays a rich spinner if not in quiet mode, else optionally logs the message.
+    """
+    stack = ExitStack()
+
+    if settings.quiet:
+        if log_if_quiet:
+            logger.info(msg)
+    if settings.quiet and log_if_quiet:
+        logger.info(msg)
+    else:
+        stack.enter_context(console.status(msg))
+
+    stack.enter_context(quiet_mode(not settings.debug))
+
+    return stack

langroid/utils/pandas_utils.py

@@ -0,0 +1,30 @@
+from typing import Any
+
+import pandas as pd
+
+
+def stringify(x: Any) -> str:
+    # Convert x to DataFrame if it is not one already
+    if isinstance(x, pd.Series):
+        df = x.to_frame()
+    elif not isinstance(x, pd.DataFrame):
+        return str(x)
+    else:
+        df = x
+
+    # Truncate long text columns to 1000 characters
+    for col in df.columns:
+        if df[col].dtype == object:
+            df[col] = df[col].apply(
+                lambda item: (
+                    (item[:1000] + "...")
+                    if isinstance(item, str) and len(item) > 1000
+                    else item
+                )
+            )
+
+    # Limit to 10 rows
+    df = df.head(10)
+
+    # Convert to string
+    return df.to_string(index=False)  # type: ignore