lionagi 0.5.5__py3-none-any.whl → 0.6.1__py3-none-any.whl

lionagi/integrations/pydantic_/break_down_annotation.py

@@ -1,81 +0,0 @@
-# Copyright (c) 2023 - 2024, HaiyangLi <quantocean.li at gmail dot com>
-#
-# SPDX-License-Identifier: Apache-2.0
-
-from inspect import isclass
-from typing import Any, TypeVar, get_args, get_origin
-
-from pydantic import BaseModel
-
-T = TypeVar("T", bound=BaseModel)
-
-
-def break_down_pydantic_annotation(
-    model: type[T], max_depth: int | None = None, current_depth: int = 0
-) -> dict[str, Any]:
-    """
-    Break down the type annotations of a Pydantic model into a dictionary.
-
-    This function recursively processes Pydantic models, converting their
-    field annotations into a dictionary structure. It handles nested models
-    and lists of models.
-
-    Args:
-        model: The Pydantic model class to break down.
-        max_depth: Maximum depth for recursion. None for no limit.
-        current_depth: Current recursion depth (used internally).
-
-    Returns:
-        A dictionary representing the structure of the model's annotations.
-
-    Raises:
-        TypeError: If the input is not a Pydantic model.
-        RecursionError: If max recursion depth is reached.
-
-    Example:
-        >>> from pydantic import BaseModel
-        >>> class SubModel(BaseModel):
-        ...     field1: int
-        ...     field2: str
-        >>> class MainModel(BaseModel):
-        ...     sub: SubModel
-        ...     items: list[SubModel]
-        >>> result = break_down_annotation(MainModel)
-        >>> print(result)
-        {
-            'sub': {'field1': <class 'int'>, 'field2': <class 'str'>},
-            'items': [{'field1': <class 'int'>, 'field2': <class 'str'>}]
-        }
-    """
-
-    if not _is_pydantic_model(model):
-        raise TypeError("Input must be a Pydantic model")
-
-    if max_depth is not None and current_depth >= max_depth:
-        raise RecursionError("Maximum recursion depth reached")
-
-    out: dict[str, Any] = {}
-    for k, v in model.__annotations__.items():
-        origin = get_origin(v)
-        if _is_pydantic_model(v):
-            out[k] = break_down_pydantic_annotation(
-                v, max_depth, current_depth + 1
-            )
-        elif origin is list:
-            args = get_args(v)
-            if args and _is_pydantic_model(args[0]):
-                out[k] = [
-                    break_down_pydantic_annotation(
-                        args[0], max_depth, current_depth + 1
-                    )
-                ]
-            else:
-                out[k] = [args[0] if args else Any]
-        else:
-            out[k] = v
-
-    return out
-
-
-def _is_pydantic_model(x: Any) -> bool:
-    return isclass(x) and issubclass(x, BaseModel)

lionagi/integrations/pydantic_/new_model.py

