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

lionagi/libs/func/async_calls/mcall.py

@@ -1,134 +0,0 @@
-import asyncio
-from collections.abc import Callable, Sequence
-from typing import Any, TypeVar
-
-from ...constants import UNDEFINED
-from ...parse import to_list
-from .alcall import alcall
-from .rcall import rcall
-
-T = TypeVar("T")
-
-
-async def mcall(
-    input_: Any,
-    func: Callable[..., T] | Sequence[Callable[..., T]],
-    /,
-    *,
-    explode: bool = False,
-    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,
-    max_concurrent: int | None = None,
-    throttle_period: float | None = None,
-    dropna: bool = False,
-    **kwargs: Any,
-) -> list[T] | list[tuple[T, float]]:
-    """
-    Apply functions over inputs asynchronously with customizable options.
-
-    Args:
-        input_: The input data to be processed.
-        func: The function or sequence of functions to be applied.
-        explode: Whether to apply each function to all inputs.
-        retries: Number of retry attempts for each function call.
-        initial_delay: Initial delay before starting execution.
-        delay: Delay between retry attempts.
-        backoff_factor: Factor by which delay increases after each attempt.
-        default: Default value to return if all attempts fail.
-        timeout: Timeout for each function execution.
-        timing: Whether to return the execution duration.
-        verbose: Whether to print retry messages.
-        error_msg: Custom error message.
-        error_map: Dictionary mapping exception types to error handlers.
-        max_concurrent: Maximum number of concurrent executions.
-        throttle_period: Minimum time period between function executions.
-        dropna: Whether to drop None values from the output list.
-        **kwargs: Additional keyword arguments for the functions.
-
-    Returns:
-        List of results, optionally including execution durations if timing
-        is True.
-
-    Raises:
-        ValueError: If the length of inputs and functions don't match when
-            not exploding the function calls.
-    """
-    input_ = to_list(input_, flatten=False, dropna=False)
-    func = to_list(func, flatten=False, dropna=False)
-
-    if explode:
-        tasks = [
-            alcall(
-                input_,
-                f,
-                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,
-                max_concurrent=max_concurrent,
-                throttle_period=throttle_period,
-                dropna=dropna,
-                **kwargs,
-            )
-            for f in func
-        ]
-        return await asyncio.gather(*tasks)
-    elif len(func) == 1:
-        tasks = [
-            rcall(
-                func[0],
-                inp,
-                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,
-            )
-            for inp in input_
-        ]
-        return await asyncio.gather(*tasks)
-
-    elif len(input_) == len(func):
-        tasks = [
-            rcall(
-                f,
-                inp,
-                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,
-            )
-            for inp, f in zip(input_, func)
-        ]
-        return await asyncio.gather(*tasks)
-    else:
-        raise ValueError(
-            "Inputs and functions must be the same length for map calling."
-        )

lionagi/libs/func/async_calls/pcall.py

