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

lionagi/__init__.py

@@ -7,9 +7,9 @@ import logging
 from pydantic import BaseModel, Field
 
 from . import _types as types
-from .operations import Operation
-from .operations import OperationGraphBuilder as Builder
-from .operations import brainstorm, flow, plan
+from . import ln as ln
+from .operations.builder import OperationGraphBuilder as Builder
+from .operations.node import Operation
 from .service.imodel import iModel
 from .session.session import Branch, Session
 from .version import __version__
@@ -28,7 +28,5 @@ __all__ = (
     "logger",
     "Builder",
     "Operation",
-    "brainstorm",
-    "flow",
-    "plan",
+    "ln",
 )

lionagi/adapters/async_postgres_adapter.py

@@ -1,16 +1,21 @@
 """
-Clean LionAGI async PostgreSQL adapter for integration into lionagi core.
-
-This adapter handles SQLAlchemy async inspection issues and lionagi data
-serialization while providing seamless async persistence.
+Simplified LionAGI async PostgreSQL adapter for pydapter v1.0.4+
+
+This adapter leverages pydapter's improved raw SQL handling.
+No workarounds needed - pydapter now properly handles:
+- Raw SQL without table parameter
+- No table inspection for raw SQL
+- ORDER BY operations
+- Both SQLite and PostgreSQL connections
 """
 
 from __future__ import annotations
 
-from datetime import datetime
-from typing import Any, ClassVar, TypeVar
+from typing import ClassVar, TypeVar
 
-from pydapter.exceptions import QueryError
+import sqlalchemy as sa
+from pydapter.extras.async_postgres_ import AsyncPostgresAdapter
+from sqlalchemy.ext.asyncio import create_async_engine
 
 from ._utils import check_async_postgres_available
 
@@ -19,61 +24,21 @@ _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")
 
 
 class LionAGIAsyncPostgresAdapter(AsyncPostgresAdapter[T]):
     """
-    Async PostgreSQL adapter for lionagi Nodes with critical fixes.
-
-    Solves core issues:
-    1. SQLAlchemy async table inspection ("Inspection on an AsyncConnection is currently not supported")
-    2. LionAGI float timestamp serialization (created_at as float → datetime)
-    3. Datetime objects in JSON content (datetime → ISO strings)
-    4. Automatic metadata field mapping via LionAGIPostgresAdapter
+    Streamlined async adapter for lionagi Nodes.
 
     Features:
-    - Works with lionagi's adapt_to_async() system
-    - Automatic schema creation for lionagi Node structure
-    - Cross-database compatibility (PostgreSQL/SQLite)
-    - Handles all lionagi data serialization edge cases
+    - Auto-creates tables with lionagi schema
+    - Inherits all pydapter v1.0.4+ improvements
+    - No workarounds needed for SQLite or raw SQL
     """
 
     obj_key: ClassVar[str] = "lionagi_async_pg"
 
-    @classmethod
-    def _table(cls, meta: sa.MetaData, name: str) -> sa.Table:
-        """
-        Override parent's _table to avoid async inspection issues.
-
-        Uses JSON for SQLite compatibility, JSONB for PostgreSQL performance.
-        """
-        # Determine JSON type based on database (check connection URL if available)
-        json_type = sa.JSON  # Default safe option that works everywhere
-
-        # Try to detect PostgreSQL from the connection
-        if hasattr(meta, "bind") and meta.bind:
-            engine_url = str(meta.bind.engine.url)
-            if "postgresql" in engine_url and "sqlite" not in engine_url:
-                json_type = sa.dialects.postgresql.JSONB
-
-        return sa.Table(
-            name,
-            meta,
-            sa.Column("id", sa.String, primary_key=True),
-            sa.Column("content", json_type),
-            sa.Column(
-                "node_metadata", json_type
-            ),  # mapped from lionagi metadata
-            sa.Column("created_at", sa.DateTime),
-            sa.Column("embedding", json_type),
-            # Note: No autoload_with to avoid async inspection error
-        )
-
     @classmethod
     async def to_obj(
         cls,
@@ -81,282 +46,53 @@ class LionAGIAsyncPostgresAdapter(AsyncPostgresAdapter[T]):
         /,
         *,
         many: bool = True,
-        adapt_meth: str = "model_dump",
+        adapt_meth: str = None,
         **kw,
     ):
