lionagi 0.14.2__tar.gz → 0.14.4__tar.gz

{lionagi-0.14.2 → lionagi-0.14.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lionagi
-Version: 0.14.2
+Version: 0.14.4
 Summary: An Intelligence Operating System.
 Author-email: HaiyangLi <quantocean.li@gmail.com>, Liangbingyan Luo <llby_luo@outlook.com>
 License:            Apache License
@@ -224,7 +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: json-repair>=0.40.0
 Requires-Dist: matplotlib>=3.9.0
 Requires-Dist: pillow>=11.0.0
 Requires-Dist: psutil>=7.0.0
@@ -234,11 +234,13 @@ Requires-Dist: python-dotenv>=1.1.0
 Requires-Dist: tiktoken>=0.8.0
 Requires-Dist: toml>=0.9.0
 Provides-Extra: all
+Requires-Dist: aiosqlite>=0.21.0; extra == 'all'
 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: ollama>=0.4.0; extra == 'all'
+Requires-Dist: pydapter[postgres]; extra == 'all'
 Requires-Dist: rich>=13.0.0; extra == 'all'
 Provides-Extra: claude-code
 Requires-Dist: claude-code-sdk>=0.0.14; extra == 'claude-code'
@@ -254,6 +256,9 @@ Provides-Extra: mcp
 Requires-Dist: fastmcp>=2.10.5; extra == 'mcp'
 Provides-Extra: ollama
 Requires-Dist: ollama>=0.4.0; extra == 'ollama'
+Provides-Extra: postgres
+Requires-Dist: aiosqlite>=0.21.0; extra == 'postgres'
+Requires-Dist: pydapter[postgres]; extra == 'postgres'
 Provides-Extra: reader
 Requires-Dist: docling>=2.15.1; extra == 'reader'
 Provides-Extra: rich

lionagi-0.14.4/lionagi/adapters/async_postgres_adapter.py

@@ -0,0 +1,362 @@
+"""
+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.
+"""
+
+from __future__ import annotations
+
+from datetime import datetime
+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]"`.'
+    )
+
+
+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
+
+    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
+    """
+
+    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,
+        subj,
+        /,
+        *,
+        many: bool = True,
+        adapt_meth: str = "model_dump",
+        **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
+
+    @classmethod
+    async def _ensure_table_exists(cls, engine_url: str, 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]
+        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.4/lionagi/adapters/postgres_model_adapter.py

@@ -0,0 +1,131 @@
+"""
+Clean LionAGI PostgreSQL adapter for integration into lionagi core.
+
+This adapter handles the metadata field conflict and provides seamless
+PostgreSQL persistence for lionagi Nodes.
+"""
+
+from __future__ import annotations
+
+from typing import Any, 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]"`.'
+    )
+
+
+class LionAGIPostgresAdapter(PostgresModelAdapter):
+    """
+    PostgreSQL adapter for lionagi Nodes with automatic metadata field mapping.
+
+    Solves the core issue where lionagi's 'metadata' field conflicts with
+    SQLAlchemy's reserved 'metadata' attribute by automatically mapping it
+    to 'node_metadata' in the database schema.
+
+    Features:
+    - Automatic metadata field mapping (metadata → node_metadata)
+    - Handles Union types like list[float] | None for embedding fields
+    - Preserves all PostgreSQL-specific type support from parent
+    - Transparent to lionagi users - Elements work seamlessly
+    """
+
+    # Core field mapping to resolve SQLAlchemy conflicts
+    FIELD_MAPPINGS = {"metadata": "node_metadata"}
+
+    def __init__(self):
+        super().__init__()
+        self._register_lionagi_types()
+
+    def _register_lionagi_types(self):
+        """Register lionagi-specific type mappings."""
+        try:
+            # Handle lionagi IDType as String (UUID)
+            from lionagi.protocols.generic.element import IDType
+
+            self.register_type_mapping(
+                python_type=IDType,
+                sql_type_factory=lambda: String(36),  # UUID string length
+                python_to_sql=lambda x: str(x),
+                sql_to_python=lambda x: IDType.validate(x) if x else None,
+            )
+        except ImportError:
+            pass  # lionagi not available
+
+    @classmethod
+    def pydantic_model_to_sql(
+        cls,
+        model: type[BaseModel],
+        *,
+        table_name: str | None = None,
+        pk_field: str = "id",
+        schema: str | None = None,
+    ) -> type[DeclarativeBase]:
+        """
+        Generate SQLAlchemy model with lionagi field mapping.
+
+        Automatically handles:
+        - metadata → node_metadata mapping
+        - Union type resolution (e.g., list[float] | None → list[float])
+        - Standard lionagi Node field structure
+        """
+
+        # Create modified field mapping for lionagi compatibility
+        modified_fields = {}
+
+        for name, info in model.model_fields.items():
+            # Apply field name mapping
+            field_name = cls.FIELD_MAPPINGS.get(name, name)
+
+            # Resolve Union types by extracting non-None type
+            annotation = info.annotation
+            origin = get_origin(annotation)
+
+            if origin is Union or (
+                hasattr(annotation, "__class__")
+                and annotation.__class__.__name__ == "UnionType"
+            ):
+                args = get_args(annotation)
+                non_none_args = [arg for arg in args if arg is not type(None)]
+                if len(non_none_args) == 1:
+                    annotation = non_none_args[0]
+
+            # Create field info with resolved annotation
+            from pydantic.fields import FieldInfo
+
+            modified_fields[field_name] = FieldInfo(
+                annotation=annotation,
+                default=info.default,
+                default_factory=info.default_factory,
+                alias=info.alias,
+                title=info.title,
+                description=info.description,
+                json_schema_extra=info.json_schema_extra,
+                frozen=info.frozen,
+                validate_default=info.validate_default,
+                repr=info.repr,
+                init_var=info.init_var,
+                kw_only=info.kw_only,
+            )
+
+        # Create temporary model with mapped fields
+        class ModifiedModel(BaseModel):
+            model_config = getattr(model, "model_config", {})
+
+        ModifiedModel.model_fields = modified_fields
+        ModifiedModel.__name__ = model.__name__
+
+        # Generate SQLAlchemy model with parent's logic
+        return super().pydantic_model_to_sql(
+            ModifiedModel,
+            table_name=table_name,
+            pk_field=pk_field,
+            schema=schema,
+        )

{lionagi-0.14.2 → lionagi-0.14.4}/lionagi/protocols/graph/node.py

@@ -72,10 +72,12 @@ class Node(Element, Relational, AsyncAdaptable, Adaptable):
         self, obj_key: str, many=False, **kwargs: Any
     ) -> Any:
         kwargs["adapt_meth"] = "to_dict"
-        return super().adapt_to_async(obj_key, many=many, **kwargs)
+        return await super().adapt_to_async(
+            obj_key=obj_key, many=many, **kwargs
+        )
 
     @classmethod
-    def adapt_from_async(
+    async def adapt_from_async(
         cls,
         obj: Any,
         obj_key: str,
@@ -83,7 +85,7 @@ class Node(Element, Relational, AsyncAdaptable, Adaptable):
         **kwargs: Any,
     ) -> Node:
         kwargs["adapt_meth"] = "from_dict"
-        return super().adapt_from_async(
+        return await super().adapt_from_async(
             obj, obj_key=obj_key, many=many, **kwargs
         )
 
@@ -92,7 +94,7 @@ class Node(Element, Relational, AsyncAdaptable, Adaptable):
         Convert this Node to another format using a registered adapter.
         """
         kwargs["adapt_meth"] = "to_dict"