@@ -1,208 +0,0 @@
-# Copyright (c) 2023 - 2024, HaiyangLi <quantocean.li at gmail dot com>
-#
-# SPDX-License-Identifier: Apache-2.0
-
-
-from collections.abc import Callable
-from typing import Any, Literal, TypeVar, overload
-
-from pydantic import (
-    BaseModel,
-    ConfigDict,
-    Field,
-    create_model,
-    field_validator,
-)
-from pydantic.fields import FieldInfo
-
-T = TypeVar("T", bound=BaseModel)
-
-
-@overload
-def new_model(
-    base: type[T],
-    *,
-    model_name: str | None = None,
-    use_all_fields: Literal[False] = False,
-    config_dict: ConfigDict | None = None,
-    doc: str | None = None,
-    validators: dict[str, Callable] | None = None,
-    use_base_kwargs: bool = False,
-    inherit_base: bool = False,
-    extra_fields: dict[str, Any] | None = None,
-    field_descriptions: dict[str, str] | None = None,
-    exclude_fields: list[str] | None = None,
-    frozen: bool = False,
-) -> type[BaseModel]: ...
-
-
-@overload
-def new_model(
-    base: type[T],
-    *,
-    model_name: str | None = None,
-    use_all_fields: Literal[True],
-    config_dict: ConfigDict | None = None,
-    doc: str | None = None,
-    validators: dict[str, Callable] | None = None,
-    use_base_kwargs: bool = False,
-    inherit_base: bool = False,
-    extra_fields: dict[str, Any] | None = None,
-    field_descriptions: dict[str, str] | None = None,
-    exclude_fields: list[str] | None = None,
-    frozen: bool = False,
-) -> type[BaseModel]: ...
-
-
-def new_model(
-    base: type[T] | T,
-    *,
-    model_name: str | None = None,
-    use_all_fields: bool = False,
-    config_dict: ConfigDict | None = None,
-    doc: str | None = None,
-    validators: dict[str, Callable] | None = None,
-    use_base_kwargs: bool = False,
-    inherit_base: bool = False,
-    extra_fields: dict[str, Any] | None = None,
-    field_descriptions: dict[str, str] | None = None,
-    exclude_fields: list[str] | None = None,
-    frozen: bool = False,
-) -> type[BaseModel]:
-    """
-    Create a new Pydantic model based on an existing model with additional customizations.
-
-    This function allows you to create a new Pydantic model by extending or modifying
-    an existing model. It provides various options to customize the new model's fields,
-    configuration, and behavior.
-
-    Args:
-        base: The base model or instance to derive the new model from.
-        model_name: Name for the new model. Defaults to f"Dynamic{base.__name__}".
-        use_all_fields: If True, includes fields from base.all_fields (if available).
-        config_dict: Additional configuration options for the model.
-        doc: Docstring for the new model.
-        validators: Dictionary of field validators to add to the model.
-        use_base_kwargs: If True, includes class kwargs from the base model.
-        inherit_base: If True, sets the base model as the parent class.
-        extra_fields: Additional fields to add to the new model.
-        field_descriptions: Dictionary of field descriptions to add or update.
-        exclude_fields: List of field names to exclude from the new model.
-        frozen: If True, creates an immutable model.
-
-    Returns:
-        A new Pydantic model class.
-
-    Raises:
-        ValueError: If invalid arguments are provided.
-
-    Examples:
-        >>> class BaseUser(BaseModel):
-        ...     name: str
-        ...     age: int
-        >>> NewUser = new_model(
-        ...     BaseUser,
-        ...     model_name="ExtendedUser",
-        ...     extra_fields={"email": (str, ...)},
-        ...     field_descriptions={"name": "Full name of the user"},
-        ...     frozen=True
-        ... )
-        >>> print(NewUser.model_fields.keys())
-        dict_keys(['name', 'age', 'email'])
-
-        >>> class AdvancedUser(BaseModel):
-        ...     details: dict[str, Any]
-        ...
-        ...     class Config:
-        ...         extra = 'allow'
-        >>> EnhancedUser = new_model(
-        ...     AdvancedUser,
-        ...     use_all_fields=True,
-        ...     inherit_base=True,
-        ...     config_dict={'json_schema_extra': {'examples': [{'details': {'key': 'value'}}]}}
-        ... )
-        >>> print(EnhancedUser.model_config)
-        {'extra': 'allow', 'json_schema_extra': {'examples': [{'details': {'key': 'value'}}]}}
-    """
-    if not isinstance(base, type) or not issubclass(base, BaseModel):
-        if not isinstance(base, BaseModel):
-            raise ValueError("base must be a Pydantic model class or instance")
-        base = type(base)
-
-    # Prepare fields
-    fields = {}
-    if use_all_fields and hasattr(base, "all_fields"):
-        fields.update(base.all_fields)
-    else:
-        fields.update(base.model_fields)
-
-    # Exclude fields
-    if exclude_fields:
-        for field in exclude_fields:
-            fields.pop(field, None)
-
-    # Add extra fields
-    if extra_fields:
-        fields.update(extra_fields)
-
-    # Update field descriptions
-    if field_descriptions:
-        for field_name, description in field_descriptions.items():
-            if field_name in fields:
-                field_info = fields[field_name]
-                if isinstance(field_info, tuple):
-                    fields[field_name] = (
-                        field_info[0],
-                        Field(..., description=description),
-                    )
-                elif isinstance(field_info, FieldInfo):
-                    fields[field_name] = field_info.model_copy(
-                        update={"description": description}
-                    )
-
-    # Prepare config
-    config = ConfigDict()
-    if config_dict:
-        config.update(config_dict)
-    if frozen:
-        config["frozen"] = True
-
-    # Prepare class attributes
-    class_kwargs = {}
-    if use_base_kwargs:
-        class_kwargs.update(
-            {
-                k: getattr(base, k)
-                for k in base.__dict__
-                if not k.startswith("__")
-            }
-        )
-
-    # Create the model
-    new_model_name = model_name or f"Dynamic{base.__name__}"
-    model: type[BaseModel] = create_model(
-        new_model_name, __base__=base if inherit_base else BaseModel, **fields
-    )
-
-    # Set config
-    if config:
-        model.model_config = config
-
-    # Set docstring
-    if doc:
-        model.__doc__ = doc
-
-    # Add validators
-    if validators:
-        for field, validator_func in validators.items():
-            setattr(
-                model,
-                f"validate_{field}",
-                field_validator(field)(validator_func),
-            )
-
-    # Add class attributes
-    for key, value in class_kwargs.items():
-        setattr(model, key, value)
-
-    return model

