langroid 0.32.2__py3-none-any.whl → 0.33.4__py3-none-any.whl

langroid/utils/git_utils.py

@@ -1,252 +0,0 @@
-import fnmatch
-import logging
-import textwrap
-from pathlib import Path
-from typing import List
-
-import git
-from github import Github, GithubException
-
-from langroid.utils.system import create_file
-
-logger = logging.getLogger(__name__)
-
-
-def git_read_file(repo: str, filepath: str) -> str:
-    """
-    Read the contents of a file from a GitHub repository.
-
-    Args:
-        repo (str): The GitHub repository in the format "owner/repo"
-        filepath (str): The file path relative to the repository root
-
-    Returns:
-        str: The contents of the file as a string
-    """
-    try:
-        g = Github()
-        github_repo = g.get_repo(repo)
-        file_content = github_repo.get_contents(filepath)
-        if isinstance(file_content, list) and len(file_content) > 0:
-            return file_content[0].decoded_content.decode("utf-8")
-        elif hasattr(file_content, "decoded_content"):
-            return file_content.decoded_content.decode("utf-8")
-        else:
-            logger.error(f"Unexpected file_content type: {type(file_content)}")
-            return ""
-    except GithubException as e:
-        logger.error(f"An error occurred while reading file {filepath}: {e}")
-        return ""
-
-
-def get_file_list(repo: str, dir: str, pat: str = "") -> List[str]:
-    """
-    Get a list of files in a specified directory of a GitHub repository.
-
-    Args:
-        repo (str): The GitHub repository in the format "owner/repo"
-        dir (str): The directory path relative to the repository root
-        pat (str): Optional wildcard pattern to filter file names (default: "")
-
-    Returns:
-        List[str]: A list of file paths in the specified directory
-    """
-    try:
-        g = Github()
-        github_repo = g.get_repo(repo)
-        contents = github_repo.get_contents(dir)
-
-        file_list = []
-        if isinstance(contents, list):
-            file_list = [content.path for content in contents if content.type == "file"]
-        elif hasattr(contents, "path") and hasattr(contents, "type"):
-            if contents.type == "file":
-                file_list = [contents.path]
-
-        if pat:
-            file_list = [file for file in file_list if fnmatch.fnmatch(file, pat)]
-        return sorted(file_list)
-
-    except GithubException as e:
-        logger.error(f"An error occurred while fetching file list: {e}")
-        return []
-
-
-def git_init_repo(dir: str) -> git.Repo | None:
-    """
-    Set up a Git repository in the specified directory.
-
-    Args:
-        dir (str): Path to the directory where the Git repository should be initialized
-
-    Returns:
-        git.Repo: The initialized Git repository object
-    """
-    repo_path = Path(dir).expanduser()
-    try:
-        repo = git.Repo.init(repo_path)
-        logger.info(f"Git repository initialized in {repo_path}")
-
-        gitignore_content = textwrap.dedent(
-            """
-        /target/
-        **/*.rs.bk
-        Cargo.lock
-        """
-        ).strip()
-
-        gitignore_path = repo_path / ".gitignore"
-        create_file(gitignore_path, gitignore_content)
-        logger.info(f"Created .gitignore file in {repo_path}")
-
-        # Ensure the default branch is 'main'
-        # Check if we're on the master branch
-        if repo.active_branch.name == "master":
-            # Rename the branch
-            repo.git.branch("-m", "master", "main")
-            print("Branch renamed from 'master' to 'main'")
-        else:
-            print("Current branch is not 'master'. No changes made.")
-        return repo
-    except git.GitCommandError as e:
-        logger.error(f"An error occurred while initializing the repository: {e}")
-        return None
-
-
-def git_commit_file(repo: git.Repo, filepath: str, msg: str) -> None:
-    """
-    Commit a file to a Git repository.
-
-    Args:
-        repo (git.Repo): The Git repository object
-        filepath (str): Path to the file to be committed
-        msg (str): The commit message
-
-    Returns:
-        None
-    """
-    try:
-        repo.index.add([filepath])
-        commit_msg = msg or f"Updated {filepath}"
-        repo.index.commit(commit_msg)
-        logger.info(f"Successfully committed {filepath}: {commit_msg}")
-    except git.GitCommandError as e:
-        logger.error(f"An error occurred while committing: {e}")
-
-
-def git_commit_mods(repo: git.Repo, msg: str = "commit all changes") -> None:
-    """
-    Commit all modifications in the Git repository.
-    Does not raise an error if there's nothing to commit.
-
-    Args:
-        repo (git.Repo): The Git repository object
-
-    Returns:
-        None
-    """
-    try:
-        if repo.is_dirty():
-            repo.git.add(update=True)
-            repo.index.commit(msg)
-            logger.info("Successfully committed all modifications")
-        else:
-            logger.info("No changes to commit")
-    except git.GitCommandError as e:
-        logger.error(f"An error occurred while committing modifications: {e}")
-
-
-def git_restore_repo(repo: git.Repo) -> None:
-    """
-    Restore all unstaged, uncommitted changes in the Git repository.
-    This function undoes any dirty files to the last commit.
-
-    Args:
-        repo (git.Repo): The Git repository object
-
-    Returns:
-        None
-    """
-    try:
-        if repo.is_dirty():
-            repo.git.restore(".")
-            logger.info("Successfully restored all unstaged changes")
-        else:
-            logger.info("No unstaged changes to restore")
-    except git.GitCommandError as e:
-        logger.error(f"An error occurred while restoring changes: {e}")
-
-
-def git_restore_file(repo: git.Repo, file_path: str) -> None:
-    """
-    Restore a specific file in the Git repository to its state in the last commit.
-    This function undoes changes to the specified file.
-
-    Args:
-        repo (git.Repo): The Git repository object
-        file_path (str): Path to the file to be restored
-
-    Returns:
-        None
-    """
-    try:
-        repo.git.restore(file_path)
-        logger.info(f"Successfully restored file: {file_path}")
-    except git.GitCommandError as e:
-        logger.error(f"An error occurred while restoring file {file_path}: {e}")
-
-
-def git_create_checkout_branch(repo: git.Repo, branch: str) -> None:
-    """
-    Create and checkout a new branch in the given Git repository.
-    If the branch already exists, it will be checked out.
-    If we're already on the specified branch, no action is taken.
-
-    Args:
-        repo (git.Repo): The Git repository object
-        branch (str): The name of the branch to create or checkout
-
-    Returns:
-        None
-    """
-    try:
-        if repo.active_branch.name == branch:
-            logger.info(f"Already on branch: {branch}")
-            return
-
-        if branch in repo.heads:
-            repo.heads[branch].checkout()
-            logger.info(f"Checked out existing branch: {branch}")
-        else:
-            new_branch = repo.create_head(branch)
-            new_branch.checkout()
-            logger.info(f"Created and checked out new branch: {branch}")
-    except git.GitCommandError as e:
-        logger.error(f"An error occurred while creating/checking out branch: {e}")
-
-
-def git_diff_file(repo: git.Repo, filepath: str) -> str:
-    """
-    Show diffs of file between the latest commit and the previous one if any.
-
-    Args:
-        repo (git.Repo): The Git repository object
-        filepath (str): Path to the file to be diffed
-
-    Returns:
-        str: The diff output as a string
-    """
-    try:
-        # Get the two most recent commits
-        commits = list(repo.iter_commits(paths=filepath, max_count=2))
-
-        if len(commits) < 2:
-            return "No previous commit found for comparison."
-
-        # Get the diff between the two commits for the specific file
-        diff = repo.git.diff(commits[1].hexsha, commits[0].hexsha, filepath)
-
-        return str(diff)
-    except git.GitCommandError as e:
-        logger.error(f"An error occurred while getting diff: {e}")
-        return f"Error: {str(e)}"

