lionagi 0.5.4__py3-none-any.whl → 0.6.0__py3-none-any.whl

lionagi/libs/func/decorators.py

@@ -1,277 +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
-from collections.abc import Callable, Sequence
-from functools import wraps
-from typing import Any, TypeVar
-
-from ..constants import UNDEFINED
-from .async_calls import rcall, ucall
-from .throttle import Throttle
-from .utils import force_async, is_coroutine_func
-
-T = TypeVar("T")
-F = TypeVar("F", bound=Callable[..., Any])
-
-
-class CallDecorator:
-    """A collection of decorators to enhance function calls."""
-
-    @staticmethod
-    def retry(
-        num_retries: int = 0,
-        initial_delay: float = 0,
-        retry_delay: float = 0,
-        backoff_factor: float = 1,
-        retry_default: Any = UNDEFINED,
-        retry_timeout: float | None = None,
-        retry_timing: bool = False,
-        verbose_retry: bool = True,
-        error_msg: str | None = None,
-        error_map: dict[type, Callable[[Exception], None]] | None = None,
-    ) -> Callable[[F], F]:
-        """Decorator to automatically retry a function call on failure.
-
-        Args:
-            retries: Number of retry attempts.
-            initial_delay: Initial delay before retrying.
-            delay: Delay between retries.
-            backoff_factor: Factor to increase delay after each retry.
-            default: Default value to return on failure.
-            timeout: Timeout for each function call.
-            timing: If True, logs the time taken for each call.
-            verbose: If True, logs the retries.
-            error_msg: Custom error message on failure.
-            error_map: A map of exception types to handler functions.
-
-        Returns:
-            The decorated function.
-        """
-
-        def decorator(func: F) -> F:
-            @wraps(func)
-            async def wrapper(*args, **kwargs) -> Any:
-                return await rcall(
-                    func,
-                    *args,
-                    num_retries=num_retries,
-                    initial_delay=initial_delay,
-                    retry_delay=retry_delay,
-                    backoff_factor=backoff_factor,
-                    retry_default=retry_default,
-                    retry_timeout=retry_timeout,
-                    retry_timing=retry_timing,
-                    verbose_retry=verbose_retry,
-                    error_msg=error_msg,
-                    error_map=error_map,
-                    **kwargs,
-                )
-
-            return wrapper
-
-        return decorator
-
-    @staticmethod
-    def throttle(period: float) -> Callable[[F], F]:
-        """Decorator to limit the execution frequency of a function.
-
-        Args:
-            period: Minimum time in seconds between function calls.
-
-        Returns:
-            The decorated function.
-        """
-
-        def decorator(func: F) -> F:
-            if not is_coroutine_func(func):
-                func = force_async(func)
-            throttle_instance = Throttle(period)
-
-            @wraps(func)
-            async def wrapper(*args, **kwargs):
-                await throttle_instance(func)(*args, **kwargs)
-                return await func(*args, **kwargs)
-
-            return wrapper
-
-        return decorator
-
-    @staticmethod
-    def max_concurrent(limit: int) -> Callable[[F], F]:
-        """Decorator to limit the maximum number of concurrent executions.
-
-        Args:
-            limit: Maximum number of concurrent executions.
-
-        Returns:
-            The decorated function.
-        """
-
-        def decorator(func: F) -> F:
-            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
-
-        return decorator
-
-    @staticmethod
-    def compose(*functions: Callable[[T], T]) -> Callable[[F], F]:
-        """Decorator to compose multiple functions, applying in sequence.
-
-        Args:
-            functions: Functions to apply in sequence.
-
-        Returns:
-            The decorated function.
-        """
-
-        def decorator(func: F) -> F:
-            @wraps(func)
-            async def async_wrapper(*args, **kwargs):
-                value = await ucall(func, *args, **kwargs)
-                for function in functions:
-                    try:
-                        value = await ucall(function, value)
-                    except Exception as e:
-                        raise ValueError(
-                            f"Error in function {function.__name__}: {e}"
-                        )
-                return value
-
-            return async_wrapper
-
-        return decorator
-
-    @staticmethod
-    def pre_post_process(
-        preprocess: Callable[..., Any] | None = None,
-        postprocess: Callable[..., Any] | None = None,
-        preprocess_args: Sequence[Any] = (),
-        preprocess_kwargs: dict[str, Any] = {},
-        postprocess_args: Sequence[Any] = (),
-        postprocess_kwargs: dict[str, Any] = {},
-    ) -> Callable[[F], F]:
-        """Decorator to apply pre-processing and post-processing functions.
-
-        Args:
-            preprocess: Function to apply before the main function.
-            postprocess: Function to apply after the main function.
-            preprocess_args: Arguments for the preprocess function.
-            preprocess_kwargs: Keyword arguments for preprocess function.
-            postprocess_args: Arguments for the postprocess function.
-            postprocess_kwargs: Keyword arguments for postprocess function.
-
-        Returns:
-            The decorated function.
-        """
-
-        def decorator(func: F) -> F:
-            @wraps(func)
-            async def async_wrapper(*args, **kwargs) -> Any:
-                preprocessed_args = (
-                    [
-                        await ucall(
-                            preprocess,
-                            arg,
-                            *preprocess_args,
-                            **preprocess_kwargs,
-                        )
-                        for arg in args
-                    ]
-                    if preprocess
-                    else args
-                )
-                preprocessed_kwargs = (
-                    {
-                        k: await ucall(
-                            preprocess,
-                            v,
-                            *preprocess_args,
-                            **preprocess_kwargs,
-                        )
-                        for k, v in kwargs.items()
-                    }
-                    if preprocess
-                    else kwargs
-                )
-                result = await ucall(
-                    func, *preprocessed_args, **preprocessed_kwargs
-                )
-
-                return (
-                    await ucall(
-                        postprocess,
-                        result,
-                        *postprocess_args,
-                        **postprocess_kwargs,
-                    )
-                    if postprocess
-                    else result
-                )
-
-            return async_wrapper
-
-        return decorator
-
-    @staticmethod
-    def map(function: Callable[[Any], Any]) -> Callable:
-        """Decorator to map a function over async function results.
-
-        Applies a mapping function to each element in the list returned
-        by the decorated function. Useful for post-processing results of
-        asynchronous operations, such as transforming data fetched from
-        an API or processing items in a collection concurrently.
-
-        Args:
-            function: Mapping function to apply to each element.
-
-        Returns:
-            Decorated async function with transformed results.
-
-        Examples:
-            >>> @CallDecorator.map(lambda x: x.upper())
-            ... async def get_names():
-            ...     return ["alice", "bob", "charlie"]
-            ... # `get_names` now returns ["ALICE", "BOB", "CHARLIE"]
-        """
-
-        def decorator(func: Callable[..., list[Any]]) -> Callable:
-            if is_coroutine_func(func):
-
-                @wraps(func)
-                async def async_wrapper(*args, **kwargs) -> list[Any]:
-                    values = await func(*args, **kwargs)
-                    return [function(value) for value in values]
-
-                return async_wrapper
-            else:
-
-                @wraps(func)
-                def sync_wrapper(*args, **kwargs) -> list[Any]:
-                    values = func(*args, **kwargs)
-                    return [function(value) for value in values]
-
-                return sync_wrapper
-
-        return decorator

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",
-]