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

lionagi/ln/concurrency/resource_tracker.py

@@ -1,182 +1,69 @@
-"""Resource tracking utilities for concurrency primitives.
+"""Lightweight resource tracking (debug aid)."""
 
-This module provides lightweight resource leak detection and lifecycle tracking
-to address the security vulnerabilities identified in the hardening tests.
-"""
+from __future__ import annotations
 
+import threading
+import time
 import weakref
 from dataclasses import dataclass
-from datetime import datetime
-from typing import Any
 
+__all__ = (
+    "track_resource",
+    "untrack_resource",
+    "LeakInfo",
+    "LeakTracker",
+)
 
-@dataclass
-class ResourceInfo:
-    """Information about a tracked resource."""
 
+@dataclass(frozen=True, slots=True)
+class LeakInfo:
     name: str
-    creation_time: datetime
-    resource_type: str
+    kind: str | None
+    created_at: float
 
 
-class ResourceTracker:
-    """Lightweight resource lifecycle tracking for leak detection.
-
-    This addresses the over-engineering concerns by providing simple,
-    practical resource management without complex abstraction layers.
-    """
-
-    def __init__(self):
-        """Initialize a new resource tracker."""
-        self._active_resources: dict[int, ResourceInfo] = {}
-        self._weak_refs: weakref.WeakKeyDictionary = (
-            weakref.WeakKeyDictionary()
-        )
+class LeakTracker:
+    def __init__(self) -> None:
+        self._live: dict[int, LeakInfo] = {}
+        self._lock = threading.Lock()
 
     def track(
-        self, resource: Any, name: str, resource_type: str | None = None
+        self, obj: object, *, name: str | None, kind: str | None
     ) -> None:
