lionagi 0.15.4__py3-none-any.whl → 0.15.6__py3-none-any.whl

lionagi/adapters/_utils.py

@@ -0,0 +1,26 @@
+def check_async_postgres_available():
+    try:
+        import sqlalchemy as sa
+        from pydapter.extras.async_postgres_ import AsyncPostgresAdapter
+        from sqlalchemy.ext.asyncio import create_async_engine
+
+        return True
+    except Exception:
+        return ImportError(
+            "This adapter requires postgres option to be installed. "
+            'Please install them using `uv pip install "lionagi[postgres]"`.'
+        )
+
+
+def check_postgres_available():
+    try:
+        from pydapter.model_adapters.postgres_model import PostgresModelAdapter
+        from sqlalchemy import String
+        from sqlalchemy.orm import DeclarativeBase
+
+        return True
+    except Exception:
+        return ImportError(
+            "This adapter requires postgres option to be installed. "
+            'Please install them using `uv pip install "lionagi[postgres]"`.'
+        )

lionagi/adapters/async_postgres_adapter.py

@@ -12,16 +12,16 @@ from typing import Any, ClassVar, TypeVar
 
 from pydapter.exceptions import QueryError
 
-try:
-    import sqlalchemy as sa
-    from pydapter.extras.async_postgres_ import AsyncPostgresAdapter
-    from sqlalchemy.ext.asyncio import create_async_engine
-except ImportError:
-    raise ImportError(
-        "This adapter requires postgres option to be installed. "
-        'Please install them using `uv pip install "lionagi[postgres]"`.'
-    )
+from ._utils import check_async_postgres_available
 
+_ASYNC_POSTGRES_AVAILABLE = check_async_postgres_available()
+
+if isinstance(_ASYNC_POSTGRES_AVAILABLE, ImportError):
+    raise _ASYNC_POSTGRES_AVAILABLE
+
+import sqlalchemy as sa
+from pydapter.extras.async_postgres_ import AsyncPostgresAdapter
+from sqlalchemy.ext.asyncio import create_async_engine
 
 T = TypeVar("T")
 

lionagi/adapters/postgres_model_adapter.py

@@ -7,19 +7,19 @@ PostgreSQL persistence for lionagi Nodes.
 
 from __future__ import annotations
 
-from typing import Any, Union, get_args, get_origin
+from typing import Union, get_args, get_origin
 
 from pydantic import BaseModel
 
-try:
-    from pydapter.model_adapters.postgres_model import PostgresModelAdapter
-    from sqlalchemy import String
-    from sqlalchemy.orm import DeclarativeBase
-except ImportError:
-    raise ImportError(
-        "This adapter requires postgres option to be installed. "
-        'Please install them using `uv pip install "lionagi[postgres]"`.'
-    )
+from ._utils import check_postgres_available
+
+_POSTGRES_AVAILABLE = check_postgres_available()
+if isinstance(_POSTGRES_AVAILABLE, ImportError):
+    raise _POSTGRES_AVAILABLE
+
+from pydapter.model_adapters.postgres_model import PostgresModelAdapter
+from sqlalchemy import String
+from sqlalchemy.orm import DeclarativeBase
 
 
 class LionAGIPostgresAdapter(PostgresModelAdapter):

lionagi/ln/_async_call.py

@@ -37,7 +37,7 @@ async def alcall(
     retry_initial_deplay: float = 0,
     retry_backoff: float = 1,
     retry_default: Any = Unset,
-    retry_timeout: float = 0,
+    retry_timeout: float = None,
     retry_attempts: int = 0,
     max_concurrent: int | None = None,
     throttle_period: float | None = None,
@@ -277,8 +277,8 @@ class AlcallParams(Params):
     async def __call__(
         self, input_: list[Any], func: Callable[..., T], **kw
     ) -> list[T]:
-        f = self.as_partial()
-        return await f(input_, func, **kw)
+        kwargs = {**self.default_kw(), **kw}
+        return await alcall(input_, func, **kwargs)
 
 
 @dataclass(slots=True, init=False, frozen=True)
@@ -290,5 +290,7 @@ class BcallParams(AlcallParams):
     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)
+        kwargs = {**self.default_kw(), **kw}
+        func = self._func
+
+        return await func(input_, func, self.batch_size, **kwargs)

lionagi/ln/_models.py

@@ -1,5 +1,4 @@
 from dataclasses import dataclass, field
-from functools import partial
 from typing import Any, ClassVar
 
 from typing_extensions import override
@@ -9,8 +8,9 @@ from ._types import Undefined, Unset, is_sentinel
 __all__ = ("Params", "DataClass")
 
 
-class _SentinelAware:
-    """Metaclass to ensure sentinels are handled correctly in subclasses."""
+@dataclass(slots=True, frozen=True, init=False)
+class Params:
+    """Base class for parameters used in various functions."""
 
     _none_as_sentinel: ClassVar[bool] = False
     """If True, None is treated as a sentinel value."""