@@ -1,149 +0,0 @@
-import asyncio
-from collections.abc import Callable, Sequence
-from typing import Any, TypeVar
-
-from lionagi.libs.func.utils import is_coroutine_func
-
-from ...constants import UNDEFINED
-from .ucall import ucall
-
-T = TypeVar("T")
-
-
-async def pcall(
-    funcs: Sequence[Callable[..., T]],
-    /,
-    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,
-    max_concurrent: int | None = None,
-    throttle_period: float | None = None,
-    **kwargs: Any,
-) -> list[T] | list[tuple[T, float]]:
-    """Execute multiple functions asynchronously in parallel with options.
-
-    Manages parallel execution of functions with retry logic, timing, and
-    error handling. Supports concurrency control and throttling.
-
-    Args:
-        funcs: Sequence of functions to execute in parallel.
-        num_retries: Number of retry attempts for each function (default: 0).
-        initial_delay: Delay before starting execution (seconds).
-        retry_delay: Initial delay between retry attempts (seconds).
-        backoff_factor: Factor to increase delay after each retry.
-        retry_default: Value to return if all attempts for a function fail.
-        retry_timeout: Timeout for each function execution (seconds).
-        retry_timing: If True, return execution duration for each function.
-        verbose_retry: If True, print retry messages.
-        error_msg: Custom error message prefix.
-        error_map: Dict mapping exception types to error handlers.
-        max_concurrent: Maximum number of functions to run concurrently.
-        throttle_period: Minimum time between function starts (seconds).
-        **kwargs: Additional keyword arguments passed to each function.
-
-    Returns:
-        list[T] | list[tuple[T, float]]: List of results, optionally with
-        execution times if retry_timing is True.
-
-    Raises:
-        asyncio.TimeoutError: If any function execution exceeds retry_timeout.
-        Exception: Any unhandled exception from function executions.
-
-    Examples:
-        >>> async def func1(x):
-        ...     await asyncio.sleep(1)
-        ...     return x * 2
-        >>> async def func2(x):
-        ...     await asyncio.sleep(0.5)
-        ...     return x + 10
-        >>> results = await pcall([func1, func2], retry_timing=True, x=5)
-        >>> for result, duration in results:
-        ...     print(f"Result: {result}, Duration: {duration:.2f}s")
-        Result: 10, Duration: 1.00s
-        Result: 15, Duration: 0.50s
-
-    Note:
-        - Executes functions in parallel, respecting max_concurrent limit.
-        - Implements exponential backoff for retries.
-        - Can return execution timing for performance analysis.
-        - Supports both coroutine and regular functions via ucall.
-        - Results are returned in the original order of input functions.
-    """
-    if initial_delay:
-        await asyncio.sleep(initial_delay)
-
-    semaphore = asyncio.Semaphore(max_concurrent) if max_concurrent else None
-    throttle_delay = throttle_period if throttle_period else 0
-
-    async def _task(func: Callable[..., Any], index: int) -> Any:
-        if semaphore:
-            async with semaphore:
-                return await _execute_task(func, index)
-        else:
-            return await _execute_task(func, index)
-
-    async def _execute_task(func: Callable[..., Any], index: int) -> Any:
-        attempts = 0
-        current_delay = retry_delay
-        while True:
-            try:
-                if retry_timing:
-                    start_time = asyncio.get_event_loop().time()
-                    result = await asyncio.wait_for(
-                        ucall(func, **kwargs), retry_timeout
-                    )
-                    end_time = asyncio.get_event_loop().time()
-                    return index, result, end_time - start_time
-                else:
-                    result = await asyncio.wait_for(
-                        ucall(func, **kwargs), retry_timeout
-                    )
-                    return index, result
-            except TimeoutError as e:
-                raise TimeoutError(
-                    f"{error_msg or ''} Timeout {retry_timeout} seconds "
-                    "exceeded"
-                ) from e
-            except Exception as e:
-                if error_map and type(e) in error_map:
-                    handler = error_map[type(e)]
-                    if is_coroutine_func(handler):
-                        return index, await handler(e)
-                    else:
-                        return index, handler(e)
-                attempts += 1
-                if attempts <= num_retries:
-                    if verbose_retry:
-                        print(
-                            f"Attempt {attempts}/{num_retries + 1} failed: {e}"
-                            ", retrying..."
-                        )
-                    await asyncio.sleep(current_delay)
-                    current_delay *= backoff_factor
-                else:
-                    if retry_default is not UNDEFINED:
-                        return index, retry_default
-                    raise e
-
-    tasks = [_task(func, index) for index, func in enumerate(funcs)]
-    results = []
-    for coro in asyncio.as_completed(tasks):
-        result = await coro
-        results.append(result)
-        await asyncio.sleep(throttle_delay)
-
-    results.sort(
-        key=lambda x: x[0]
-    )  # Sort results based on the original index
-
-    if retry_timing:
-        return [(result[1], result[2]) for result in results]
-    else:
-        return [result[1] for result in results]

lionagi/libs/func/async_calls/rcall.py