-        return super().adapt_to(obj_key, many=many, **kwargs)
+        return super().adapt_to(obj_key=obj_key, many=many, **kwargs)
 
     @classmethod
     def adapt_from(

lionagi-0.14.4/lionagi/version.py

@@ -0,0 +1 @@
+__version__ = "0.14.4"

{lionagi-0.14.2 → lionagi-0.14.4}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "lionagi"
-version = "0.14.2"
+version = "0.14.4"
 description = "An Intelligence Operating System."
 authors = [
     { name = "HaiyangLi", email = "quantocean.li@gmail.com" },
@@ -14,7 +14,7 @@ dependencies = [
     "anyio>=4.8.0",
     "backoff>=2.2.1",
     "jinja2>=3.1.0",
-    "json-repair>=0.47.8",
+    "json-repair>=0.40.0",
     "matplotlib>=3.9.0",
     "pillow>=11.0.0",
     "psutil>=7.0.0",
@@ -98,6 +98,11 @@ schema = [
     "datamodel-code-generator>=0.31.2",
 ]
 
+postgres = [
+    "pydapter[postgres]",
+    "aiosqlite>=0.21.0",
+]
+
 all = [
     "lionagi[reader]",
     "lionagi[ollama]",
@@ -105,6 +110,7 @@ all = [
     "lionagi[mcp]",
     "lionagi[rich]",
     "lionagi[schema]",
+    "lionagi[postgres]",
 ]