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

lionagi/libs/func/lcall.py

@@ -1,57 +0,0 @@
-from collections.abc import Callable
-from typing import Any, TypeVar
-
-from ..parse import to_list
-
-T = TypeVar("T")
-
-
-def lcall(
-    input_: list[Any],
-    func: Callable[..., T],
-    /,
-    *,
-    flatten: bool = False,
-    dropna: bool = False,
-    unique: bool = False,
-    **kwargs,
-) -> list[Any]:
-    """Apply a function to each element of a list synchronously.
-
-    Args:
-        input_: List of inputs to be processed.
-        func: Function to apply to each input element.
-        flatten: If True, flatten the resulting list.
-        dropna: If True, remove None values from the result.
-        unique: If True, return only unique values (requires flatten=True).
-        **kwargs: Additional keyword arguments passed to func.
-
-    Returns:
-        list[Any]: List of results after applying func to each input element.
-
-    Raises:
-        ValueError: If more than one function is provided.
-
-    Examples:
-        >>> lcall([1, 2, 3], lambda x: x * 2)
-        [2, 4, 6]
-        >>> lcall([[1, 2], [3, 4]], sum, flatten=True)
-        [3, 7]
-        >>> lcall([1, 2, 2, 3], lambda x: x, unique=True, flatten=True)
-        [1, 2, 3]
-
-    Note:
-        The function uses to_list internally, which allows for flexible input
-        types beyond just lists.
-    """
-    lst = to_list(input_)
-    if len(to_list(func, flatten=True, dropna=True)) != 1:
-        raise ValueError(
-            "There must be one and only one function for list calling."
-        )
-    return to_list(
-        [func(i, **kwargs) for i in lst],
-        flatten=flatten,
-        dropna=dropna,
-        unique=unique,
-    )

lionagi/libs/func/params.py

@@ -1,64 +0,0 @@
-"""Parameter models for function execution configurations.
-
-This module defines Pydantic models that specify parameters for various function
-execution patterns including timed calls and retry logic.
-"""
-
-from collections.abc import Callable
-
-from pydantic import BaseModel, Field
-
-from lionagi.libs.constants import UNDEFINED, UndefinedType
-
-
-class TimedCallParams(BaseModel):
-
-    initial_delay: int = Field(
-        default=0,
-        ge=0,
-        description="Delay in seconds before function execution",
-    )
-    retry_default: str | UndefinedType = Field(
-        default=UNDEFINED,
-        description="Value to return if an error occurs and suppress_err is True",
-    )
-    retry_timeout: int | None = Field(
-        default=None,
-        ge=0,
-        description="Timeout in seconds for function execution. None means no timeout",
-    )
-    retry_timing: bool = Field(
-        default=False,
-        description="If True, return execution duration along with result",
-    )
-    error_msg: str | None = Field(
-        default=None, description="Custom error message prefix for exceptions"
-    )
-    error_map: dict[type[Exception], Callable[[Exception], None]] | None = (
-        Field(
-            default=None,
-            description="Dictionary mapping exception types to error handler functions",
-        )
-    )
-
-
-class RetryCallParams(TimedCallParams):
-
-    num_retries: int = Field(
-        default=0,
-        ge=0,
-        description="Number of retry attempts after initial failure",
-    )
-    retry_delay: int = Field(
-        default=0,
-        ge=0,
-        description="Base delay in seconds between retry attempts",
-    )
-    backoff_factor: int = Field(
-        default=1,
-        ge=1,
-        description="Factor to multiply retry_delay by after each attempt",
-    )
-    verbose_retry: bool = Field(
-        default=False, description="If True, print retry attempt messages"
-    )

lionagi/libs/func/throttle.py

