lionagi 0.14.11__tar.gz → 0.15.0__tar.gz

{lionagi-0.14.11 → lionagi-0.15.0}/PKG-INFO

@@ -1,8 +1,8 @@
 Metadata-Version: 2.4
 Name: lionagi
-Version: 0.14.11
+Version: 0.15.0
 Summary: An Intelligence Operating System.
-Author-email: HaiyangLi <quantocean.li@gmail.com>, Liangbingyan Luo <llby_luo@outlook.com>
+Author-email: HaiyangLi <quantocean.li@gmail.com>
 License:            Apache License
                                    Version 2.0, January 2004
                                 http://www.apache.org/licenses/
@@ -220,8 +220,8 @@ Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Requires-Python: >=3.10
 Requires-Dist: aiocache>=0.12.0
-Requires-Dist: aiohttp>=3.12.0
-Requires-Dist: anyio>=4.8.0
+Requires-Dist: aiohttp>=3.11.0
+Requires-Dist: anyio>=4.7.0
 Requires-Dist: backoff>=2.2.1
 Requires-Dist: jinja2>=3.1.0
 Requires-Dist: json-repair>=0.40.0

lionagi-0.15.0/lionagi/libs/concurrency.py

@@ -0,0 +1 @@
+from ..ln.concurrency import *  # backward compatibility

{lionagi-0.14.11 → lionagi-0.15.0}/lionagi/libs/token_transform/perplexity.py

@@ -5,11 +5,12 @@ from timeit import default_timer as timer
 import numpy as np
 from pydantic import BaseModel
 
+from lionagi.ln import alcall, lcall
 from lionagi.protocols.generic.event import EventStatus
 from lionagi.protocols.generic.log import Log
 from lionagi.service.connections.api_calling import APICalling
 from lionagi.service.imodel import iModel
-from lionagi.utils import alcall, lcall, to_dict, to_list
+from lionagi.utils import to_dict, to_list
 
 
 @dataclass

{lionagi-0.14.11 → lionagi-0.15.0}/lionagi/libs/token_transform/symbolic_compress_context.py

@@ -2,9 +2,10 @@ from collections.abc import Callable
 from pathlib import Path
 from typing import Literal
 
+from lionagi.ln import alcall
 from lionagi.service.imodel import iModel
 from lionagi.session.branch import Branch
-from lionagi.utils import alcall, get_bins
+from lionagi.utils import get_bins
 
 from .base import TokenMapping, TokenMappingTemplate
 from .synthlang_.base import SynthlangFramework, SynthlangTemplate
@@ -130,13 +131,13 @@ async def symbolic_compress_context(
         _inner,
         max_concurrent=max_concurrent,
         retry_default=None,
-        num_retries=3,
-        throttle_period=throttle_period,
+        retry_attempts=3,
+        retry_backoff=2,
         retry_delay=1,
-        backoff_factor=2,
-        flatten=True,
-        dropna=True,
-        unique_output=True,
+        throttle_period=throttle_period,
+        output_flatten=True,
+        output_dropna=True,
+        output_unique=True,
     )
     text = "\n".join(results)
     text = DEFAULT_INVOKATION_PROMPT + text

lionagi-0.15.0/lionagi/ln/__init__.py

@@ -0,0 +1,49 @@
+from ._async_call import AlcallParams, BcallParams, alcall, bcall
+from ._hash import hash_dict
+from ._list_call import LcallParams, lcall
+from ._models import DataClass, Params
+from ._to_list import ToListParams, to_list
+from ._types import (
+    Enum,
+    KeysDict,
+    MaybeSentinel,
+    MaybeUndefined,
+    MaybeUnset,
+    SingletonType,
+    T,
+    Undefined,
+    UndefinedType,
+    Unset,
+    UnsetType,
+    is_sentinel,
+    not_sentinel,
+)
+from .concurrency import *
+
+__all__ = (
+    "Undefined",
+    "Unset",
+    "MaybeUndefined",
+    "MaybeUnset",
+    "MaybeSentinel",
+    "SingletonType",
+    "UndefinedType",
+    "UnsetType",
+    "KeysDict",
+    "T",
+    "Enum",
+    "is_sentinel",
+    "not_sentinel",
+    "Params",
+    "DataClass",
+    "Enum",
+    "hash_dict",
+    "to_list",
+    "ToListParams",
+    "lcall",
+    "LcallParams",
+    "alcall",
+    "bcall",
+    "AlcallParams",
+    "BcallParams",
+)