@@ -1,217 +0,0 @@
-import asyncio
-from collections.abc import Callable
-from dataclasses import dataclass
-from typing import Any, TypeVar
-
-from lionagi.libs.utils import DataClass
-
-from ...constants import UNDEFINED
-from ...utils import time as _t
-from .ucall import ucall
-
-T = TypeVar("T")
-
-
-@dataclass
-class RCallParams(DataClass):
-    function: Callable[..., T]
-    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
-
-    async def __call__(self, input_, *args, **kwargs):
-        return await rcall(
-            input_,
-            self.function,
-            *args,
-            num_retries=self.num_retries,
-            initial_delay=self.initial_delay,
-            retry_delay=self.retry_delay,
-            backoff_factor=self.backoff_factor,
-            retry_default=self.retry_default,
-            retry_timeout=self.retry_timeout,
-            retry_timing=self.retry_timing,
-            verbose_retry=self.verbose_retry,
-            **kwargs,
-        )
-
-
-async def rcall(
-    func: Callable[..., T],
-    /,
-    *args: Any,
-    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,
-    **kwargs: Any,
-) -> T | tuple[T, float]:
-    """Retry a function asynchronously with customizable options.
-
-    Executes a function with specified retry logic, timing, and error handling.
-
-    Args:
-        func: The function to execute (coroutine or regular).
-        *args: Positional arguments for the function.
-        num_retries: Number of retry attempts (default: 0).
-        initial_delay: Delay before first attempt (seconds).
-        retry_delay: Delay between retry attempts (seconds).
-        backoff_factor: Factor to increase delay after each retry.
-        retry_default: Value to return if all attempts fail.
-        retry_timeout: Timeout for each function execution (seconds).
-        retry_timing: If True, return execution duration.
-        verbose_retry: If True, print retry messages.
-        error_msg: Custom error message prefix.
-        error_map: Dict mapping exception types to error handlers.
-        **kwargs: Additional keyword arguments for the function.
-
-    Returns:
-        T | tuple[T, float]: Function result, optionally with duration.
-
-    Raises:
-        RuntimeError: If function fails after all retries.
-        asyncio.TimeoutError: If execution exceeds retry_timeout.
-
-    Examples:
-        >>> async def flaky_func(x):
-        ...     if random.random() < 0.5:
-        ...         raise ValueError("Random failure")
-        ...     return x * 2
-        >>> result = await rcall(flaky_func, 5, num_retries=3)
-        >>> print(result)
-        10
-
-    Note:
-        - Supports both coroutine and regular functions.
-        - Implements exponential backoff for retries.
-        - Can return execution timing for performance analysis.
-    """
-    last_exception = None
-    result = None
-
-    await asyncio.sleep(initial_delay)
-    for attempt in range(num_retries + 1):
-        try:
-            if num_retries == 0:
-                if retry_timing:
-                    result, duration = await _rcall(
-                        func,
-                        *args,
-                        retry_timeout=retry_timeout,
-                        retry_timing=True,
-                        **kwargs,
-                    )
-                    return result, duration
-                result = await _rcall(
-                    func,
-                    *args,
-                    retry_timeout=retry_timeout,
-                    **kwargs,
-                )
-                return result
-            err_msg = (
-                f"Attempt {attempt + 1}/{num_retries + 1}: {error_msg or ''}"
-            )
-            if retry_timing:
-                result, duration = await _rcall(
-                    func,
-                    *args,
-                    error_msg=err_msg,
-                    retry_timeout=retry_timeout,
-                    retry_timing=True,
-                    **kwargs,
-                )
-                return result, duration
-
-            result = await _rcall(
-                func,
-                *args,
-                error_msg=err_msg,
-                retry_timeout=retry_timeout,
-                **kwargs,
-            )
-            return result
-        except Exception as e:
-            last_exception = e
-            if error_map and type(e) in error_map:
-                error_map[type(e)](e)
-            if attempt < num_retries:
-                if verbose_retry:
-                    print(
-                        f"Attempt {attempt + 1}/{num_retries + 1} failed: {e},"
-                        " retrying..."
-                    )
-                await asyncio.sleep(retry_delay)
-                retry_delay *= backoff_factor
-            else:
-                break
-
-    if retry_default is not UNDEFINED:
-        return retry_default
-
-    if last_exception is not None:
-        if error_map and type(last_exception) in error_map:
-            handler = error_map[type(last_exception)]
-            if asyncio.iscoroutinefunction(handler):
-                return await handler(last_exception)
-            else:
-                return handler(last_exception)
-        raise RuntimeError(
-            f"{error_msg or ''} Operation failed after {num_retries + 1} "
-            f"attempts: {last_exception}"
-        ) from last_exception
-
-    raise RuntimeError(
-        f"{error_msg or ''} Operation failed after {num_retries + 1} attempts"
-    )
-
-
-async def _rcall(
-    func: Callable[..., T],
-    *args: Any,
-    retry_delay: float = 0,
-    error_msg: str | None = None,
-    ignore_err: bool = False,
-    retry_timing: bool = False,
-    retry_default: Any = None,
-    retry_timeout: float | None = None,
-    **kwargs: Any,
-) -> T | tuple[T, float]:
-    start_time = _t()
-
-    try:
-        await asyncio.sleep(retry_delay)
-        if retry_timeout is not None:
-            result = await asyncio.wait_for(
-                ucall(func, *args, **kwargs), timeout=retry_timeout
-            )
-        else:
-            result = await ucall(func, *args, **kwargs)
-        duration = _t() - start_time
-        return (result, duration) if retry_timing else result
-    except TimeoutError as e:
-        error_msg = (
-            f"{error_msg or ''} Timeout {retry_timeout} seconds exceeded"
-        )
-        if ignore_err:
-            duration = _t() - start_time
-            return (retry_default, duration) if retry_timing else retry_default
-        else:
-            raise TimeoutError(error_msg) from e
-    except Exception:
-        if ignore_err:
-            duration = _t() - start_time
-            return (retry_default, duration) if retry_timing else retry_default
-        else:
-            raise