lionagi/libs/constants.py

@@ -1,98 +0,0 @@
-from typing import Any, Final, Literal, TypedDict, TypeVar, Union
-
-
-class UndefinedType:
-    def __init__(self) -> None:
-        self.undefined = True
-
-    def __bool__(self) -> Literal[False]:
-        return False
-
-    def __deepcopy__(self, memo):
-        # Ensure UNDEFINED is universal
-        return self
-
-    def __repr__(self) -> Literal["UNDEFINED"]:
-        return "UNDEFINED"
-
-    __slots__ = ["undefined"]
-
-
-UNDEFINED = UndefinedType()
-
-# Type definitions
-NUM_TYPE_LITERAL = Literal["int", "float", "complex"]
-NUM_TYPES = Union[type[int], type[float], type[complex], NUM_TYPE_LITERAL]
-NumericType = TypeVar("NumericType", int, float, complex)
-
-# Type mapping
-TYPE_MAP = {"int": int, "float": float, "complex": complex}
-
-# Regex patterns for different numeric formats
-PATTERNS = {
-    "scientific": r"[-+]?(?:\d*\.)?\d+[eE][-+]?\d+",
-    "complex_sci": r"[-+]?(?:\d*\.)?\d+(?:[eE][-+]?\d+)?[-+](?:\d*\.)?\d+(?:[eE][-+]?\d+)?[jJ]",
-    "complex": r"[-+]?(?:\d*\.)?\d+[-+](?:\d*\.)?\d+[jJ]",
-    "pure_imaginary": r"[-+]?(?:\d*\.)?\d*[jJ]",
-    "percentage": r"[-+]?(?:\d*\.)?\d+%",
-    "fraction": r"[-+]?\d+/\d+",
-    "decimal": r"[-+]?(?:\d*\.)?\d+",
-    "special": r"[-+]?(?:inf|infinity|nan)",
-}
-
-
-md_json_char_map = {"'": '\\"', "\n": "\\n", "\r": "\\r", "\t": "\\t"}
-
-py_json_msp = {
-    "str": "string",
-    "int": "number",
-    "float": "number",
-    "list": "array",
-    "tuple": "array",
-    "bool": "boolean",
-    "dict": "object",
-}
-
-
-# Define constants for valid boolean string representations
-TRUE_VALUES: Final[frozenset[str]] = frozenset(
-    [
-        "true",
-        "1",
-        "yes",
-        "y",
-        "on",
-        "correct",
-        "t",
-        "enabled",
-        "enable",
-        "active",
-        "activated",
-    ]
-)
-
-FALSE_VALUES: Final[frozenset[str]] = frozenset(
-    [
-        "false",
-        "0",
-        "no",
-        "n",
-        "off",
-        "incorrect",
-        "f",
-        "disabled",
-        "disable",
-        "inactive",
-        "deactivated",
-        "none",
-        "null",
-        "n/a",
-        "na",
-    ]
-)
-
-
-class KeysDict(TypedDict, total=False):
-    """TypedDict for keys dictionary."""
-
-    key: Any  # Represents any key-type pair

lionagi/libs/file/path.py