-        """
-        Write lionagi Node(s) to PostgreSQL with automatic fixes.
-
-        Handles:
-        1. Table creation if needed
-        2. LionAGI data serialization fixes
-        3. Async database operations
-        """
-        try:
-            # Validate required parameters
-            engine_url = kw.get("dsn") or kw.get("engine_url")
-            table = kw.get("table")
-
-            if not engine_url or not table:
-                raise ValueError(
-                    "Missing required 'dsn' and 'table' parameters"
-                )
-
-            # Ensure table exists with lionagi schema
-            await cls._ensure_table_exists(engine_url, table)
-
-            # Prepare data with lionagi fixes
-            items = subj if isinstance(subj, list) else [subj]
-            if not items:
-                return {"inserted_count": 0}
-
-            # Convert nodes to database rows with serialization fixes
-            rows = []
-            for item in items:
-                data = getattr(item, adapt_meth)()
-                fixed_data = cls._fix_lionagi_data(data)
-                rows.append(fixed_data)
-
-            # Execute async insert
-            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)
-                await conn.execute(sa.insert(table_obj), rows)
-
-            return {"inserted_count": len(rows)}
-
-        except Exception as e:
-            raise QueryError(
-                f"Error in lionagi async adapter: {e}",
-                adapter="lionagi_async_pg",
-            ) from e
+        """Write lionagi Node(s) to database with auto-table creation."""
+        # Auto-create table if needed
+        if table := kw.get("table"):
+            if engine_url := (kw.get("dsn") or kw.get("engine_url")):
+                await cls._ensure_table(engine_url, table)
+            elif engine := kw.get("engine"):
+                await cls._ensure_table(engine, table)
+
+        return await super().to_obj(
+            subj, many=many, adapt_meth=adapt_meth, **kw
+        )
 
     @classmethod
-    async def _ensure_table_exists(cls, engine_url: str, table_name: str):
+    async def _ensure_table(cls, engine_or_url, table_name: str):
         """Create table with lionagi schema if it doesn't exist."""
-        try:
-            engine = create_async_engine(engine_url, future=True)
-            async with engine.begin() as conn:
-                meta = sa.MetaData()
-                meta.bind = conn
-
-                # Use the same _table method to ensure consistency
-                table = cls._table(meta, table_name)
-
-                # Create just this table
-                await conn.run_sync(table.create, checkfirst=True)
-
-        except Exception:
-            # Table might already exist, continue
-            pass
-
-    @classmethod
-    def _fix_lionagi_data(cls, data: dict) -> dict:
-        """
-        Fix lionagi Node data for database storage.
-
-        Handles:
-        1. Float timestamp → datetime for created_at
-        2. Datetime objects in content → ISO strings
-        """
-        # Fix created_at timestamp
-        if "created_at" in data and isinstance(
-            data["created_at"], (int, float)
-        ):
-            data["created_at"] = datetime.fromtimestamp(data["created_at"])
-
-        # Fix datetime objects in content
-        if "content" in data and isinstance(data["content"], dict):
-            data["content"] = cls._serialize_datetime_recursive(
-                data["content"]
-            )
-
-        return data
-
-    @classmethod
-    def _serialize_datetime_recursive(cls, obj: Any) -> Any:
-        """Recursively convert datetime objects to ISO strings."""
-        if isinstance(obj, datetime):
-            return obj.isoformat()
-        elif isinstance(obj, dict):
-            return {
-                k: cls._serialize_datetime_recursive(v) for k, v in obj.items()
-            }
-        elif isinstance(obj, list):
-            return [cls._serialize_datetime_recursive(item) for item in obj]
+        should_dispose = False
+        if isinstance(engine_or_url, str):
+            engine = create_async_engine(engine_or_url, future=True)
+            should_dispose = True
         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