@@ -26,16 +26,6 @@ class _SentinelAware:
     )
     """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)."""
@@ -47,23 +37,15 @@ class _SentinelAware:
         """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
+    @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
 
     @override
     def _validate(self) -> None:
@@ -79,38 +61,58 @@ class Params(_SentinelAware):
         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__}."
-            )
+    def default_kw(self) -> Any:
 
         # 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
+        return dict_
+
+    def to_dict(self) -> dict[str, str]:
+        data = {}
+        for k in self.allowed():
+            if not self._is_sentinel(v := getattr(self, k, Undefined)):
+                data[k] = v
+        return data
 
 
 @dataclass(slots=True)
-class DataClass(_SentinelAware):
+class DataClass:
     """A base class for data classes with strict parameter handling."""
 
+    _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."""
+
+    def __post_init__(self):
+        """Post-initialization to ensure all fields are set."""
+        self._validate()
+
+    @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
+
     @override
     def _validate(self) -> None:
         def _validate_strict(k):
@@ -124,3 +126,18 @@ class DataClass(_SentinelAware):
 
         for k in self.allowed():
             _validate_strict(k)
+
+    def to_dict(self) -> dict[str, str]:
+        data = {}
+        print(self.allowed())
+        for k in type(self).allowed():
+            if not self._is_sentinel(v := getattr(self, k)):
+                data[k] = v
+        return data
+
+    @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)

lionagi/ln/concurrency/__init__.py

@@ -24,6 +24,7 @@ from .resource_tracker import (
 from .task import TaskGroup, create_task_group
 from .utils import is_coro_func
 
+ConcurrencyEvent = Event
 __all__ = (
     "TaskGroup",
     "create_task_group",
@@ -48,4 +49,5 @@ __all__ = (
     "cleanup_check",
     "get_global_tracker",
     "is_coro_func",
+    "ConcurrencyEvent",
 )

lionagi/operations/flow.py

@@ -12,9 +12,7 @@ using Events for synchronization and CapacityLimiter for concurrency control.
 import os
 from typing import Any
 
-from lionagi.ln.concurrency.primitives import CapacityLimiter
-from lionagi.ln.concurrency.primitives import Event as ConcurrencyEvent
-from lionagi.ln.concurrency.task import create_task_group
+from lionagi.ln import AlcallParams, CapacityLimiter, ConcurrencyEvent
 from lionagi.operations.node import Operation
 from lionagi.protocols.types import EventStatus, Graph
 from lionagi.session.branch import Branch
@@ -36,6 +34,7 @@ class DependencyAwareExecutor:
         max_concurrent: int = 5,
         verbose: bool = False,
         default_branch: Branch | None = None,
+        alcall_params: AlcallParams | None = None,
     ):
         """Initialize the executor.
 
@@ -52,6 +51,7 @@ class DependencyAwareExecutor:
         self.context = context or {}
         self.max_concurrent = max_concurrent
         self.verbose = verbose
+        self._alcall = alcall_params or AlcallParams()
         self._default_branch = default_branch
 
         # Track results and completion
@@ -92,11 +92,12 @@ class DependencyAwareExecutor:
         )
         limiter = CapacityLimiter(capacity)
 
-        # Execute all operations using structured concurrency
-        async with create_task_group() as tg:
-            for node in self.graph.internal_nodes.values():
-                if isinstance(node, Operation):
-                    await tg.start_soon(self._execute_operation, node, limiter)
+        nodes = [
+            n
+            for n in self.graph.internal_nodes.values()
+            if isinstance(n, Operation)
+        ]
+        await self._alcall(nodes, self._execute_operation, limiter=limiter)
 
         # Return results - only include actually completed operations
         completed_ops = [
@@ -507,6 +508,7 @@ async def flow(
     parallel: bool = True,
     max_concurrent: int = None,
     verbose: bool = False,
+    alcall_params: AlcallParams | None = None,
 ) -> dict[str, Any]:
     """Execute a graph using structured concurrency primitives.
 
@@ -521,6 +523,7 @@ async def flow(
         parallel: Whether to execute independent operations in parallel
         max_concurrent: Max concurrent operations (1 if not parallel)
         verbose: Enable verbose logging
+        alcall_params: Parameters for async parallel call execution
 
     Returns:
         Execution results with completed operations and final context
@@ -528,8 +531,7 @@ async def flow(
 
     # Handle concurrency limits
     if not parallel:
-        max_concurrent = 1  # Force sequential execution
-    # If max_concurrent is None, it means no limit
+        max_concurrent = 1
 
     # Execute using the dependency-aware executor
     executor = DependencyAwareExecutor(
@@ -539,6 +541,7 @@ async def flow(
         max_concurrent=max_concurrent,
         verbose=verbose,
         default_branch=branch,
+        alcall_params=alcall_params,
     )
 
     return await executor.execute()