lionagi/libs/func/async_calls/tcall.py

@@ -1,114 +0,0 @@
-import asyncio
-import logging
-from collections.abc import Callable
-from typing import Any, TypeVar
-
-from ...constants import UNDEFINED
-from .ucall import ucall
-
-T = TypeVar("T")
-
-
-async def tcall(
-    func: Callable[..., T],
-    /,
-    *args: Any,
-    initial_delay: float = 0,
-    error_msg: str | None = None,
-    suppress_err: bool = False,
-    retry_timing: bool = False,
-    retry_timeout: float | None = None,
-    retry_default: Any = None,
-    error_map: dict[type, Callable[[Exception], None]] | None = None,
-    **kwargs: Any,
-) -> T | tuple[T, float]:
-    """Execute a function asynchronously with timing and error handling.
-
-    Handles both coroutine and regular functions, supporting timing,
-    timeout, and custom error handling.
-
-    Args:
-        func: The function to execute (coroutine or regular).
-        *args: Positional arguments for the function.
-        initial_delay: Delay before execution (seconds).
-        error_msg: Custom error message prefix.
-        suppress_err: If True, return default on error instead of raising.
-        retry_timing: If True, return execution duration.
-        retry_timeout: Timeout for function execution (seconds).
-        retry_default: Value to return if an error occurs and suppress_err
-        is True.
-        error_map: Dict mapping exception types to error handlers.
-        **kwargs: Additional keyword arguments for the function.
-
-    Returns:
-        T | tuple[T, float]: Function result, optionally with duration.
-
-    Raises:
-        asyncio.TimeoutError: If execution exceeds the timeout.
-        RuntimeError: If an error occurs and suppress_err is False.
-
-    Examples:
-        >>> async def slow_func(x):
-        ...     await asyncio.sleep(1)
-        ...     return x * 2
-        >>> result, duration = await tcall(slow_func, 5, retry_timing=True)
-        >>> print(f"Result: {result}, Duration: {duration:.2f}s")
-        Result: 10, Duration: 1.00s
-
-    Note:
-        - Automatically handles both coroutine and regular functions.
-        - Provides timing information for performance analysis.
-        - Supports custom error handling and suppression.
-    """
-    start = asyncio.get_event_loop().time()
-
-    try:
-        await asyncio.sleep(initial_delay)
-        result = None
-
-        if asyncio.iscoroutinefunction(func):
-            # Asynchronous function
-            if retry_timeout is None:
-                result = await func(*args, **kwargs)
-            else:
-                result = await asyncio.wait_for(
-                    func(*args, **kwargs), timeout=retry_timeout
-                )
-        else:
-            # Synchronous function
-            if retry_timeout is None:
-                result = func(*args, **kwargs)
-            else:
-                result = await asyncio.wait_for(
-                    asyncio.shield(asyncio.to_thread(func, *args, **kwargs)),
-                    timeout=retry_timeout,
-                )
-
-        duration = asyncio.get_event_loop().time() - start
-        return (result, duration) if retry_timing else result
-
-    except TimeoutError as e:
-        error_msg = (
-            f"{error_msg or ''} Timeout {retry_timeout} seconds exceeded"
-        )
-        if suppress_err:
-            duration = asyncio.get_event_loop().time() - start
-            return (retry_default, duration) if retry_timing else retry_default
-        else:
-            raise TimeoutError(error_msg) from e
-
-    except Exception as e:
-        if error_map and type(e) in error_map:
-            error_map[type(e)](e)
-            duration = asyncio.get_event_loop().time() - start
-            return (None, duration) if retry_timing else None
-        error_msg = (
-            f"{error_msg} Error: {e}"
-            if error_msg
-            else f"An error occurred in async execution: {e}"
-        )
-        if suppress_err:
-            duration = asyncio.get_event_loop().time() - start
-            return (retry_default, duration) if retry_timing else retry_default
-        else:
-            raise RuntimeError(error_msg) from e