langroid/utils/globals.py

@@ -1,49 +0,0 @@
-from typing import Any, Dict, Optional, Type, TypeVar
-
-from langroid.pydantic_v1 import BaseModel
-
-T = TypeVar("T", bound="GlobalState")
-
-
-class GlobalState(BaseModel):
-    """A base Pydantic model for global states."""
-
-    _instance: Optional["GlobalState"] = None
-
-    @classmethod
-    def get_instance(cls: Type["GlobalState"]) -> "GlobalState":
-        """
-        Get the global instance of the specific subclass.
-
-        Returns:
-            The global instance of the subclass.
-        """
-        if cls._instance is None:
-            cls._instance = cls()
-        return cls._instance
-
-    @classmethod
-    def set_values(cls: Type[T], **kwargs: Dict[str, Any]) -> None:
-        """
-        Set values on the global instance of the specific subclass.
-
-        Args:
-            **kwargs: The fields and their values to set.
-        """
-        instance = cls.get_instance()
-        for key, value in kwargs.items():
-            setattr(instance, key, value)
-
-    @classmethod
-    def get_value(cls: Type[T], name: str) -> Any:
-        """
-        Retrieve the value of a specific field from the global instance.
-
-        Args:
-            name (str): The name of the field to retrieve.
-
-        Returns:
-            str: The value of the specified field.
-        """
-        instance = cls.get_instance()
-        return getattr(instance, name)