+            engine = engine_or_url
 
-        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
+                # Determine JSON type based on database
+                engine_url = str(engine.url)
+                json_type = (
+                    sa.dialects.postgresql.JSONB
+                    if "postgresql" in engine_url
+                    else sa.JSON
+                )
 
-    @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
+                # Create table with lionagi schema
+                await conn.run_sync(
+                    lambda sync_conn: sa.Table(
+                        table_name,
+                        sa.MetaData(),
+                        sa.Column("id", sa.String, primary_key=True),
+                        sa.Column("content", json_type),
+                        sa.Column("node_metadata", json_type),
+                        sa.Column("created_at", sa.DateTime),
+                        sa.Column("embedding", json_type, nullable=True),
+                    ).create(sync_conn, checkfirst=True)
+                )
+        finally:
+            if should_dispose:
+                await engine.dispose()

lionagi/libs/file/_utils.py

@@ -0,0 +1,10 @@
+def check_docling_available():
+    try:
+        from docling.document_converter import DocumentConverter  # noqa: F401
+
+        return True
+    except Exception:
+        return ImportError(
+            "The 'docling' package is required for this feature. "
+            "Please install it via 'pip install lionagi[reader]'."
+        )

lionagi/libs/file/process.py

@@ -8,11 +8,14 @@ from concurrent.futures import ThreadPoolExecutor, as_completed
 from pathlib import Path
 from typing import Any, Literal
 
-from lionagi.utils import lcall
+from lionagi import ln
 
+from ._utils import check_docling_available
 from .chunk import chunk_content
 from .save import save_chunks
 