@@ -1,119 +0,0 @@
-"""
-Copyright 2024 HaiyangLi
-
-   Licensed under the Apache License, Version 2.0 (the "License");
-   you may not use this file except in compliance with the License.
-   You may obtain a copy of the License at
-
-       http://www.apache.org/licenses/LICENSE-2.0
-
-   Unless required by applicable law or agreed to in writing, software
-   distributed under the License is distributed on an "AS IS" BASIS,
-   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-   See the License for the specific language governing permissions and
-   limitations under the License.
-"""
-
-import asyncio
-import functools
-import time
-from collections.abc import Callable
-from typing import Any, TypeVar
-
-from ..utils import time as _t
-from .utils import force_async, is_coroutine_func
-
-T = TypeVar("T")
-
-
-class Throttle:
-    """
-    Provide a throttling mechanism for function calls.
-
-    When used as a decorator, it ensures that the decorated function can only
-    be called once per specified period. Subsequent calls within this period
-    are delayed to enforce this constraint.
-
-    Attributes:
-        period: The minimum time period (in seconds) between successive calls.
-    """
-
-    def __init__(self, period: float) -> None:
-        """
-        Initialize a new instance of Throttle.
-
-        Args:
-            period: The minimum time period (in seconds) between
-                successive calls.
-        """
-        self.period = period
-        self.last_called = 0
-
-    def __call__(self, func: Callable[..., T]) -> Callable[..., T]:
-        """
-        Decorate a synchronous function with the throttling mechanism.
-
-        Args:
-            func: The synchronous function to be throttled.
-
-        Returns:
-            The throttled synchronous function.
-        """
-
-        @functools.wraps(func)
-        def wrapper(*args, **kwargs) -> Any:
-            elapsed = _t() - self.last_called
-            if elapsed < self.period:
-                time.sleep(self.period - elapsed)
-            self.last_called = _t()
-            return func(*args, **kwargs)
-
-        return wrapper
-
-    def __call_async__(
-        self, func: Callable[..., Callable[..., T]]
-    ) -> Callable[..., Callable[..., T]]:
-        """
-        Decorate an asynchronous function with the throttling mechanism.
-
-        Args:
-            func: The asynchronous function to be throttled.
-
-        Returns:
-            The throttled asynchronous function.
-        """
-
-        @functools.wraps(func)
-        async def wrapper(*args, **kwargs) -> Any:
-            elapsed = _t() - self.last_called
-            if elapsed < self.period:
-                await asyncio.sleep(self.period - elapsed)
-            self.last_called = _t()
-            return await func(*args, **kwargs)
-
-        return wrapper
-
-
-def throttle(
-    func: Callable[..., T], period: float
-) -> Callable[..., Callable[..., T]]:
-    """
-    Throttle function execution to limit the rate of calls.
-
-    Args:
-        func: The function to throttle.
-        period: The minimum time interval between consecutive calls.
-
-    Returns:
-        The throttled function.
-    """
-    if not is_coroutine_func(func):
-        func = force_async(func)
-    throttle_instance = Throttle(period)
-
-    @functools.wraps(func)
-    async def wrapper(*args, **kwargs):
-        await throttle_instance(func)(*args, **kwargs)
-        return await func(*args, **kwargs)
-
-    return wrapper

lionagi/libs/func/types.py

@@ -1,39 +0,0 @@
-from .async_calls.alcall import alcall
-from .async_calls.bcall import bcall
-from .async_calls.mcall import mcall
-from .async_calls.pcall import pcall
-from .async_calls.rcall import rcall
-from .async_calls.tcall import tcall
-from .async_calls.ucall import ucall
-from .decorators import CallDecorator
-from .lcall import lcall
-from .throttle import Throttle, throttle
-from .utils import (
-    custom_error_handler,
-    force_async,
-    is_coroutine_func,
-    max_concurrent,
-)
-
-__all__ = [
-    # Async calls
-    "bcall",
-    "alcall",
-    "mcall",
-    "pcall",
-    "rcall",
-    "tcall",
-    "ucall",
-    # List operations
-    "lcall",
-    # Decorators
-    "CallDecorator",
-    # Throttling
-    "Throttle",
-    "throttle",
-    # Utilities
-    "force_async",
-    "is_coroutine_func",
-    "custom_error_handler",
-    "max_concurrent",
-]

lionagi/libs/func/utils.py