langroid/utils/logging.py

@@ -1,135 +0,0 @@
-import logging
-import os.path
-from typing import no_type_check
-
-import colorlog
-from rich.console import Console
-from rich.markup import escape
-
-
-# Define a function to set up the colored logger
-def setup_colored_logging() -> None:
-    # Define the log format with color codes
-    log_format = "%(log_color)s%(asctime)s - %(levelname)s - %(message)s%(reset)s"
-    # Create a color formatter
-    color_formatter = colorlog.ColoredFormatter(
-        log_format,
-        datefmt="%Y-%m-%d %H:%M:%S",
-        reset=True,
-        log_colors={
-            "DEBUG": "cyan",
-            "INFO": "green",
-            "WARNING": "yellow",
-            "ERROR": "red",
-            "CRITICAL": "red,bg_white",
-        },
-    )
-    # Configure the root logger to use the color formatter
-    handler = logging.StreamHandler()
-    handler.setFormatter(color_formatter)
-    logger = logging.getLogger()
-    logger.addHandler(handler)
-    # logger.setLevel(logging.DEBUG)
-
-
-def setup_logger(
-    name: str,
-    level: int = logging.INFO,
-    terminal: bool = False,
-) -> logging.Logger:
-    """
-    Set up a logger of module `name` at a desired level.
-    Args:
-        name: module name
-        level: desired logging level
-    Returns:
-        logger
-    """
-    logger = logging.getLogger(name)
-    logger.setLevel(level)
-    if not logger.hasHandlers() and terminal:
-        handler = logging.StreamHandler()
-        formatter = logging.Formatter(
-            "%(asctime)s - %(name)s - %(levelname)s - %(message)s"
-        )
-        handler.setFormatter(formatter)
-        logger.addHandler(handler)
-    return logger
-
-
-def setup_console_logger(name: str) -> logging.Logger:
-    logger = setup_logger(name)
-    handler = logging.StreamHandler()
-    handler.setLevel(logging.INFO)
-    formatter = logging.Formatter(
-        "%(asctime)s - %(name)s - %(levelname)s - %(message)s"
-    )
-    handler.setFormatter(formatter)
-    logger.addHandler(handler)
-    return logger
-
-
-def setup_file_logger(
-    name: str,
-    filename: str,
-    append: bool = False,
-    log_format: bool = False,
-    propagate: bool = False,
-) -> logging.Logger:
-    os.makedirs(os.path.dirname(filename), exist_ok=True)
-    file_mode = "a" if append else "w"
-    logger = setup_logger(name, terminal=False)
-    handler = logging.FileHandler(filename, mode=file_mode)
-    handler.setLevel(logging.INFO)
-    if log_format:
-        formatter = logging.Formatter(
-            "%(asctime)s - %(name)s - %(levelname)s - %(message)s"
-        )
-    else:
-        formatter = logging.Formatter("%(message)s")
-    handler.setFormatter(formatter)
-    logger.addHandler(handler)
-    logger.propagate = propagate
-    return logger
-
-
-def setup_loggers_for_package(package_name: str, level: int) -> None:
-    """
-    Set up loggers for all modules in a package.
-    This ensures that log-levels of modules outside the package are not affected.
-    Args:
-        package_name: main package name
-        level: desired logging level
-    Returns:
-    """
-    import importlib
-    import pkgutil
-
-    package = importlib.import_module(package_name)
-    for _, module_name, _ in pkgutil.walk_packages(
-        package.__path__, package.__name__ + "."
-    ):
-        module = importlib.import_module(module_name)
-        setup_logger(module.__name__, level)
-
-
-class RichFileLogger:
-    def __init__(self, log_file: str, append: bool = False, color: bool = True):
-        os.makedirs(os.path.dirname(log_file), exist_ok=True)
-        self.log_file = log_file
-        if not append:
-            if os.path.exists(self.log_file):
-                os.remove(self.log_file)
-        self.file = None
-        self.console = None
-        self.append = append
-        self.color = color
-
-    @no_type_check
-    def log(self, message: str) -> None:
-        with open(self.log_file, "a") as f:
-            if self.color:
-                console = Console(file=f, force_terminal=True, width=200)
-                console.print(escape(message))
-            else:
-                print(message, file=f)