+_HAS_DOCLING = check_docling_available()
+
 
 def dir_to_files(
     directory: str | Path,
@@ -206,24 +209,24 @@ def chunk(
             reader_tool = lambda x: Path(x).read_text(encoding="utf-8")
 
         if reader_tool == "docling":
-            from lionagi.libs.package.imports import check_import
+            if _HAS_DOCLING is not True:
+                raise _HAS_DOCLING
 
-            DocumentConverter = check_import(
-                "docling",
-                module_name="document_converter",
-                import_name="DocumentConverter",
+            from docling.document_converter import (  # noqa: F401
+                DocumentConverter,
             )
+
             converter = DocumentConverter()
             reader_tool = lambda x: converter.convert(
                 x
             ).document.export_to_markdown()
 
-        texts = lcall(files, reader_tool)
+        texts = ln.lcall(files, reader_tool)
 
     else:
         texts = [text]
 
-    chunks = lcall(
+    chunks = ln.lcall(
         texts,
         chunk_content,
         chunk_by=chunk_by,
@@ -244,15 +247,15 @@ def chunk(
         output_file = Path(output_file)
         if output_file.suffix == ".csv":
             p = Pile(chunks)
-            p.to_csv_file(output_file)
+            p.dump(output_file, "csv")
 
-        elif output_file.suffix == ".json":
+        if output_file.suffix == "json":
             p = Pile(chunks)
-            p.to_json_file(output_file, use_pd=True)
+            p.dump(output_file, "json")
 
-        elif output_file.suffix in Pile.list_adapters():
+        if output_file.suffix == ".parquet":
             p = Pile(chunks)
-            p.adapt_to(output_file.suffix, fp=output_file)
+            p.dump(output_file, "parquet")
 
         else:
             raise ValueError(f"Unsupported output file format: {output_file}")

lionagi/libs/unstructured/pdf_to_image.py

@@ -1,4 +1,4 @@
-from lionagi.utils import check_import, is_import_installed
+from lionagi.utils import import_module, is_import_installed
 
 _HAS_PDF2IMAGE = is_import_installed("pdf2image")
 
@@ -25,7 +25,7 @@ def pdf_to_images(
 
     import os
 
-    convert_from_path = check_import(
+    convert_from_path = import_module(
         "pdf2image", import_name="convert_from_path"
     )
 

lionagi/libs/validate/string_similarity.py

@@ -320,13 +320,13 @@ def string_similarity(
     # Sort by score (descending) and index (ascending) for stable ordering
     results.sort(key=lambda x: (-x.score, x.index))
 
-    # Return results
-    if return_most_similar:
-        return results[0].word
-
     # Filter exact matches for case sensitive comparisons
     if case_sensitive:
         max_score = results[0].score
         results = [r for r in results if r.score == max_score]
 
+    # Return results
+    if return_most_similar:
+        return results[0].word
+
     return [r.word for r in results]

lionagi/ln/__init__.py

@@ -1,4 +1,6 @@
 from ._async_call import AlcallParams, BcallParams, alcall, bcall
+from ._extract_json import extract_json
+from ._fuzzy_json import fuzzy_json
 from ._hash import hash_dict
 from ._json_dump import (
     DEFAULT_SERIALIZER,
@@ -56,4 +58,30 @@ __all__ = (
     "DEFAULT_SERIALIZER",
     "DEFAULT_SERIALIZER_OPTION",
     "json_dumps",
+    "TaskGroup",
+    "create_task_group",
+    "CancelScope",
+    "move_on_after",
+    "fail_after",
+    "ConnectionPool",
+    "WorkerPool",
+    "parallel_requests",
+    "retry_with_timeout",
+    "Lock",
+    "Semaphore",
+    "CapacityLimiter",
+    "Event",
+    "Condition",
+    "get_cancelled_exc_class",
+    "shield",
+    "ResourceTracker",
+    "resource_leak_detector",
+    "track_resource",
+    "untrack_resource",
+    "cleanup_check",
+    "get_global_tracker",
+    "is_coro_func",
+    "ConcurrencyEvent",
+    "fuzzy_json",
+    "extract_json",
 )

lionagi/ln/_async_call.py

@@ -4,6 +4,7 @@ from dataclasses import dataclass
 from typing import Any, ClassVar
 
 import anyio
+import anyio.to_thread
 from pydantic import BaseModel
 
 from ._models import Params

lionagi/ln/_extract_json.py

@@ -0,0 +1,60 @@
+import re
+from typing import Any
+
+import orjson
+
+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)
+
+
+def extract_json(
+    input_data: str | list[str],
+    /,
+    *,
+    fuzzy_parse: bool = False,
+    return_one_if_single: bool = True,
+) -> dict[str, Any] | list[dict[str, Any]]:
+    """Extract and parse JSON content from a string or markdown code blocks.
+    Attempts direct JSON parsing first. If that fails, looks for JSON content
+    within markdown code blocks denoted by ```json.
+
+    Args:
+        input_data (str | list[str]): The input string or list of strings to parse.
+        fuzzy_parse (bool): If True, attempts fuzzy JSON parsing on failed attempts.
+        return_one_if_single (bool): If True and only one JSON object is found,
+            returns a dict instead of a list with one dict.
+    """
+
+    # If input_data is a list, join into a single string
+    if isinstance(input_data, list):
+        input_str = "\n".join(input_data)
+    else:
+        input_str = input_data
+
+    # 1. Try direct parsing
+    try:
+        if fuzzy_parse:
+            return fuzzy_json(input_str)
+        return orjson.loads(input_str)
+    except Exception:
+        pass
+
+    # 2. Attempt extracting JSON blocks from markdown
+    matches = _JSON_BLOCK_PATTERN.findall(input_str)
+    if not matches:
+        return []
+
+    # 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)
+
+    # Multiple matches
+    if fuzzy_parse:
+        return [fuzzy_json(m) for m in matches]
+    else:
+        return [orjson.loads(m) for m in matches]