lionagi-0.15.0/lionagi/ln/_async_call.py

@@ -0,0 +1,293 @@
+import asyncio
+from dataclasses import dataclass
+from typing import Any, AsyncGenerator, Callable, ClassVar
+
+import anyio
+from pydantic import BaseModel
+
+from ._models import Params
+from ._to_list import to_list
+from ._types import T, Unset, not_sentinel
+from .concurrency import Lock as ConcurrencyLock
+from .concurrency import Semaphore, create_task_group, is_coro_func
+
+__all__ = (
+    "alcall",
+    "bcall",
+    "AlcallParams",
+    "BcallParams",
+)
+
+
+async def alcall(
+    input_: list[Any],
+    func: Callable[..., T],
+    /,
+    *,
+    input_flatten: bool = False,
+    input_dropna: bool = False,
+    input_unique: bool = False,
+    input_flatten_tuple_set: bool = False,
+    output_flatten: bool = False,
+    output_dropna: bool = False,
+    output_unique: bool = False,
+    output_flatten_tuple_set: bool = False,
+    delay_before_start: float = 0,
+    retry_initial_deplay: float = 0,
+    retry_backoff: float = 1,
+    retry_default: Any = Unset,
+    retry_timeout: float = 0,
+    retry_attempts: int = 0,
+    max_concurrent: int | None = None,
+    throttle_period: float | None = None,
+    **kwargs: Any,
+) -> list[T]:
+    """
+    Asynchronously apply a function to each element of a list, with optional input sanitization,
+    retries, timeout, and output processing.
+    """
+
+    # Validate func is a single callable
+    if not callable(func):
+        # If func is not callable, maybe it's an iterable. Extract one callable if possible.
+        try:
+            func_list = list(func)  # Convert iterable to list
+        except TypeError:
+            raise ValueError(
+                "func must be callable or an iterable containing one callable."
+            )
+
+        # Ensure exactly one callable is present
+        if len(func_list) != 1 or not callable(func_list[0]):
+            raise ValueError("Only one callable function is allowed.")
+
+        func = func_list[0]
+
+    # Process input if requested
+    if any((input_flatten, input_dropna)):
+        input_ = to_list(
+            input_,
+            flatten=input_flatten,
+            dropna=input_dropna,
+            unique=input_unique,
+            flatten_tuple_set=input_flatten_tuple_set,
+        )
+    else:
+        if not isinstance(input_, list):
+            # Attempt to iterate
+            if isinstance(input_, BaseModel):
+                # Pydantic model, convert to list
+                input_ = [input_]
+            else:
+                try:
+                    iter(input_)
+                    # It's iterable (tuple), convert to list of its contents
+                    input_ = list(input_)
+                except TypeError:
+                    # Not iterable, just wrap in a list
+                    input_ = [input_]
+
+    # Optional initial delay before processing
+    if delay_before_start:
+        await anyio.sleep(delay_before_start)
+
+    semaphore = Semaphore(max_concurrent) if max_concurrent else None
+    throttle_delay = throttle_period or 0
+    coro_func = is_coro_func(func)
+
+    async def call_func(item: Any) -> T:
+        if coro_func:
+            # Async function
+            if retry_timeout is not None:
+                with anyio.move_on_after(retry_timeout) as cancel_scope:
+                    result = await func(item, **kwargs)
+                if cancel_scope.cancelled_caught:
+                    raise asyncio.TimeoutError(
+                        f"Function call timed out after {retry_timeout}s"
+                    )
+                return result
+            else:
+                return await func(item, **kwargs)
+        else:
+            # Sync function
+            if retry_timeout is not None:
+                with anyio.move_on_after(retry_timeout) as cancel_scope:
+                    result = await anyio.to_thread.run_sync(
+                        func, item, **kwargs
+                    )
+                if cancel_scope.cancelled_caught:
+                    raise asyncio.TimeoutError(
+                        f"Function call timed out after {retry_timeout}s"
+                    )
+                return result
+            else:
+                return await anyio.to_thread.run_sync(func, item, **kwargs)
+
+    async def execute_task(i: Any, index: int) -> Any:
+        attempts = 0
+        current_delay = retry_initial_deplay
+        while True:
+            try:
+                result = await call_func(i)
+                return index, result
+
+            # if cancelled, re-raise
+            except anyio.get_cancelled_exc_class():
+                raise
+
+            # handle other exceptions
+            except Exception:
+                attempts += 1
+                if attempts <= retry_attempts:
+                    if current_delay:
+                        await anyio.sleep(current_delay)
+                        current_delay *= retry_backoff
+                    # Retry loop continues
+                else:
+                    # Exhausted retries
+                    if not_sentinel(retry_default):
+                        return index, retry_default
+                    # No default, re-raise
+                    raise
+
+    async def task_wrapper(item: Any, idx: int) -> Any:
+        if semaphore:
+            async with semaphore:
+                result = await execute_task(item, idx)
+        else:
+            result = await execute_task(item, idx)
+
+        return result
+
+    # Use task group for structured concurrency
+    results = []
+    results_lock = ConcurrencyLock()  # Protect results list
+
+    async def run_and_store(item: Any, idx: int):
+        result = await task_wrapper(item, idx)
+        async with results_lock:
+            results.append(result)
+
+    # Execute all tasks using task group
+    async with create_task_group() as tg:
+        for idx, item in enumerate(input_):
+            await tg.start_soon(run_and_store, item, idx)
+            # Apply throttle delay between starting tasks
+            if throttle_delay and idx < len(input_) - 1:
+                await anyio.sleep(throttle_delay)
+
+    # Sort by original index
+    results.sort(key=lambda x: x[0])
+
+    # (index, result)
+    output_list = [r[1] for r in results]
+    return to_list(
+        output_list,
+        flatten=output_flatten,
+        dropna=output_dropna,
+        unique=output_unique,
+        flatten_tuple_set=output_flatten_tuple_set,
+    )
+
+
+async def bcall(
+    input_: list[Any],
+    func: Callable[..., T],
+    /,
+    batch_size: int,
+    *,
+    input_flatten: bool = False,
+    input_dropna: bool = False,
+    input_unique: bool = False,
+    input_flatten_tuple_set: bool = False,
+    output_flatten: bool = False,
+    output_dropna: bool = False,
+    output_unique: bool = False,
+    output_flatten_tuple_set: bool = False,
+    delay_before_start: float = 0,
+    retry_initial_deplay: float = 0,
+    retry_backoff: float = 1,
+    retry_default: Any = Unset,
+    retry_timeout: float = 0,
+    retry_attempts: int = 0,
+    max_concurrent: int | None = None,
+    throttle_period: float | None = None,
+    **kwargs: Any,
+) -> AsyncGenerator[list[T | tuple[T, float]], None]:
+    input_ = to_list(input_, flatten=True, dropna=True)
+
+    for i in range(0, len(input_), batch_size):
+        batch = input_[i : i + batch_size]  # noqa: E203
+        yield await alcall(
+            batch,
+            func,
+            input_flatten=input_flatten,
+            input_dropna=input_dropna,
+            input_unique=input_unique,
+            input_flatten_tuple_set=input_flatten_tuple_set,
+            output_flatten=output_flatten,
+            output_dropna=output_dropna,
+            output_unique=output_unique,
+            output_flatten_tuple_set=output_flatten_tuple_set,
+            delay_before_start=delay_before_start,
+            retry_initial_deplay=retry_initial_deplay,
+            retry_backoff=retry_backoff,
+            retry_default=retry_default,
+            retry_timeout=retry_timeout,
+            retry_attempts=retry_attempts,
+            max_concurrent=max_concurrent,
+            throttle_period=throttle_period,
+            **kwargs,
+        )
+
+
+@dataclass(slots=True, init=False, frozen=True)
+class AlcallParams(Params):
+    # ClassVar attributes
+    _none_as_sentinel: ClassVar[bool] = True
+    _func: ClassVar[Any] = alcall
+
+    # input processing
+    input_flatten: bool
+    input_dropna: bool
+    input_unique: bool
+    input_flatten_tuple_set: bool
+
+    # output processing
+    output_flatten: bool
+    output_dropna: bool
+    output_unique: bool
+    output_flatten_tuple_set: bool
+
+    # retry and timeout
+    delay_before_start: float
+    retry_initial_deplay: float
+    retry_backoff: float
+    retry_default: Any
+    retry_timeout: float
+    retry_attempts: int
+
+    # concurrency and throttling
+    max_concurrent: int
+    throttle_period: float
+
+    kw: dict[str, Any] = Unset
+
+    async def __call__(
+        self, input_: list[Any], func: Callable[..., T], **kw
+    ) -> list[T]:
+        f = self.as_partial()
+        return await f(input_, func, **kw)
+
+
+@dataclass(slots=True, init=False, frozen=True)
+class BcallParams(AlcallParams):
+    _func: ClassVar[Any] = bcall
+
+    batch_size: int
+
+    async def __call__(
+        self, input_: list[Any], func: Callable[..., T], **kw
+    ) -> list[T]:
+        f = self.as_partial()
+        return await f(input_, func, self.batch_size, **kw)