langroid/utils/object_registry.py

@@ -1,66 +0,0 @@
-import time
-from typing import TYPE_CHECKING, Dict, Optional, TypeAlias, TypeVar
-from uuid import uuid4
-
-from langroid.pydantic_v1 import BaseModel
-
-if TYPE_CHECKING:
-    from langroid.agent.base import Agent
-    from langroid.agent.chat_agent import ChatAgent
-    from langroid.agent.chat_document import ChatDocument
-
-    # any derivative of BaseModel that has an id() method or an id attribute
-    ObjWithId: TypeAlias = ChatDocument | ChatAgent | Agent
-else:
-    ObjWithId = BaseModel
-
-# Define a type variable that can be any subclass of BaseModel
-T = TypeVar("T", bound=BaseModel)
-
-
-class ObjectRegistry:
-    """A global registry to hold id -> object mappings."""
-
-    registry: Dict[str, ObjWithId] = {}
-
-    @classmethod
-    def add(cls, obj: ObjWithId) -> str:
-        """Adds an object to the registry, returning the object's ID."""
-        object_id = obj.id() if callable(obj.id) else obj.id
-        cls.registry[object_id] = obj
-        return object_id
-
-    @classmethod
-    def get(cls, obj_id: str) -> Optional[ObjWithId]:
-        """Retrieves an object by ID if it still exists."""
-        return cls.registry.get(obj_id)
-
-    @classmethod
-    def register_object(cls, obj: ObjWithId) -> str:
-        """Registers an object in the registry, returning the object's ID."""
-        return cls.add(obj)
-
-    @classmethod
-    def remove(cls, obj_id: str) -> None:
-        """Removes an object from the registry."""
-        if obj_id in cls.registry:
-            del cls.registry[obj_id]
-
-    @classmethod
-    def cleanup(cls) -> None:
-        """Cleans up the registry by removing entries where the object is None."""
-        to_remove = [key for key, value in cls.registry.items() if value is None]
-        for key in to_remove:
-            del cls.registry[key]
-
-    @staticmethod
-    def new_id() -> str:
-        """Generates a new unique ID."""
-        return str(uuid4())
-
-
-def scheduled_cleanup(interval: int = 600) -> None:
-    """Periodically cleans up the global registry every 'interval' seconds."""
-    while True:
-        ObjectRegistry.cleanup()
-        time.sleep(interval)