@@ -1,96 +0,0 @@
-"""
-Copyright 2024 HaiyangLi
-
-   Licensed under the Apache License, Version 2.0 (the "License");
-   you may not use this file except in compliance with the License.
-   You may obtain a copy of the License at
-
-       http://www.apache.org/licenses/LICENSE-2.0
-
-   Unless required by applicable law or agreed to in writing, software
-   distributed under the License is distributed on an "AS IS" BASIS,
-   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-   See the License for the specific language governing permissions and
-   limitations under the License.
-"""
-
-import asyncio
-import functools
-import logging
-from collections.abc import Callable
-from concurrent.futures import ThreadPoolExecutor
-from functools import lru_cache, wraps
-from typing import Any, TypeVar
-
-T = TypeVar("T")
-
-
-def force_async(fn: Callable[..., T]) -> Callable[..., Callable[..., T]]:
-    """
-    Convert a synchronous function to an asynchronous function
-    using a thread pool.
-
-    Args:
-        fn: The synchronous function to convert.
-
-    Returns:
-        The asynchronous version of the function.
-    """
-    pool = ThreadPoolExecutor()
-
-    @wraps(fn)
-    def wrapper(*args, **kwargs):
-        future = pool.submit(fn, *args, **kwargs)
-        return asyncio.wrap_future(future)  # Make it awaitable
-
-    return wrapper
-
-
-@lru_cache(maxsize=None)
-def is_coroutine_func(func: Callable[..., Any]) -> bool:
-    """
-    Check if a function is a coroutine function.
-
-    Args:
-        func: The function to check.
-
-    Returns:
-        True if the function is a coroutine function, False otherwise.
-    """
-    return asyncio.iscoroutinefunction(func)
-
-
-async def custom_error_handler(
-    error: Exception, error_map: dict[type, Callable[[Exception], None]]
-) -> None:
-    for error_type, handler in error_map.items():
-        if isinstance(error, error_type):
-            if is_coroutine_func(handler):
-                return await handler(error)
-            return handler(error)
-    logging.error(f"Unhandled error: {error}")
-
-
-def max_concurrent(
-    func: Callable[..., T], limit: int
-) -> Callable[..., Callable[..., T]]:
-    """
-    Limit the concurrency of function execution using a semaphore.
-
-    Args:
-        func: The function to limit concurrency for.
-        limit: The maximum number of concurrent executions.
-
-    Returns:
-        The function wrapped with concurrency control.
-    """
-    if not is_coroutine_func(func):
-        func = force_async(func)
-    semaphore = asyncio.Semaphore(limit)
-
-    @wraps(func)
-    async def wrapper(*args, **kwargs):
-        async with semaphore:
-            return await func(*args, **kwargs)
-
-    return wrapper

lionagi/libs/package/types.py

@@ -1,26 +0,0 @@
-from .imports import (
-    check_import,
-    import_module,
-    install_import,
-    is_import_installed,
-)
-from .management import (
-    list_installed_packages,
-    uninstall_package,
-    update_package,
-)
-from .system import get_cpu_architecture
-
-__all__ = [
-    # Import handling
-    "check_import",
-    "import_module",
-    "install_import",
-    "is_import_installed",
-    # Package management
-    "list_installed_packages",
-    "uninstall_package",
-    "update_package",
-    # System utilities
-    "get_cpu_architecture",
-]

lionagi/libs/parse/__init__.py

@@ -1 +0,0 @@
-from .types import *

lionagi/libs/parse/flatten/__init__.py

@@ -1,9 +0,0 @@
-"""Utilities for flattening nested data structures."""
-
-from .flatten import flatten
-from .params import FlattenParams
-
-__all__ = [
-    "flatten",
-    "FlattenParams",
-]

lionagi/libs/parse/flatten/params.py

@@ -1,52 +0,0 @@
-from typing import Any, Literal
-
-from pydantic import BaseModel, Field, field_validator
-
-
-class FlattenParams(BaseModel):
-    """Parameters for flatten function.
-
-    Attributes:
-        parent_key: Base key for the current recursion level
-        sep: Separator for joining keys
-        coerce_keys: Join keys into strings if True, keep as tuples if False
-        dynamic: Handle sequences (except strings) dynamically if True
-        coerce_sequence: Force sequences to be treated as dicts or lists
-        max_depth: Maximum depth to flatten
-    """
-
-    parent_key: tuple[Any, ...] = Field(
-        default=(),
-        description="Base key for the current recursion level",
-    )
-    sep: str = Field(
-        default="|",
-        description="Separator for joining keys",
-    )
-    coerce_keys: bool = Field(
-        default=True,
-        description="Join keys into strings if True, keep as tuples if False",
-    )
-    dynamic: bool = Field(
-        default=True,
-        description="Handle sequences (except strings) dynamically if True",
-    )
-    coerce_sequence: Literal["dict", "list"] | None = Field(
-        default=None,
-        description="Force sequences to be treated as dicts or lists",
-    )
-    max_depth: int | None = Field(
-        default=None,
-        description="Maximum depth to flatten",
-        ge=0,
-    )
-
-    @field_validator("coerce_sequence")
-    def validate_coerce_sequence(
-        cls, v: Literal["dict", "list"] | None, values: dict[str, Any]
-    ) -> Literal["dict", "list"] | None:
-        if v == "list" and values.get("coerce_keys", True):
-            raise ValueError(
-                "coerce_sequence cannot be 'list' when coerce_keys is True"
-            )
-        return v