-        """Track a resource for leak detection.
-
-        Args:
-            resource: The resource to track
-            name: Human-readable name for the resource
-            resource_type: Optional type classification
-        """
-        if resource_type is None:
-            resource_type = type(resource).__name__
-
-        resource_info = ResourceInfo(
-            name=name,
-            creation_time=datetime.now(),
-            resource_type=resource_type,
+        info = LeakInfo(
+            name=name or f"obj-{id(obj)}", kind=kind, created_at=time.time()
         )
+        key = id(obj)
 
-        # Use weak reference to avoid interfering with garbage collection
-        self._weak_refs[resource] = resource_info
-        self._active_resources[id(resource)] = resource_info
-
-    def untrack(self, resource: Any) -> None:
-        """Manually untrack a resource.
-
-        Args:
-            resource: The resource to stop tracking
-        """
-        resource_id = id(resource)
-        self._active_resources.pop(resource_id, None)
-        self._weak_refs.pop(resource, None)
-
-    def cleanup_check(self) -> list[ResourceInfo]:
-        """Check for potentially leaked resources.
+        def _finalizer(_key: int = key) -> None:
+            with self._lock:
+                self._live.pop(_key, None)
 
-        Returns:
-            List of resource info for resources that may have leaked
-        """
-        # Clean up references to garbage collected objects
-        current_resources = []
-        for resource, info in list(self._weak_refs.items()):
-            current_resources.append(info)
+        with self._lock:
+            self._live[key] = info
+        weakref.finalize(obj, _finalizer)
 
-        return current_resources
+    def untrack(self, obj: object) -> None:
+        with self._lock:
+            self._live.pop(id(obj), None)
 
-    def get_active_count(self) -> int:
-        """Get the number of currently tracked resources.
+    def live(self) -> list[LeakInfo]:
+        with self._lock:
+            return list(self._live.values())
 
-        Returns:
-            Number of active tracked resources
-        """
-        return len(self._weak_refs)
+    def clear(self) -> None:
+        with self._lock:
+            self._live.clear()
 
-    def get_resource_summary(self) -> dict[str, int]:
-        """Get a summary of tracked resources by type.
 
-        Returns:
-            Dictionary mapping resource types to counts
-        """
-        summary = {}
-        for info in self._weak_refs.values():
-            resource_type = info.resource_type
-            summary[resource_type] = summary.get(resource_type, 0) + 1
-        return summary
-
-
-# Global tracker instance for convenience
-_global_tracker = ResourceTracker()
+_TRACKER = LeakTracker()
 
 
 def track_resource(
-    resource: Any, name: str, resource_type: str | None = None
+    obj: object, name: str | None = None, kind: str | None = None
 ) -> None:
-    """Track a resource using the global tracker.
-
-    Args:
-        resource: The resource to track
-        name: Human-readable name for the resource
-        resource_type: Optional type classification
-    """
-    _global_tracker.track(resource, name, resource_type)
-
-
-def untrack_resource(resource: Any) -> None:
-    """Untrack a resource using the global tracker.
-
-    Args:
-        resource: The resource to stop tracking
-    """
-    _global_tracker.untrack(resource)
-
-
-def get_global_tracker() -> ResourceTracker:
-    """Get the global resource tracker instance.
-
-    Returns:
-        The global ResourceTracker instance
-    """
-    return _global_tracker
-
-
-def cleanup_check() -> list[ResourceInfo]:
-    """Check for potentially leaked resources using global tracker.
-
-    Returns:
-        List of resource info for resources that may have leaked
-    """
-    return _global_tracker.cleanup_check()
-
-
-class resource_leak_detector:
-    """Context manager for resource leak detection in tests and production.
-
-    Example:
-        async with resource_leak_detector() as tracker:
-            lock = Lock()
-            tracker.track(lock, "test_lock")
-            # ... use lock
-        # Automatically checks for leaks on exit
-    """
-
-    def __init__(self, raise_on_leak: bool = False):
-        """Initialize the leak detector.
-
-        Args:
-            raise_on_leak: Whether to raise an exception if leaks are detected
-        """
-        self.raise_on_leak = raise_on_leak
-        self.tracker = ResourceTracker()
-        self._initial_count = 0
-
-    async def __aenter__(self) -> ResourceTracker:
-        """Enter the context and return the tracker."""
-        self._initial_count = self.tracker.get_active_count()
-        return self.tracker
+    _TRACKER.track(obj, name=name, kind=kind)
 
-    async def __aexit__(self, exc_type, exc_val, exc_tb) -> None:
-        """Exit the context and check for leaks."""
-        leaked_resources = self.tracker.cleanup_check()
 
-        if leaked_resources and self.raise_on_leak:
-            resource_summary = self.tracker.get_resource_summary()
-            raise RuntimeError(
-                f"Resource leak detected: {len(leaked_resources)} resources "
-                f"still active. Summary: {resource_summary}"
-            )
+def untrack_resource(obj: object) -> None:
+    _TRACKER.untrack(obj)

lionagi/ln/concurrency/task.py

@@ -1,9 +1,9 @@
-"""Task group implementation for structured concurrency."""
+"""Task group wrapper (thin facade over anyio.create_task_group)."""
 
 from __future__ import annotations
 
-from collections.abc import Awaitable, Callable
-from types import TracebackType
+from collections.abc import AsyncIterator, Awaitable, Callable
+from contextlib import asynccontextmanager
 from typing import Any, TypeVar
 
 import anyio
@@ -11,33 +11,55 @@ import anyio
 T = TypeVar("T")
 R = TypeVar("R")
 
+__all__ = (
+    "TaskGroup",
+    "create_task_group",
+)
+
 
 class TaskGroup:
-    """A group of tasks that are treated as a unit."""
+    """Structured concurrency task group (anyio.abc.TaskGroup wrapper).
+
+    Manages a group of concurrent tasks with structured lifecycle.
+    If any task fails, all other tasks in the group are cancelled.
+
+    Note: Lifecycle is managed by the create_task_group() context manager.
+    Do not instantiate directly.
+
+    Usage:
+        async with create_task_group() as tg:
+            tg.start_soon(worker_task, arg1)
+            tg.start_soon(worker_task, arg2)
+            # All tasks complete before exiting context
+    """
+
+    __slots__ = ("_tg",)
 
-    def __init__(self):
-        """Initialize a new task group."""
-        self._task_group = None
+    def __init__(self, tg: anyio.abc.TaskGroup) -> None:
+        self._tg = tg
 
-    async def start_soon(
+    @property
+    def cancel_scope(self) -> anyio.CancelScope:
+        """Cancel scope controlling this task group's lifetime.
+
+        Use this to cancel all tasks: tg.cancel_scope.cancel()
+        """
+        return self._tg.cancel_scope
+
+    def start_soon(
         self,
         func: Callable[..., Awaitable[Any]],
         *args: Any,
         name: str | None = None,
     ) -> None:
-        """Start a new task in this task group.
+        """Start a task without waiting for it to initialize.
 
         Args:
-            func: The coroutine function to call
-            *args: Positional arguments to pass to the function
-            name: Optional name for the task
-
-        Note:
-            This method does not wait for the task to initialize.
+            func: Async function to run as a task
+            *args: Arguments to pass to the function
+            name: Optional name for the task (for debugging)
         """
-        if self._task_group is None:
-            raise RuntimeError("Task group is not active")
-        self._task_group.start_soon(func, *args, name=name)
+        self._tg.start_soon(func, *args, name=name)
 
     async def start(
         self,
@@ -45,67 +67,27 @@ class TaskGroup:
         *args: Any,
         name: str | None = None,
     ) -> R:
-        """Start a new task and wait for it to initialize.
-
-        Args:
-            func: The coroutine function to call
-            *args: Positional arguments to pass to the function
-            name: Optional name for the task
+        """Start a task and wait for it to initialize.
 
-        Returns:
-            The value passed to task_status.started()
-
-        Note:
-            The function must accept a task_status keyword argument and call
-            task_status.started() once initialization is complete.
-        """
-        if self._task_group is None:
-            raise RuntimeError("Task group is not active")
-        return await self._task_group.start(func, *args, name=name)
-
-    async def __aenter__(self) -> TaskGroup:
-        """Enter the task group context.
-
-        Returns:
-            The task group instance.
-        """
-        task_group = anyio.create_task_group()
-        self._task_group = await task_group.__aenter__()
-        return self
+        The task function should use task_status.started() to signal initialization.
 
-    async def __aexit__(
-        self,
-        exc_type: type[BaseException] | None,
-        exc_val: BaseException | None,
-        exc_tb: TracebackType | None,
-    ) -> bool:
-        """Exit the task group context.
-
-        This will wait for all tasks in the group to complete.
-        If any task raised an exception, it will be propagated.
-        If multiple tasks raised exceptions, they will be combined into an ExceptionGroup.
+        Args:
+            func: Async function to run as a task
+            *args: Arguments to pass to the function
+            name: Optional name for the task (for debugging)
 
         Returns:
-            True if the exception was handled, False otherwise.
+            Value passed to task_status.started() by the task
         """
-        if self._task_group is None:
-            return False
+        return await self._tg.start(func, *args, name=name)
 
-        try:
-            return await self._task_group.__aexit__(exc_type, exc_val, exc_tb)
-        finally:
-            self._task_group = None
 
+@asynccontextmanager
+async def create_task_group() -> AsyncIterator[TaskGroup]:
+    """Create a new task group for structured concurrency.
 
-def create_task_group() -> TaskGroup:
-    """Create a new task group.
-
-    Returns:
-        A new task group instance.
-
-    Example:
-        async with create_task_group() as tg:
-            await tg.start_soon(task1)
-            await tg.start_soon(task2)
+    Returns an async context manager that yields a TaskGroup.
+    All tasks started within the group complete before the context exits.
     """
-    return TaskGroup()
+    async with anyio.create_task_group() as tg:
+        yield TaskGroup(tg)

lionagi/ln/concurrency/throttle.py

@@ -6,12 +6,15 @@ from collections.abc import Callable
 from time import sleep, time
 from typing import Any, TypeVar
 
+from typing_extensions import deprecated
+
 T = TypeVar("T")
 
 
 __all__ = ("Throttle",)
 
 
+@deprecated("Throttle is deprecated and will be removed in a future release.")
 class Throttle:
     """
     Provide a throttling mechanism for function calls.

lionagi/ln/concurrency/utils.py

@@ -12,4 +12,5 @@ def _is_coro_func(func: Callable[..., Any]) -> bool:
 
 
 def is_coro_func(func: Callable[..., Any]) -> bool:
+    """Check if a function is a coroutine function, with caching for performance."""
     return _is_coro_func(func)

lionagi/ln/fuzzy/__init__.py

@@ -0,0 +1,15 @@
+from ._extract_json import extract_json
+from ._fuzzy_json import fuzzy_json
+from ._fuzzy_match import FuzzyMatchKeysParams, fuzzy_match_keys
+from ._fuzzy_validate import fuzzy_validate_pydantic
+from ._string_similarity import SIMILARITY_TYPE, string_similarity
+
+__all__ = (
+    "fuzzy_json",
+    "fuzzy_match_keys",
+    "extract_json",
+    "string_similarity",
+    "SIMILARITY_TYPE",
+    "fuzzy_validate_pydantic",
+    "FuzzyMatchKeysParams",
+)

lionagi/ln/{_extract_json.py → fuzzy/_extract_json.py}

@@ -1,13 +1,16 @@
 import re
 from typing import Any
 
-import orjson
+import msgspec
 
 from ._fuzzy_json import fuzzy_json
 
 # Precompile the regex for extracting JSON code blocks
 _JSON_BLOCK_PATTERN = re.compile(r"```json\s*(.*?)\s*```", re.DOTALL)
 
+# Initialize a decoder for efficiency
+_decoder = msgspec.json.Decoder(type=Any)
+
 
 def extract_json(
     input_data: str | list[str],
@@ -37,7 +40,7 @@ def extract_json(
     try:
         if fuzzy_parse:
             return fuzzy_json(input_str)
-        return orjson.loads(input_str)
+        return _decoder.decode(input_str.encode("utf-8"))
     except Exception:
         pass
 
@@ -49,12 +52,22 @@ def extract_json(
     # If only one match, return single dict; if multiple, return list of dicts
     if return_one_if_single and len(matches) == 1:
         data_str = matches[0]
-        if fuzzy_parse:
-            return fuzzy_json(data_str)
-        return orjson.loads(data_str)
+        try:
+            if fuzzy_parse:
+                return fuzzy_json(data_str)
+            return _decoder.decode(data_str.encode("utf-8"))
+        except Exception:
+            return []
 
     # Multiple matches
-    if fuzzy_parse:
-        return [fuzzy_json(m) for m in matches]
-    else:
-        return [orjson.loads(m) for m in matches]
+    results = []
+    for m in matches:
+        try:
+            if fuzzy_parse:
+                results.append(fuzzy_json(m))
+            else:
+                results.append(_decoder.decode(m.encode("utf-8")))
+        except Exception:
+            # Skip invalid JSON blocks
+            continue
+    return results

lionagi/ln/{_fuzzy_json.py → fuzzy/_fuzzy_json.py}

@@ -2,7 +2,9 @@ import contextlib
 import re
 from typing import Any
 
-import orjson
+import msgspec
+
+_decoder = msgspec.json.Decoder(type=Any)
 
 
 def fuzzy_json(str_to_parse: str, /) -> dict[str, Any] | list[dict[str, Any]]:
@@ -10,7 +12,7 @@ def fuzzy_json(str_to_parse: str, /) -> dict[str, Any] | list[dict[str, Any]]:
     Attempt to parse a JSON string, trying a few minimal "fuzzy" fixes if needed.
 
     Steps:
-    1. Parse directly with json.loads.
+    1. Parse directly with msgspec.
     2. Replace single quotes with double quotes, normalize spacing, and try again.
     3. Attempt to fix unmatched brackets using fix_json_string.
     4. If all fail, raise ValueError.
@@ -27,19 +29,21 @@ def fuzzy_json(str_to_parse: str, /) -> dict[str, Any] | list[dict[str, Any]]:
     """
     _check_valid_str(str_to_parse)
 
+    # Use .encode("utf-8") as msgspec typically works with bytes for optimal performance
+
     # 1. Direct attempt
-    with contextlib.suppress(Exception):
-        return orjson.loads(str_to_parse)
+    with contextlib.suppress(msgspec.DecodeError):
+        return _decoder.decode(str_to_parse.encode("utf-8"))
 
     # 2. Try cleaning: replace single quotes with double and normalize
     cleaned = _clean_json_string(str_to_parse.replace("'", '"'))
-    with contextlib.suppress(Exception):
-        return orjson.loads(cleaned)
+    with contextlib.suppress(msgspec.DecodeError):
+        return _decoder.decode(cleaned.encode("utf-8"))
 
     # 3. Try fixing brackets
     fixed = fix_json_string(cleaned)
-    with contextlib.suppress(Exception):
-        return orjson.loads(fixed)
+    with contextlib.suppress(msgspec.DecodeError):
+        return _decoder.decode(fixed.encode("utf-8"))
 
     # If all attempts fail
     raise ValueError("Invalid JSON string")
@@ -59,6 +63,8 @@ def _clean_json_string(s: str) -> str:
     s = re.sub(r"(?<!\\)'", '"', s)
     # Collapse multiple whitespaces
     s = re.sub(r"\s+", " ", s)
+    # Remove trailing commas before closing brackets/braces
+    s = re.sub(r",\s*([}\]])", r"\1", s)
     # Ensure keys are quoted
     # This attempts to find patterns like { key: value } and turn them into {"key": value}
     s = re.sub(r'([{,])\s*([^"\s]+)\s*:', r'\1"\2":', s)