lionagi 0.14.3__tar.gz → 0.14.5__tar.gz

{lionagi-0.14.3 → lionagi-0.14.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lionagi
-Version: 0.14.3
+Version: 0.14.5
 Summary: An Intelligence Operating System.
 Author-email: HaiyangLi <quantocean.li@gmail.com>, Liangbingyan Luo <llby_luo@outlook.com>
 License:            Apache License
@@ -224,8 +224,7 @@ Requires-Dist: aiohttp>=3.12.0
 Requires-Dist: anyio>=4.8.0
 Requires-Dist: backoff>=2.2.1
 Requires-Dist: jinja2>=3.1.0
-Requires-Dist: json-repair>=0.47.8
-Requires-Dist: matplotlib>=3.9.0
+Requires-Dist: json-repair>=0.40.0
 Requires-Dist: pillow>=11.0.0
 Requires-Dist: psutil>=7.0.0
 Requires-Dist: pydantic-settings>=2.8.0
@@ -239,6 +238,8 @@ Requires-Dist: claude-code-sdk>=0.0.14; extra == 'all'
 Requires-Dist: datamodel-code-generator>=0.31.2; extra == 'all'
 Requires-Dist: docling>=2.15.1; extra == 'all'
 Requires-Dist: fastmcp>=2.10.5; extra == 'all'
+Requires-Dist: matplotlib>=3.7.0; extra == 'all'
+Requires-Dist: networkx>=3.0.0; extra == 'all'
 Requires-Dist: ollama>=0.4.0; extra == 'all'
 Requires-Dist: pydapter[postgres]; extra == 'all'
 Requires-Dist: rich>=13.0.0; extra == 'all'
@@ -248,6 +249,9 @@ Provides-Extra: docs
 Requires-Dist: furo>=2024.8.6; extra == 'docs'
 Requires-Dist: sphinx-autobuild>=2024.10.3; extra == 'docs'
 Requires-Dist: sphinx>=8.1.3; extra == 'docs'
+Provides-Extra: graph
+Requires-Dist: matplotlib>=3.7.0; extra == 'graph'
+Requires-Dist: networkx>=3.0.0; extra == 'graph'
 Provides-Extra: lint
 Requires-Dist: black[jupyter]>=24.10.0; extra == 'lint'
 Requires-Dist: isort>=5.13.2; extra == 'lint'

{lionagi-0.14.3 → lionagi-0.14.5}/docs/modules/branch_operations.rst

@@ -64,7 +64,7 @@ of action requests. Optionally retries, logs errors, or merges results.
 This is best used for **explicit function calls** triggered from user 
 instructions or system logic.
 
-.. method:: Branch.act(action_request, *, suppress_errors=True, sanitize_input=False, unique_input=False, num_retries=0, initial_delay=0, retry_delay=0, backoff_factor=1, retry_default=UNDEFINED, retry_timeout=None, retry_timing=False, max_concurrent=None, throttle_period=None, flatten=True, dropna=True, unique_output=False, flatten_tuple_set=False)
+.. method:: Branch.act(action_request, *, suppress_errors=True, sanitize_input=False, unique_input=False, num_retries=0, initial_delay=0, retry_delay=0, backoff_factor=1, retry_default=UNDEFINED, retry_timeout=None, max_concurrent=None, throttle_period=None, flatten=True, dropna=True, unique_output=False, flatten_tuple_set=False)
 
     Public, potentially batched, asynchronous interface to run one or multiple action requests.
 
@@ -90,8 +90,6 @@ instructions or system logic.
         Fallback value if all retries fail (if suppressing errors)
     retry_timeout : float | None, default=None
         Overall timeout for all attempts (None = no limit)
-    retry_timing : bool, default=False
-        If True, track time used for retries
     max_concurrent : int | None, default=None
         Maximum concurrent tasks (if batching)
     throttle_period : float | None, default=None

{lionagi-0.14.3 → lionagi-0.14.5}/lionagi/adapters/async_postgres_adapter.py

@@ -188,3 +188,175 @@ class LionAGIAsyncPostgresAdapter(AsyncPostgresAdapter[T]):
             return [cls._serialize_datetime_recursive(item) for item in obj]
         else:
             return obj
+
+    @classmethod
+    async def from_obj(
+        cls,
+        node_cls: type[T],
+        obj: Any,
+        /,
+        *,
+        adapt_meth: str = "from_dict",
+        many: bool = True,
+        **kw,
+    ) -> T | list[T] | None:
+        """
+        Read lionagi Node(s) from database with automatic data reconstruction.
+
+        Handles:
+        1. Database querying with filters
+        2. Reverse metadata field mapping (node_metadata → metadata)
+        3. Reverse data serialization (ISO strings → datetime objects)
+        4. Node object reconstruction
+
+        Args:
+            node_cls: The Node class to instantiate
+            obj: Database connection parameters (dict with dsn, table, etc.)
+            adapt_meth: Adaptation method (unused but required by pydapter)
+            many: Whether to return list or single object
+            **kw: Additional query parameters (where, limit, order_by)
+
+        Returns:
+            Single Node, list of Nodes, or None if no results found
+        """
+        try:
+            # Merge obj parameters with kw parameters
+            if isinstance(obj, dict):
+                params = {**obj, **kw}
+            else:
+                params = kw
+
+            # Validate required parameters
+            engine_url = params.get("dsn") or params.get("engine_url")
+            table = params.get("table")
+
+            if not engine_url or not table:
+                raise ValueError(
+                    "Missing required 'dsn' and 'table' parameters"
+                )
+
+            # Build query
+            engine = create_async_engine(engine_url, future=True)
+            async with engine.begin() as conn:
+                meta = sa.MetaData()
+                meta.bind = conn
+                table_obj = cls._table(meta, table)
+
+                # Build SELECT query
+                query = sa.select(table_obj)
+
+                # Add WHERE conditions if provided
+                where_conditions = params.get("where")
+                if where_conditions:
+                    if isinstance(where_conditions, dict):
+                        # Convert dict to column conditions
+                        for col_name, value in where_conditions.items():
+                            if hasattr(table_obj.c, col_name):
+                                query = query.where(
+                                    getattr(table_obj.c, col_name) == value
+                                )
+                    else:
+                        # Assume it's already a SQLAlchemy condition
+                        query = query.where(where_conditions)
+
+                # Add ordering if provided
+                order_by = params.get("order_by")
+                if order_by:
+                    if isinstance(order_by, str):
+                        if hasattr(table_obj.c, order_by):
+                            query = query.order_by(
+                                getattr(table_obj.c, order_by)
+                            )
+                    else:
+                        query = query.order_by(order_by)
+
+                # Add limit if provided
+                limit = params.get("limit")
+                if limit:
+                    query = query.limit(limit)
+
+                # Execute query
+                result = await conn.execute(query)
+                rows = result.fetchall()
+
+                # Use many parameter from params if provided, otherwise use method parameter
+                return_many = params.get("many", many)
+
+                if not rows:
+                    return [] if return_many else None
+
+                # Convert database rows back to Node objects
+                nodes = []
+                for row in rows:
+                    # Convert row to dict
+                    row_dict = dict(row._mapping)
+
+                    # Apply reverse lionagi data transformations
+                    node_data = cls._reverse_lionagi_data(row_dict)
+
+                    # Create Node instance
+                    node = node_cls(**node_data)
+                    nodes.append(node)
+
+                if return_many:
+                    return nodes
+                else:
+                    return nodes[-1] if nodes else None
+
+        except Exception as e:
+            raise QueryError(
+                f"Error reading from lionagi async adapter: {e}",
+                adapter="lionagi_async_pg",
+            ) from e
+
+    @classmethod
+    def _reverse_lionagi_data(cls, row_data: dict) -> dict:
+        """
+        Reverse lionagi data transformations from database storage.
+
+        Handles:
+        1. Database field mapping (node_metadata → metadata)
+        2. ISO string → datetime objects in content
+        3. Proper lionagi Node field structure
+        """
+        # Create a copy to avoid modifying original
+        data = row_data.copy()
+
+        # Reverse field mapping: node_metadata → metadata
+        if "node_metadata" in data:
+            data["metadata"] = data.pop("node_metadata")
+
+        # Reverse datetime serialization in content
+        if "content" in data and isinstance(data["content"], dict):
+            data["content"] = cls._deserialize_datetime_recursive(
+                data["content"]
+            )
+
+        return data
+
+    @classmethod
+    def _deserialize_datetime_recursive(cls, obj: Any) -> Any:
+        """Recursively convert ISO datetime strings back to datetime objects."""
+        if isinstance(obj, str):
+            # Try to parse as ISO datetime string
+            try:
+                # Check if it looks like an ISO datetime string
+                if "T" in obj and (
+                    obj.endswith("Z")
+                    or "+" in obj[-10:]
+                    or obj.count(":") >= 2
+                ):
+                    return datetime.fromisoformat(obj.replace("Z", "+00:00"))
+            except (ValueError, AttributeError):
+                # Not a datetime string, return as-is
+                pass
+            return obj
+        elif isinstance(obj, dict):
+            return {
+                k: cls._deserialize_datetime_recursive(v)
+                for k, v in obj.items()
+            }
+        elif isinstance(obj, list):
+            return [cls._deserialize_datetime_recursive(item) for item in obj]
+        else:
+            return obj

{lionagi-0.14.3 → lionagi-0.14.5}/lionagi/libs/concurrency/__init__.py

@@ -1,4 +1,4 @@
-"""Structured concurrency primitives.
+"""Structured concurrency primitives for pynector.
 
 This module provides structured concurrency primitives using AnyIO,
 which allows for consistent behavior across asyncio and trio backends.
@@ -6,7 +6,21 @@ which allows for consistent behavior across asyncio and trio backends.
 
 from .cancel import CancelScope, fail_after, move_on_after
 from .errors import get_cancelled_exc_class, shield
+from .patterns import (
+    ConnectionPool,
+    WorkerPool,
+    parallel_requests,
+    retry_with_timeout,
+)
 from .primitives import CapacityLimiter, Condition, Event, Lock, Semaphore
+from .resource_tracker import (
+    ResourceTracker,
+    cleanup_check,
+    get_global_tracker,
+    resource_leak_detector,
+    track_resource,
+    untrack_resource,
+)
 from .task import TaskGroup, create_task_group
 
 __all__ = [
@@ -15,6 +29,10 @@ __all__ = [
     "CancelScope",
     "move_on_after",
     "fail_after",
+    "ConnectionPool",
+    "WorkerPool",
+    "parallel_requests",
+    "retry_with_timeout",
     "Lock",
     "Semaphore",
     "CapacityLimiter",
@@ -22,4 +40,10 @@ __all__ = [
     "Condition",
     "get_cancelled_exc_class",
     "shield",
+    "ResourceTracker",
+    "resource_leak_detector",
+    "track_resource",
+    "untrack_resource",
+    "cleanup_check",
+    "get_global_tracker",
 ]

lionagi-0.14.5/lionagi/libs/concurrency/patterns.py

@@ -0,0 +1,259 @@
+"""Common concurrency patterns for structured concurrency."""
+
+from __future__ import annotations
+
+import logging
+from collections.abc import Awaitable, Callable
+from types import TracebackType
+from typing import Any, TypeVar
+
+import anyio
+
+from .cancel import move_on_after
+from .primitives import CapacityLimiter, Lock
+from .resource_tracker import track_resource, untrack_resource
+from .task import create_task_group
+
+logger = logging.getLogger(__name__)
+
+T = TypeVar("T")
+R = TypeVar("R")
+Response = TypeVar("Response")
+
+
+class ConnectionPool:
+    """A pool of reusable connections."""
+
+    def __init__(
+        self,
+        max_connections: int,
+        connection_factory: Callable[[], Awaitable[T]],
+    ):
+        """Initialize a new connection pool."""
+        if max_connections < 1:
+            raise ValueError("max_connections must be >= 1")
+        if not callable(connection_factory):
+            raise ValueError("connection_factory must be callable")
+
+        self._connection_factory = connection_factory
+        self._limiter = CapacityLimiter(max_connections)
+        self._connections: list[T] = []
+        self._lock = Lock()
+
+        track_resource(self, f"ConnectionPool-{id(self)}", "ConnectionPool")
+
+    def __del__(self):
+        """Clean up resource tracking."""
+        try:
+            untrack_resource(self)
+        except Exception:
+            pass
+
+    async def acquire(self) -> T:
+        """Acquire a connection from the pool."""
+        await self._limiter.acquire()
+
+        try:
+            async with self._lock:
+                if self._connections:
+                    return self._connections.pop()
+
+            # No pooled connection available, create new one
+            return await self._connection_factory()
+        except Exception:
+            self._limiter.release()
+            raise
+
+    async def release(self, connection: T) -> None:
+        """Release a connection back to the pool."""
+        try:
+            async with self._lock:
+                self._connections.append(connection)
+        finally:
+            self._limiter.release()
+
+    async def __aenter__(self) -> ConnectionPool[T]:
+        """Enter the connection pool context."""
+        return self
+
+    async def __aexit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc_val: BaseException | None,
+        exc_tb: TracebackType | None,
+    ) -> None:
+        """Exit the connection pool context."""
+        # Clean up any remaining connections
+        async with self._lock:
+            self._connections.clear()
+
+
+async def parallel_requests(
+    inputs: list[str],
+    func: Callable[[str], Awaitable[Response]],
+    max_concurrency: int = 10,
+) -> list[Response]:
+    """Execute requests in parallel with controlled concurrency.
+
+    Args:
+        inputs: List of inputs
+        fetch_func: Async function
+        max_concurrency: Maximum number of concurrent requests
+
+    Returns:
+        List of responses in the same order as inputs
+    """
+    if not inputs:
+        return []
+
+    results: list[Response | None] = [None] * len(inputs)
+
+    async def bounded_fetch(
+        semaphore: anyio.Semaphore, idx: int, url: str
+    ) -> None:
+        async with semaphore:
+            results[idx] = await func(url)
+
+    try:
+        async with create_task_group() as tg:
+            semaphore = anyio.Semaphore(max_concurrency)
+
+            for i, inp in enumerate(inputs):
+                await tg.start_soon(bounded_fetch, semaphore, i, inp)
+    except BaseException as e:
+        # Re-raise the first exception directly instead of ExceptionGroup
+        if hasattr(e, "exceptions") and e.exceptions:
+            raise e.exceptions[0]
+        else:
+            raise
+
+    return results  # type: ignore
+
+
+async def retry_with_timeout(
+    func: Callable[[], Awaitable[T]],
+    max_retries: int = 3,
+    timeout: float = 30.0,
+    backoff_factor: float = 1.0,
+) -> T:
+    """Retry an async function with exponential backoff and timeout.
+
+    Args:
+        func: The async function to retry
+        max_retries: Maximum number of retries
+        timeout: Timeout for each attempt
+        backoff_factor: Multiplier for exponential backoff
+
+    Returns:
+        The result of the successful function call
+
+    Raises:
+        Exception: The last exception raised by the function
+    """
+    last_exception = None
+
+    for attempt in range(max_retries):
+        try:
+            with move_on_after(timeout) as cancel_scope:
+                result = await func()
+                if not cancel_scope.cancelled_caught:
+                    return result
+                else:
+                    raise TimeoutError(f"Function timed out after {timeout}s")
+        except Exception as e:
+            last_exception = e
+            if attempt < max_retries - 1:
+                delay = backoff_factor * (2**attempt)
+                await anyio.sleep(delay)
+            continue
+
+    if last_exception:
+        raise last_exception
+    else:
+        raise RuntimeError("Retry failed without capturing exception")
+
+
+class WorkerPool:
+    """A pool of worker tasks that process items from a queue."""
+
+    def __init__(
+        self, num_workers: int, worker_func: Callable[[Any], Awaitable[None]]
+    ):
+        """Initialize a new worker pool."""
+        if num_workers < 1:
+            raise ValueError("num_workers must be >= 1")
+        if not callable(worker_func):
+            raise ValueError("worker_func must be callable")
+
+        self._num_workers = num_workers
+        self._worker_func = worker_func
+        self._queue = anyio.create_memory_object_stream(1000)
+        self._task_group = None
+
+        track_resource(self, f"WorkerPool-{id(self)}", "WorkerPool")
+
+    def __del__(self):
+        """Clean up resource tracking."""
+        try:
+            untrack_resource(self)
+        except Exception:
+            pass
+
+    async def start(self) -> None:
+        """Start the worker pool."""
+        if self._task_group is not None:
+            raise RuntimeError("Worker pool is already started")
+
+        self._task_group = create_task_group()
+        await self._task_group.__aenter__()
+
+        # Start worker tasks
+        for i in range(self._num_workers):
+            await self._task_group.start_soon(self._worker_loop)
+
+    async def stop(self) -> None:
+        """Stop the worker pool."""
+        if self._task_group is None:
+            return
+
+        # Close the queue to signal workers to stop
+        await self._queue[0].aclose()
+
+        # Wait for all workers to finish
+        try:
+            await self._task_group.__aexit__(None, None, None)
+        finally:
+            self._task_group = None
+
+    async def submit(self, item: Any) -> None:
+        """Submit an item for processing."""
+        if self._task_group is None:
+            raise RuntimeError("Worker pool is not started")
+        await self._queue[0].send(item)
+
+    async def _worker_loop(self) -> None:
+        """Main loop for worker tasks."""
+        try:
+            async with self._queue[1]:
+                async for item in self._queue[1]:
+                    try:
+                        await self._worker_func(item)
+                    except Exception as e:
+                        logger.error(f"Worker error processing item: {e}")
+        except anyio.ClosedResourceError:
+            # Queue was closed, worker should exit gracefully
+            pass
+
+    async def __aenter__(self) -> WorkerPool:
+        """Enter the worker pool context."""
+        await self.start()
+        return self
+
+    async def __aexit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc_val: BaseException | None,
+        exc_tb: TracebackType | None,
+    ) -> None:
+        """Exit the worker pool context."""
+        await self.stop()