lionagi/libs/parse/json/__init__.py

@@ -1,27 +0,0 @@
-"""JSON parsing and manipulation utilities."""
-
-from .as_readable import as_readable, as_readable_json
-from .extract import extract_block, extract_json_blocks
-from .parse import _clean_json_string, fix_json_string, fuzzy_parse_json
-from .schema import (
-    extract_json_schema,
-    json_schema_to_cfg,
-    json_schema_to_regex,
-    print_cfg,
-)
-from .to_json import to_json
-
-__all__ = [
-    "as_readable",
-    "as_readable_json",
-    "extract_block",
-    "extract_json_blocks",
-    "fuzzy_parse_json",
-    "fix_json_string",
-    "_clean_json_string",
-    "extract_json_schema",
-    "json_schema_to_cfg",
-    "json_schema_to_regex",
-    "print_cfg",
-    "to_json",
-]

lionagi/libs/parse/json/extract.py

@@ -1,102 +0,0 @@
-import re
-from collections.abc import Callable
-from typing import Any
-
-from ..type_convert.to_dict import to_dict
-
-
-def extract_json_blocks(
-    str_to_parse: str,
-    suppress: bool = True,
-    fuzzy_parse: bool = True,
-    dropna: bool = True,
-) -> list[dict[str, Any]]:
-    """
-    Extract and parse JSON blocks from the given text.
-
-    This function searches for JSON blocks enclosed in triple backticks
-    within the input text, parses them, and returns a list of parsed
-    dictionaries.
-
-    Args:
-        text: The input text containing JSON blocks.
-        suppress: If True, suppress errors during parsing. Default is True.
-        fuzzy_parse: If True, use fuzzy parsing for JSON. Default is True.
-        dropna: If True, remove None values from the result. Default is True.
-
-    Returns:
-        A list of parsed JSON blocks as dictionaries.
-
-    Example:
-        >>> text = "```json\n{\"key\": \"value\"}\n```"
-        >>> extract_json_blocks(text)
-        [{'key': 'value'}]
-    """
-    pattern = r"```json\s*(.*?)\s*```"
-    matches = re.findall(pattern, str_to_parse, re.DOTALL)
-
-    json_blocks = [
-        to_dict(match, fuzzy_parse=fuzzy_parse, suppress=suppress)
-        for match in matches
-    ]
-
-    return [block for block in json_blocks if block] if dropna else json_blocks
-
-
-def extract_block(
-    str_to_parse: str,
-    language: str = "json",
-    regex_pattern: str | None = None,
-    *,
-    parser: Callable[[str], Any] | None = None,
-    suppress: bool = False,
-) -> dict[str, Any] | None:
-    """
-    Extract and parse a code block from the given string.
-
-    This function searches for a code block in the input string using a
-    regular expression pattern, extracts it, and parses it using the
-    provided parser function.
-
-    Args:
-        str_to_parse: The input string containing the code block.
-        language: The language of the code block. Default is "json".
-        regex_pattern: Custom regex pattern to find the code block.
-            If provided, overrides the default pattern.
-        parser: A function to parse the extracted code string.
-            If not provided, uses `to_dict` with fuzzy parsing.
-        suppress: If True, return None instead of raising an error
-            when no code block is found. Default is False.
-
-    Returns:
-        The parsed content of the code block as a dictionary,
-        or None if no block is found and suppress is True.
-
-    Raises:
-        ValueError: If no code block is found and suppress is False.
-
-    Example:
-        >>> text = "```json\n{\"key\": \"value\"}\n```"
-        >>> extract_block(text)
-        {'key': 'value'}
-    """
-    if not regex_pattern:
-        regex_pattern = rf"```{language}\n?(.*?)\n?```"
-    if not language:
-        regex_pattern = r"```\n?(.*?)\n?```"
-
-    match = re.search(regex_pattern, str_to_parse, re.DOTALL)
-
-    if match:
-        code_str = match.group(1).strip()
-    elif str_to_parse.startswith(f"```{language}\n") and str_to_parse.endswith(
-        "\n```"
-    ):
-        code_str = str_to_parse[4 + len(language) : -4].strip()
-    elif suppress:
-        return None
-    else:
-        raise ValueError("No code block found in the input string.")
-
-    parser = parser or (lambda x: to_dict(x, fuzzy_parse=True, suppress=True))
-    return parser(code_str)