lionagi-0.15.0/lionagi/ln/_list_call.py

@@ -0,0 +1,129 @@
+from dataclasses import dataclass
+from typing import Any, Callable, ClassVar, Iterable, TypeVar
+
+from ._models import Params
+from ._to_list import to_list
+
+R = TypeVar("R")
+T = TypeVar("T")
+
+__all__ = ("lcall", "LcallParams")
+
+
+def lcall(
+    input_: Iterable[T] | T,
+    func: Callable[[T], R] | Iterable[Callable[[T], R]],
+    /,
+    *args: Any,
+    input_flatten: bool = False,
+    input_dropna: bool = False,
+    input_unique: bool = False,
+    input_use_values: bool = False,
+    input_flatten_tuple_set: bool = False,
+    output_flatten: bool = False,
+    output_dropna: bool = False,
+    output_unique: bool = False,
+    output_flatten_tuple_set: bool = False,
+    **kwargs: Any,
+) -> list[R]:
+    """Apply function to each element in input list with optional processing.
+
+    Maps a function over input elements and processes results. Can sanitize input
+    and output using various filtering options.
+
+    Raises:
+        ValueError: If func is not callable or unique_output used incorrectly.
+        TypeError: If func or input processing fails.
+    """
+    # Validate and extract callable function
+    if not callable(func):
+        try:
+            func_list = list(func)
+            if len(func_list) != 1 or not callable(func_list[0]):
+                raise ValueError(
+                    "func must contain exactly one callable function."
+                )
+            func = func_list[0]
+        except TypeError as e:
+            raise ValueError(
+                "func must be callable or iterable with one callable."
+            ) from e
+
+    # Validate output processing options
+    if output_unique and not (output_flatten or output_dropna):
+        raise ValueError(
+            "unique_output requires flatten or dropna for post-processing."
+        )
+
+    # Process input based on sanitization flag
+    if input_flatten or input_dropna:
+        input_ = to_list(
+            input_,
+            flatten=input_flatten,
+            dropna=input_dropna,
+            unique=input_unique,
+            flatten_tuple_set=input_flatten_tuple_set,
+            use_values=input_use_values,
+        )
+    else:
+        if not isinstance(input_, list):
+            try:
+                input_ = list(input_)
+            except TypeError:
+                input_ = [input_]
+
+    # Process elements and collect results
+    out = []
+    append = out.append
+
+    for item in input_:
+        try:
+            result = func(item, *args, **kwargs)
+            append(result)
+        except InterruptedError:
+            return out
+        except Exception:
+            raise
+
+    # Apply output processing if requested
+    if output_flatten or output_dropna:
+        out = to_list(
+            out,
+            flatten=output_flatten,
+            dropna=output_dropna,
+            unique=output_unique,
+            flatten_tuple_set=output_flatten_tuple_set,
+        )
+
+    return out
+
+
+@dataclass(slots=True, frozen=True, init=False)
+class LcallParams(Params):
+    _func: ClassVar[Any] = lcall
+
+    # input processing
+    input_flatten: bool
+    """If True, recursively flatten input to a flat list"""
+    input_dropna: bool
+    """If True, remove None and undefined values from input."""
+    input_unique: bool
+    input_use_values: bool
+    input_flatten_tuple_set: bool
+
+    # output processing
+    output_flatten: bool
+    """If True, recursively flatten output to a flat list."""
+    output_dropna: bool
+    """If True, remove None and undefined values."""
+    output_unique: bool
+    """If True, remove duplicates (requires output_flatten=True)."""
+    output_use_values: bool
+    """If True, extract values from enums/mappings."""
+    output_flatten_tuple_set: bool
+    """If True, include tuples and sets in flattening."""
+
+    def __call__(self, input_: Any, *args, **kw) -> list:
+        """Convert parameters to a list."""
+        f = self.as_partial()
+        return f(input_, *args, **kw)