@@ -1,301 +0,0 @@
-import logging
-import re
-import sys
-from datetime import datetime
-from pathlib import Path
-from typing import Any
-
-from ..utils import unique_hash
-
-
-def create_path(
-    directory: Path | str,
-    filename: str,
-    extension: str = None,
-    timestamp: bool = False,
-    dir_exist_ok: bool = True,
-    file_exist_ok: bool = False,
-    time_prefix: bool = False,
-    timestamp_format: str | None = None,
-    random_hash_digits: int = 0,
-) -> Path:
-    """
-    Generate a new file path with optional timestamp and random hash.
-
-    Args:
-        directory: The directory where the file will be created.
-        filename: The base name of the file to create.
-        timestamp: If True, adds a timestamp to the filename.
-        dir_exist_ok: If True, doesn't raise an error if the directory
-            exists.
-        file_exist_ok: If True, allows overwriting of existing files.
-        time_prefix: If True, adds the timestamp as a prefix instead of
-            a suffix.
-        timestamp_format: Custom format for the timestamp.
-        random_hash_digits: Number of digits for the random hash.
-
-    Returns:
-        The full path to the new or existing file.
-
-    Raises:
-        ValueError: If the filename contains illegal characters.
-        FileExistsError: If the file exists and file_exist_ok is False.
-    """
-    if "/" in filename or "\\" in filename:
-        raise ValueError("Filename cannot contain directory separators.")
-    directory = Path(directory)
-
-    name, ext = None, None
-    if "." in filename:
-        name, ext = filename.rsplit(".", 1)
-    else:
-        name = filename
-        ext = extension.strip(".").strip() if extension else None
-
-    if not ext:
-        raise ValueError("No extension provided for filename.")
-
-    ext = f".{ext}" if ext else ""
-
-    if timestamp:
-        timestamp_str = datetime.now().strftime(
-            timestamp_format or "%Y%m%d%H%M%S"
-        )
-        name = (
-            f"{timestamp_str}_{name}"
-            if time_prefix
-            else f"{name}_{timestamp_str}"
-        )
-
-    if random_hash_digits > 0:
-        random_hash = "-" + unique_hash(random_hash_digits)
-        name = f"{name}{random_hash}"
-
-    full_filename = f"{name}{ext}"
-    full_path = directory / full_filename
-
-    if full_path.exists():
-        if file_exist_ok:
-            return full_path
-        raise FileExistsError(
-            f"File {full_path} already exists and file_exist_ok is False."
-        )
-    full_path.parent.mkdir(parents=True, exist_ok=dir_exist_ok)
-    return full_path
-
-
-def is_valid_path(
-    path: str | Path,
-    *,
-    max_length: int | None = None,
-    allow_relative: bool = True,
-    allow_symlinks: bool = True,
-    custom_reserved_names: list[str] | None = None,
-    strict_mode: bool = False,
-) -> bool:
-    """
-    Validates whether the given path is syntactically valid for the current operating system.
-
-    Args:
-        path (Union[str, Path]): The filesystem path to validate.
-        max_length (Optional[int]): Maximum allowed path length. If None, uses OS default.
-        allow_relative (bool): Whether to allow relative paths. Default is True.
-        allow_symlinks (bool): Whether to allow symlinks. Default is True.
-        custom_reserved_names (Optional[List[str]]): Additional reserved names to check.
-        strict_mode (bool): If True, applies stricter validation rules. Default is False.
-
-    Returns:
-        bool: True if the path is valid, False otherwise.
-
-    Raises:
-        ValueError: If the path is invalid, with a detailed explanation.
-    """
-    if isinstance(path, Path):
-        path_str = str(path)
-    elif isinstance(path, str):
-        path_str = path
-    else:
-        raise TypeError("Path must be a string or Path object.")
-
-    if not path_str:
-        raise ValueError("Path cannot be an empty string.")
-
-    issues = []
-    is_windows = sys.platform.startswith("win")
-
-    # Common checks for both Windows and Unix-like systems
-    if "\0" in path_str:
-        issues.append("Path contains null character.")
-
-    if not max_length:
-        max_length = 260 if is_windows else 4096
-    if len(path_str) > max_length:
-        issues.append(
-            f"Path exceeds the maximum length of {max_length} characters."
-        )
-
-    if is_windows:
-        # Windows-specific validation
-        invalid_chars = r'<>:"/\\|?*'
-        if re.search(f"[{re.escape(invalid_chars)}]", path_str):
-            issues.append(f"Path contains invalid characters: {invalid_chars}")
-
-        reserved_names = {
-            "CON",
-            "PRN",
-            "AUX",
-            "NUL",
-            "COM1",
-            "COM2",
-            "COM3",
-            "COM4",
-            "COM5",
-            "COM6",
-            "COM7",
-            "COM8",
-            "COM9",
-            "LPT1",
-            "LPT2",
-            "LPT3",
-            "LPT4",
-            "LPT5",
-            "LPT6",
-            "LPT7",
-            "LPT8",
-            "LPT9",
-        }
-        if custom_reserved_names:
-            reserved_names.update(custom_reserved_names)
-
-        path = Path(path_str)
-        for part in path.parts:
-            name = part.upper().rstrip(". ")
-            if name in reserved_names:
-                issues.append(f"Path contains a reserved name: '{part}'")
-
-        if path_str.endswith(" ") or path_str.endswith("."):
-            issues.append(
-                "Path cannot end with a space or a period on Windows."
-            )
-
-        if strict_mode:
-            if not path_str.startswith("\\\\?\\") and len(path_str) > 260:
-                issues.append(
-                    "Path exceeds 260 characters without long path prefix."
-                )
-
-    else:
-        # Unix-like systems validation
-        if strict_mode:
-            if re.search(r"//+", path_str):
-                issues.append("Path contains consecutive slashes.")
-
-        if not allow_relative and not path_str.startswith("/"):
-            issues.append("Relative paths are not allowed.")
-
-    # Common additional checks
-    if not allow_symlinks and Path(path_str).is_symlink():
-        issues.append("Symlinks are not allowed.")
-
-    if strict_mode:
-        if re.search(r"\s", path_str):
-            issues.append("Path contains whitespace characters.")
-
-    if issues:
-        raise ValueError("Invalid path: " + "; ".join(issues))
-
-    return True
-
-
-def split_path(path: Path | str) -> tuple[Path, str]:
-    """
-    Split a path into its directory and filename components.
-
-    Args:
-        path: The path to split.
-
-    Returns:
-        A tuple containing the directory and filename.
-    """
-    path = Path(path)
-    return path.parent, path.name
-
-
-def _get_path_kwargs(
-    persist_path: str | Path, postfix: str, **path_kwargs: Any
-) -> dict[str, Any]:
-    """
-    Generate keyword arguments for path creation.
-
-    Args:
-        persist_path: The base path to use.
-        postfix: The file extension to use.
-        **path_kwargs: Additional keyword arguments to override defaults.
-
-    Returns:
-        A dictionary of keyword arguments for path creation.
-    """
-    persist_path = Path(persist_path)
-    postfix = f".{postfix.strip('.')}"
-
-    if persist_path.suffix != postfix:
-        dirname = persist_path
-        filename = f"new_file{postfix}"
-    else:
-        dirname, filename = persist_path.parent, persist_path.name
-
-    return {
-        "timestamp": path_kwargs.get("timestamp", False),
-        "file_exist_ok": path_kwargs.get("file_exist_ok", True),
-        "directory": path_kwargs.get("directory", dirname),
-        "filename": path_kwargs.get("filename", filename),
-    }
-
-
-def clear_path(
-    path: Path | str,
-    /,
-    recursive: bool = False,
-    exclude: list[str] | None = None,
-) -> None:
-    """
-    Clear all files and directories in the specified path.
-
-    Args:
-        path: The path to the directory to clear.
-        recursive: If True, clears directories recursively.
-        exclude: A list of string patterns to exclude from deletion.
-
-    Raises:
-        FileNotFoundError: If the specified directory does not exist.
-        PermissionError: If there are insufficient permissions to delete
-            files.
-    """
-    path = Path(path)
-    if not path.exists():
-        raise FileNotFoundError(
-            f"The specified directory {path} does not exist."
-        )
-
-    exclude = exclude or []
-    exclude_pattern = re.compile("|".join(exclude)) if exclude else None
-
-    for file_path in path.iterdir():
-        if exclude_pattern and exclude_pattern.search(file_path.name):
-            logging.info(f"Excluded from deletion: {file_path}")
-            continue
-
-        try:
-            if file_path.is_dir():
-                if recursive:
-                    clear_path(file_path, recursive=True, exclude=exclude)
-                    file_path.rmdir()
-                else:
-                    continue
-            else:
-                file_path.unlink()
-            logging.info(f"Successfully deleted {file_path}")
-        except PermissionError as e:
-            logging.error(f"Permission denied when deleting {file_path}: {e}")
-        except Exception as e:
-            logging.error(f"Failed to delete {file_path}: {e}")

lionagi/libs/file/types.py

@@ -1,22 +0,0 @@
-from .chunk import chunk_by_chars, chunk_by_tokens, chunk_content
-from .file_ops import copy_file, get_file_size, list_files, read_file
-from .path import clear_path, create_path, is_valid_path, split_path
-from .process import dir_to_files, file_to_chunks
-from .save import save_to_file
-
-__all__ = [
-    "chunk_by_chars",
-    "chunk_by_tokens",
-    "chunk_content",
-    "clear_path",
-    "copy_file",
-    "create_path",
-    "dir_to_files",
-    "file_to_chunks",
-    "get_file_size",
-    "is_valid_path",
-    "list_files",
-    "read_file",
-    "save_to_file",
-    "split_path",
-]