langroid/utils/output/__init__.py

@@ -1,20 +0,0 @@
-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/citations.py

@@ -1,41 +0,0 @@
-def extract_markdown_references(md_string: str) -> list[int]:
-    """
-    Extracts markdown references (e.g., [^1], [^2]) from a string and returns
-    them as a sorted list of integers.
-
-    Args:
-        md_string (str): The markdown string containing references.
-
-    Returns:
-        list[int]: A sorted list of unique integers from the markdown references.
-    """
-    import re
-
-    # Regex to find all occurrences of [^<number>]
-    matches = re.findall(r"\[\^(\d+)\]", md_string)
-    # Convert matches to integers, remove duplicates with set, and sort
-    return sorted(set(int(match) for match in matches))
-
-
-def format_footnote_text(content: str, width: int = 80) -> str:
-    """
-    Formats the content part of a footnote (i.e. not the first line that
-    appears right after the reference [^4])
-    It wraps the text so that no line is longer than the specified width and indents
-    lines as necessary for markdown footnotes.
-
-    Args:
-        content (str): The text of the footnote to be formatted.
-        width (int): Maximum width of the text lines.
-
-    Returns:
-        str: Properly formatted markdown footnote text.
-    """
-    import textwrap
-
-    # Wrap the text to the specified width
-    wrapped_lines = textwrap.wrap(content, width)
-    if len(wrapped_lines) == 0:
-        return ""
-    indent = "    "  # Indentation for markdown footnotes
-    return indent + ("\n" + indent).join(wrapped_lines)

langroid/utils/output/printing.py

@@ -1,99 +0,0 @@
-import logging
-import sys
-from contextlib import contextmanager
-from typing import Any, Iterator, Optional, Type
-
-from rich import print as rprint
-from rich.text import Text
-
-from langroid.utils.configuration import settings
-from langroid.utils.constants import Colors
-
-
-def shorten_text(text: str, chars: int = 40) -> str:
-    text = " ".join(text.split())
-    return text[:chars] + "..." + text[-chars:] if len(text) > 2 * chars else text
-
-
-def print_long_text(
-    color: str, style: str, preamble: str, text: str, chars: Optional[int] = None
-) -> None:
-    if chars is not None:
-        text = " ".join(text.split())
-        text = text[:chars] + "..." + text[-chars:] if len(text) > 2 * chars else text
-    styled_text = Text(text, style=style)
-    rprint(f"[{color}]{preamble} {styled_text}")
-
-
-def show_if_debug(
-    text: str,
-    preamble: str,
-    chars: Optional[int] = None,
-    color: str = "red",
-    style: str = "italic",
-) -> None:
-    if settings.debug:
-        print_long_text(color, style, preamble, text, chars)
-
-
-class PrintColored:
-    """Context to temporarily print in a desired color"""
-
-    def __init__(self, color: str):
-        self.color = color
-
-    def __enter__(self) -> None:
-        sys.stdout.write(self.color)
-        sys.stdout.flush()
-
-    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: Optional[Type[BaseException]],
-        exc_value: Optional[BaseException],
-        traceback: Any,
-    ) -> None:
-        # Reset the logging level to its original value
-        self.logger.setLevel(self.original_level)

langroid/utils/output/status.py

@@ -1,40 +0,0 @@
-import logging
-from contextlib import AbstractContextManager, ExitStack
-from typing import Any
-
-from rich.console import Console
-from rich.errors import LiveError
-
-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()
-    logged = False
-    if settings.quiet and log_if_quiet:
-        logged = True
-        logger.info(msg)
-
-    if not settings.quiet:
-        try:
-            stack.enter_context(console.status(msg))
-        except LiveError:
-            if not logged:
-                logger.info(msg)
-
-    # When using rich spinner, we enforce quiet mode
-    # (since output will be messy otherwise);
-    # We make an exception to this when debug is enabled.
-    stack.enter_context(quiet_mode(not settings.debug))
-
-    return stack