lionagi-0.15.0/lionagi/ln/_models.py

@@ -0,0 +1,126 @@
+from dataclasses import dataclass, field
+from functools import partial
+from typing import Any, ClassVar
+
+from typing_extensions import override
+
+from ._types import Undefined, Unset, is_sentinel
+
+__all__ = ("Params", "DataClass")
+
+
+class _SentinelAware:
+    """Metaclass to ensure sentinels are handled correctly in subclasses."""
+
+    _none_as_sentinel: ClassVar[bool] = False
+    """If True, None is treated as a sentinel value."""
+
+    _strict: ClassVar[bool] = False
+    """No sentinels allowed if strict is True."""
+
+    _prefill_unset: ClassVar[bool] = True
+    """If True, unset fields are prefilled with Unset."""
+
+    _allowed_keys: ClassVar[set[str]] = field(
+        default=set(), init=False, repr=False
+    )
+    """Class variable cache to store allowed keys for parameters."""
+
+    @classmethod
+    def allowed(cls) -> set[str]:
+        """Return the keys of the parameters."""
+        if cls._allowed_keys:
+            return cls._allowed_keys
+        cls._allowed_keys = {
+            i for i in cls.__dataclass_fields__.keys() if not i.startswith("_")
+        }
+        return cls._allowed_keys
+
+    @classmethod
+    def _is_sentinel(cls, value: Any) -> bool:
+        """Check if a value is a sentinel (Undefined or Unset)."""
+        if value is None and cls._none_as_sentinel:
+            return True
+        return is_sentinel(value)
+
+    def __post_init__(self):
+        """Post-initialization to ensure all fields are set."""
+        self._validate()
+
+    def _validate(self) -> None:
+        pass
+
+    def to_dict(self) -> dict[str, str]:
+        data = {}
+        for k in self.allowed():
+            if not self._is_sentinel(v := getattr(self, k)):
+                data[k] = v
+        return data
+
+
+@dataclass(slots=True, frozen=True, init=False)
+class Params(_SentinelAware):
+    """Base class for parameters used in various functions."""
+
+    _func: ClassVar[Any] = Unset
+    _particial_func: ClassVar[Any] = Unset
+
+    @override
+    def _validate(self) -> None:
+        def _validate_strict(k):
+            if self._strict and self._is_sentinel(getattr(self, k, Unset)):
+                raise ValueError(f"Missing required parameter: {k}")
+            if (
+                self._prefill_unset
+                and getattr(self, k, Undefined) is Undefined
+            ):
+                object.__setattr__(self, k, Unset)
+
+        for k in self.allowed():
+            _validate_strict(k)
+
+    def as_partial(self) -> Any:
+        # if partial function is already cached, return it
+        if self._particial_func is not Unset:
+            return self._particial_func
+
+        # validate is there is a function to apply
+        if self._func is Unset:
+            raise ValueError("No function defined for partial application.")
+        if not callable(self._func):
+            raise TypeError(
+                f"Expected a callable, got {type(self._func).__name__}."
+            )
+
+        # create a partial function with the current parameters
+        dict_ = self.to_dict()
+        if not dict_:
+            self._particial_func = self._func
+            return self._func
+
+        # handle kwargs if present, handle both 'kwargs' and 'kw'
+        kw_ = {}
+        kw_.update(dict_.pop("kwargs", {}))
+        kw_.update(dict_.pop("kw", {}))
+        dict_.update(kw_)
+        self._particial_func = partial(self._func, **dict_)
+        return self._particial_func
+
+
+@dataclass(slots=True)
+class DataClass(_SentinelAware):
+    """A base class for data classes with strict parameter handling."""
+
+    @override
+    def _validate(self) -> None:
+        def _validate_strict(k):
+            if self._strict and self._is_sentinel(getattr(self, k, Unset)):
+                raise ValueError(f"Missing required parameter: {k}")
+            if (
+                self._prefill_unset
+                and getattr(self, k, Undefined) is Undefined
+            ):
+                self.__setattr__(k, Unset)
+
+        for k in self.allowed():
+            _validate_strict(k)