lionagi 0.15.13__py3-none-any.whl → 0.16.0__py3-none-any.whl

lionagi/ln/_async_call.py

@@ -7,11 +7,16 @@ import anyio
 import anyio.to_thread
 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
+from .concurrency import (
+    Semaphore,
+    create_task_group,
+    get_cancelled_exc_class,
+    is_coro_func,
+    move_on_after,
+)
+from .types import Params, T, Unset, not_sentinel
 
 __all__ = (
     "alcall",
@@ -101,7 +106,7 @@ async def alcall(
         if coro_func:
             # Async function
             if retry_timeout is not None:
-                with anyio.move_on_after(retry_timeout) as cancel_scope:
+                with move_on_after(retry_timeout) as cancel_scope:
                     result = await func(item, **kwargs)
                 if cancel_scope.cancelled_caught:
                     raise asyncio.TimeoutError(
@@ -113,7 +118,7 @@ async def alcall(
         else:
             # Sync function
             if retry_timeout is not None:
-                with anyio.move_on_after(retry_timeout) as cancel_scope:
+                with move_on_after(retry_timeout) as cancel_scope:
                     result = await anyio.to_thread.run_sync(
                         func, item, **kwargs
                     )
@@ -134,7 +139,7 @@ async def alcall(
                 return index, result
 
             # if cancelled, re-raise
-            except anyio.get_cancelled_exc_class():
+            except get_cancelled_exc_class():
                 raise
 
             # handle other exceptions
@@ -173,7 +178,7 @@ async def alcall(
     # 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)
+            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)
@@ -292,6 +297,4 @@ class BcallParams(AlcallParams):
         self, input_: list[Any], func: Callable[..., T], **kw
     ) -> list[T]:
         kwargs = {**self.default_kw(), **kw}
-        func = self._func
-
-        return await func(input_, func, self.batch_size, **kwargs)
+        return await bcall(input_, func, self.batch_size, **kwargs)

lionagi/ln/_hash.py

@@ -1,5 +1,8 @@
+from __future__ import annotations
+
 import copy
 
+import msgspec
 from pydantic import BaseModel as PydanticBaseModel
 
 __all__ = ("hash_dict",)
@@ -12,6 +15,7 @@ _TYPE_MARKER_TUPLE = 2
 _TYPE_MARKER_SET = 3
 _TYPE_MARKER_FROZENSET = 4
 _TYPE_MARKER_PYDANTIC = 5  # Distinguishes dumped Pydantic models
+_TYPE_MARKER_MSGSPEC = 6  # Distinguishes msgspec Structs
 
 
 def _generate_hashable_representation(item: any) -> any:
@@ -23,6 +27,14 @@ def _generate_hashable_representation(item: any) -> any:
     if isinstance(item, _PRIMITIVE_TYPES):
         return item
 
+    # Handle msgspec Structs
+    if isinstance(item, msgspec.Struct):
+        # Use msgspec.to_builtins for efficient conversion to built-in types
+        return (
+            _TYPE_MARKER_MSGSPEC,
+            _generate_hashable_representation(msgspec.to_builtins(item)),
+        )
+
     if isinstance(item, PydanticBaseModel):
         # Process the Pydantic model by first dumping it to a dict, then processing that dict.
         # The type marker distinguishes this from a regular dictionary.
@@ -58,9 +70,15 @@ def _generate_hashable_representation(item: any) -> any:
         try:  # Attempt direct sort for comparable elements
             sorted_elements = sorted(list(item))
         except TypeError:  # Fallback for unorderable mixed types
-            sorted_elements = sorted(
-                list(item), key=lambda x: (str(type(x)), str(x))
-            )
+
+            def sort_key(x):
+                # Deterministic ordering across mixed, unorderable types
+                # Sort strictly by textual type then textual value.
+                # This also naturally places bool before int because
+                # "<class 'bool'>" < "<class 'int'>" lexicographically.
+                return (str(type(x)), str(x))
+
+            sorted_elements = sorted(list(item), key=sort_key)
         return (
             _TYPE_MARKER_FROZENSET,
             tuple(
@@ -73,9 +91,12 @@ def _generate_hashable_representation(item: any) -> any:
         try:
             sorted_elements = sorted(list(item))
         except TypeError:
-            sorted_elements = sorted(
-                list(item), key=lambda x: (str(type(x)), str(x))
-            )
+            # For mixed types, use a deterministic, portable sort key
+            def sort_key(x):
+                # Sort by textual type then textual value for stability.
+                return (str(type(x)), str(x))
+
+            sorted_elements = sorted(list(item), key=sort_key)
         return (
             _TYPE_MARKER_SET,
             tuple(
@@ -87,8 +108,12 @@ def _generate_hashable_representation(item: any) -> any:
     # Fallback for other types (e.g., custom objects not derived from the above)
     try:
         return str(item)
-    except Exception:  # If str() fails for some reason
-        return repr(item)
+    except Exception:
+        try:
+            return repr(item)
+        except Exception:
+            # If both str() and repr() fail, return a stable fallback based on type and id
+            return f"<unhashable:{type(item).__name__}:{id(item)}>"
 
 
 def hash_dict(data: any, strict: bool = False) -> int:

lionagi/ln/_list_call.py

@@ -1,14 +1,12 @@
 from collections.abc import Callable, Iterable
-from dataclasses import dataclass
-from typing import Any, ClassVar, TypeVar
+from typing import Any, TypeVar
 
-from ._models import Params
 from ._to_list import to_list
 
 R = TypeVar("R")
 T = TypeVar("T")
 
-__all__ = ("lcall", "LcallParams")
+__all__ = ("lcall",)
 
 
 def lcall(
@@ -97,34 +95,3 @@ def lcall(
         )
 
     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/ln/_to_list.py

@@ -3,21 +3,24 @@ from dataclasses import dataclass
 from enum import Enum as _Enum
 from typing import Any, ClassVar
 
+from msgspec import Struct
 from pydantic import BaseModel
 from pydantic_core import PydanticUndefinedType
 
 from ._hash import hash_dict
-from ._models import Params
-from ._types import UndefinedType, UnsetType
+from .types import Params, UndefinedType, UnsetType
 
 __all__ = ("to_list", "ToListParams")
 
 
-_SKIP_TYPE = (str, bytes, bytearray, Mapping, BaseModel, _Enum)
-_TUPLE_SET_TYPES = (tuple, set, frozenset)
-_SKIP_TUPLE_SET = (*_SKIP_TYPE, *_TUPLE_SET_TYPES)
+_BYTE_LIKE = (str, bytes, bytearray)
+_MODEL_LIKE = (BaseModel, Struct)
+_MAP_LIKE = (Mapping, *_MODEL_LIKE)
+_TUPLE_SET = (tuple, set, frozenset)
 _SINGLETONE_TYPES = (UndefinedType, UnsetType, PydanticUndefinedType)
-_BYTE_LIKE_TYPES = (str, bytes, bytearray)
+
+_SKIP_TYPE = (*_BYTE_LIKE, *_MAP_LIKE, _Enum)
+_SKIP_TUPLE_SET = (*_SKIP_TYPE, *_TUPLE_SET)
 
 
 def to_list(
@@ -104,7 +107,7 @@ def to_list(
                 else list(members)
             )
 
-        if isinstance(input_, _BYTE_LIKE_TYPES):
+        if isinstance(input_, _BYTE_LIKE):
             return list(input_) if use_values else [input_]
 
         if isinstance(input_, Mapping):
@@ -117,9 +120,7 @@ def to_list(
         if isinstance(input_, BaseModel):
             return [input_]
 
-        if isinstance(input_, Iterable) and not isinstance(
-            input_, _BYTE_LIKE_TYPES
-        ):
+        if isinstance(input_, Iterable) and not isinstance(input_, _BYTE_LIKE):
             return list(input_)
 
         return [input_]
@@ -133,24 +134,46 @@ def to_list(
     if unique:
         seen = set()
         out = []
-        try:
-            return [x for x in processed if not (x in seen or seen.add(x))]
-        except TypeError:
-            for i in processed:
-                hash_value = None
-                try:
-                    hash_value = hash(i)
-                except TypeError:
-                    if isinstance(i, (BaseModel, Mapping)):
-                        hash_value = hash_dict(i)
-                    else:
-                        raise ValueError(
-                            "Unhashable type encountered in list unique value processing."
-                        )
-                if hash_value not in seen:
-                    seen.add(hash_value)
-                    out.append(i)
-            return out
+        use_hash_fallback = False
+        for i in processed:
+            try:
+                if not use_hash_fallback:
+                    # Direct approach - try to use the item as hash key
+                    if i not in seen:
+                        seen.add(i)
+                        out.append(i)
+                else:
+                    # Hash-based approach for unhashable items
+                    hash_value = (
+                        hash(i)
+                        if hasattr(i, "__hash__") and i.__hash__ is not None
+                        else hash_dict(i)
+                    )
+                    if hash_value not in seen:
+                        seen.add(hash_value)
+                        out.append(i)
+            except TypeError:
+                # Switch to hash-based approach and restart
+                if not use_hash_fallback:
+                    use_hash_fallback = True
+                    seen = set()
+                    out = []
+                    # Restart from beginning with hash-based approach
+                    for j in processed:
+                        try:
+                            hash_value = hash(j)
+                        except TypeError:
+                            if isinstance(j, _MAP_LIKE):
+                                hash_value = hash_dict(j)
+                            else:
+                                raise ValueError(
+                                    "Unhashable type encountered in list unique value processing."
+                                )
+                        if hash_value not in seen:
+                            seen.add(hash_value)
+                            out.append(j)
+                    break
+        return out
 
     return processed
 

lionagi/ln/_utils.py

@@ -0,0 +1,156 @@
+import importlib.util
+import uuid
+from datetime import datetime, timezone
+from pathlib import Path as StdPath
+from typing import Any
+
+from anyio import Path as AsyncPath
+
+__all__ = (
+    "now_utc",
+    "acreate_path",
+    "get_bins",
+    "import_module",
+    "is_import_installed",
+)
+
+
+def now_utc() -> datetime:
+    return datetime.now(timezone.utc)
+
+
+async def acreate_path(
+    directory: StdPath | AsyncPath | str,
+    filename: str,
+    extension: str = None,
+    timestamp: bool = False,
+    dir_exist_ok: bool = True,
+    file_exist_ok: bool = False,
+    time_prefix: bool = False,
+    timestamp_format: str | None = None,
+    random_hash_digits: int = 0,
+) -> AsyncPath:
+    """
+    Generate a new file path asynchronously with optional timestamp and a random suffix.
+    Uses non-blocking I/O (AnyIO).
+    """
+
+    # Use AsyncPath for construction and execution
+    if "/" in filename:
+        sub_dir, filename = filename.split("/")[:-1], filename.split("/")[-1]
+        directory = AsyncPath(directory) / "/".join(sub_dir)
+
+    if "\\" in filename:
+        raise ValueError("Filename cannot contain directory separators.")
+
+    # Ensure directory is an AsyncPath
+    directory = AsyncPath(directory)
+    if "." in filename:
+        name, ext = filename.rsplit(".", 1)
+    else:
+        name, ext = filename, extension
+    ext = f".{ext.lstrip('.')}" if ext else ""
+
+    if timestamp:
+        # datetime.now() is generally non-blocking
+        ts_str = datetime.now().strftime(timestamp_format or "%Y%m%d%H%M%S")
+        name = f"{ts_str}_{name}" if time_prefix else f"{name}_{ts_str}"
+
+    if random_hash_digits > 0:
+        random_suffix = uuid.uuid4().hex[:random_hash_digits]
+        name = f"{name}-{random_suffix}"
+
+    full_path = directory / f"{name}{ext}"
+
+    # --- CRITICAL: ASYNC I/O Operations ---
+    await full_path.parent.mkdir(parents=True, exist_ok=dir_exist_ok)
+
+    if await full_path.exists() and not file_exist_ok:
+        raise FileExistsError(
+            f"File {full_path} already exists and file_exist_ok is False."
+        )
+
+    return full_path
+
+
+def get_bins(input_: list[str], upper: int) -> list[list[int]]:
+    """Organizes indices of strings into bins based on a cumulative upper limit.
+
+    Args:
+        input_ (List[str]): The list of strings to be binned.
+        upper (int): The cumulative length upper limit for each bin.
+
+    Returns:
+        List[List[int]]: A list of bins, each bin is a list of indices from the input list.
+    """
+    current = 0
+    bins = []
+    current_bin = []
+    for idx, item in enumerate(input_):
+        if current + len(item) < upper:
+            current_bin.append(idx)
+            current += len(item)
+        else:
+            bins.append(current_bin)
+            current_bin = [idx]
+            current = len(item)
+    if current_bin:
+        bins.append(current_bin)
+    return bins
+
+
+def import_module(
+    package_name: str,
+    module_name: str = None,
+    import_name: str | list = None,
+) -> Any:
+    """
+    Import a module by its path.
+
+    Args:
+        module_path: The path of the module to import.
+
+    Returns:
+        The imported module.
+
+    Raises:
+        ImportError: If the module cannot be imported.
+    """
+    try:
+        full_import_path = (
+            f"{package_name}.{module_name}" if module_name else package_name
+        )
+
+        if import_name:
+            import_name = (
+                [import_name]
+                if not isinstance(import_name, list)
+                else import_name
+            )
+            a = __import__(
+                full_import_path,
+                fromlist=import_name,
+            )
+            if len(import_name) == 1:
+                return getattr(a, import_name[0])
+            return [getattr(a, name) for name in import_name]
+        else:
+            return __import__(full_import_path)
+
+    except ImportError as e:
+        raise ImportError(
+            f"Failed to import module {full_import_path}: {e}"
+        ) from e
+
+
+def is_import_installed(package_name: str) -> bool:
+    """
+    Check if a package is installed.
+
+    Args:
+        package_name: The name of the package to check.
+
+    Returns:
+        bool: True if the package is installed, False otherwise.
+    """
+    return importlib.util.find_spec(package_name) is not None

lionagi/ln/concurrency/__init__.py

@@ -1,23 +1,25 @@
-"""Structured concurrency primitives for pynector.
-
-This module provides structured concurrency primitives using AnyIO,
-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 ._compat import ExceptionGroup
+from .cancel import (
+    CancelScope,
+    effective_deadline,
+    fail_after,
+    fail_at,
+    move_on_after,
+    move_on_at,
+)
+from .errors import get_cancelled_exc_class, is_cancelled, shield
+from .patterns import CompletionStream, bounded_map, gather, race, retry
+from .primitives import (
+    CapacityLimiter,
+    Condition,
+    Event,
+    Lock,
+    Queue,
+    Semaphore,
 )
-from .primitives import CapacityLimiter, Condition, Event, Lock, Semaphore
 from .resource_tracker import (
-    ResourceTracker,
-    cleanup_check,
-    get_global_tracker,
-    resource_leak_detector,
+    LeakInfo,
+    LeakTracker,
     track_resource,
     untrack_resource,
 )
@@ -25,29 +27,35 @@ from .task import TaskGroup, create_task_group
 from .utils import is_coro_func
 
 ConcurrencyEvent = Event
+
 __all__ = (
-    "TaskGroup",
-    "create_task_group",
     "CancelScope",
-    "move_on_after",
     "fail_after",
-    "ConnectionPool",
-    "WorkerPool",
-    "parallel_requests",
-    "retry_with_timeout",
+    "move_on_after",
+    "fail_at",
+    "move_on_at",
+    "effective_deadline",
+    "get_cancelled_exc_class",
+    "is_cancelled",
+    "shield",
+    "TaskGroup",
+    "create_task_group",
     "Lock",
     "Semaphore",
     "CapacityLimiter",
+    "Queue",
     "Event",
     "Condition",
-    "get_cancelled_exc_class",
-    "shield",
-    "ResourceTracker",
-    "resource_leak_detector",
+    "gather",
+    "race",
+    "bounded_map",
+    "retry",
+    "CompletionStream",
     "track_resource",
     "untrack_resource",
-    "cleanup_check",
-    "get_global_tracker",
+    "LeakInfo",
+    "LeakTracker",
     "is_coro_func",
     "ConcurrencyEvent",
+    "ExceptionGroup",
 )

lionagi/ln/concurrency/_compat.py

@@ -0,0 +1,65 @@
+"""Compatibility layer for Python 3.10+ support.
+
+Provides ExceptionGroup backport and other compatibility utilities.
+"""
+
+from __future__ import annotations
+
+import sys
+from collections.abc import Sequence
+
+# ExceptionGroup compatibility for Python 3.10
+if sys.version_info >= (3, 11):
+    # Python 3.11+ has built-in ExceptionGroup
+    from builtins import ExceptionGroup as _ExceptionGroup
+
+    BaseExceptionGroup = _ExceptionGroup
+    ExceptionGroup = _ExceptionGroup
+
+else:
+    # Python 3.10: Use exceptiongroup backport
+    try:
+        from exceptiongroup import BaseExceptionGroup, ExceptionGroup
+    except ImportError:
+        # Fallback implementation for environments without exceptiongroup
+        class BaseExceptionGroup(BaseException):  # type: ignore
+            """Minimal BaseExceptionGroup implementation for Python 3.10 without exceptiongroup."""
+
+            def __init__(
+                self, message: str, exceptions: Sequence[BaseException]
+            ) -> None:
+                super().__init__(message)
+                self.message = message
+                self.exceptions = tuple(exceptions)
+
+            def __str__(self) -> str:
+                return (
+                    f"{self.message} ({len(self.exceptions)} sub-exceptions)"
+                )
+
+        class ExceptionGroup(BaseExceptionGroup, Exception):  # type: ignore
+            """Minimal ExceptionGroup implementation for Python 3.10 without exceptiongroup."""
+
+            pass
+
+
+def is_exception_group(exc: BaseException) -> bool:
+    """Check if exception is an ExceptionGroup (compatible across Python versions)."""
+    return isinstance(exc, BaseExceptionGroup)
+
+
+def get_exception_group_exceptions(
+    exc: BaseException,
+) -> Sequence[BaseException]:
+    """Get exceptions from ExceptionGroup, or return single exception in list."""
+    if is_exception_group(exc):
+        return getattr(exc, "exceptions", (exc,))
+    return (exc,)
+
+
+__all__ = [
+    "BaseExceptionGroup",
+    "ExceptionGroup",
+    "is_exception_group",
+    "get_exception_group_exceptions",
+]