lionagi/libs/func/async_calls/ucall.py

@@ -1,85 +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
-from typing import Any, TypeVar
-
-from ..utils import custom_error_handler, force_async, is_coroutine_func
-
-T = TypeVar("T")
-
-
-async def ucall(
-    func: Callable[..., T],
-    /,
-    *args: Any,
-    error_map: dict[type, Callable[[Exception], None]] | None = None,
-    **kwargs: Any,
-) -> T:
-    """Execute a function asynchronously with error handling.
-
-    Ensures asynchronous execution of both coroutine and regular functions,
-    managing event loops and applying custom error handling.
-
-    Args:
-        func: The function to be executed (coroutine or regular).
-        *args: Positional arguments for the function.
-        error_map: Dict mapping exception types to error handlers.
-        **kwargs: Keyword arguments for the function.
-
-    Returns:
-        T: The result of the function call.
-
-    Raises:
-        Exception: Any unhandled exception from the function execution.
-
-    Examples:
-        >>> async def example_func(x):
-        ...     return x * 2
-        >>> await ucall(example_func, 5)
-        10
-        >>> await ucall(lambda x: x + 1, 5)  # Non-coroutine function
-        6
-
-    Note:
-        - Automatically wraps non-coroutine functions for async execution.
-        - Manages event loop creation and closure when necessary.
-        - Applies custom error handling based on the provided error_map.
-    """
-    try:
-        if not is_coroutine_func(func):
-            func = force_async(func)
-
-        # Checking for a running event loop
-        try:
-            loop = asyncio.get_running_loop()
-            if loop.is_running():
-                return await func(*args, **kwargs)
-            else:
-                return await asyncio.run(func(*args, **kwargs))
-
-        except RuntimeError:  # No running event loop
-            loop = asyncio.new_event_loop()
-            result = await func(*args, **kwargs)
-            loop.close()
-            return result
-
-    except Exception as e:
-        if error_map:
-
-            return await custom_error_handler(e, error_map)
-        raise e