lionagi 0.16.2__py3-none-any.whl → 0.17.0__py3-none-any.whl

lionagi/adapters/_utils.py

@@ -1,26 +1,13 @@
 def check_async_postgres_available():
-    try:
-        import sqlalchemy as sa
-        from pydapter.extras.async_postgres_ import AsyncPostgresAdapter
-        from sqlalchemy.ext.asyncio import create_async_engine
+    from lionagi.utils import is_import_installed
 
+    all_import_present = 0
+    for pkg in ("sqlalchemy", "asyncpg"):
+        if is_import_installed(pkg):
+            all_import_present += 1
+    if all_import_present == 2:
         return True
-    except Exception:
-        return ImportError(
-            "This adapter requires postgres option to be installed. "
-            'Please install them using `uv pip install "lionagi[postgres]"`.'
-        )
-
-
-def check_postgres_available():
-    try:
-        from pydapter.model_adapters.postgres_model import PostgresModelAdapter
-        from sqlalchemy import String
-        from sqlalchemy.orm import DeclarativeBase
-
-        return True
-    except Exception:
-        return ImportError(
-            "This adapter requires postgres option to be installed. "
-            'Please install them using `uv pip install "lionagi[postgres]"`.'
-        )
+    return ImportError(
+        "This adapter requires postgres option to be installed. "
+        'Please install them using `uv pip install "lionagi[postgres]"`.'
+    )

lionagi/adapters/async_postgres_adapter.py

@@ -13,86 +13,90 @@ from __future__ import annotations
 
 from typing import ClassVar, TypeVar
 
-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
-
-_ASYNC_POSTGRES_AVAILABLE = check_async_postgres_available()
-
-if isinstance(_ASYNC_POSTGRES_AVAILABLE, ImportError):
-    raise _ASYNC_POSTGRES_AVAILABLE
+from pydapter import AsyncAdapter
 
 T = TypeVar("T")
 
 
-class LionAGIAsyncPostgresAdapter(AsyncPostgresAdapter[T]):
-    """
-    Streamlined async adapter for lionagi Nodes.
-
-    Features:
-    - 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
-    async def to_obj(
-        cls,
-        subj,
-        /,
-        *,
-        many: bool = True,
-        adapt_meth: str = None,
-        **kw,
-    ):
-        """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(cls, engine_or_url, table_name: str):
-        """Create table with lionagi schema if it doesn't exist."""
-        should_dispose = False
-        if isinstance(engine_or_url, str):
-            engine = create_async_engine(engine_or_url, future=True)
-            should_dispose = True
-        else:
-            engine = engine_or_url
-
-        try:
-            async with engine.begin() as conn:
-                # 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
-                )
-
-                # 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.Float),
-                        sa.Column("embedding", json_type, nullable=True),
-                    ).create(sync_conn, checkfirst=True)
-                )
-        finally:
-            if should_dispose:
-                await engine.dispose()
+def create_lionagi_async_postgres_adapter() -> type[AsyncAdapter]:
+    from pydapter.extras.async_postgres_ import AsyncPostgresAdapter
+
+    class LionAGIAsyncPostgresAdapter(AsyncPostgresAdapter[T]):
+        """
+        Streamlined async adapter for lionagi Nodes.
+
+        Features:
+        - 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
+        async def to_obj(
+            cls,
+            subj,
+            /,
+            *,
+            many: bool = True,
+            adapt_meth: str = None,
+            **kw,
+        ):
+            """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(cls, engine_or_url, table_name: str):
+            """Create table with lionagi schema if it doesn't exist."""
+            import sqlalchemy as sa
+            from sqlalchemy.ext.asyncio import create_async_engine
+
+            should_dispose = False
+            if isinstance(engine_or_url, str):
+                engine = create_async_engine(engine_or_url, future=True)
+                should_dispose = True
+            else:
+                engine = engine_or_url
+
+            try:
+                async with engine.begin() as conn:
+                    # 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
+                    )
+
+                    # 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.Float),
+                            sa.Column("embedding", json_type, nullable=True),
+                        ).create(sync_conn, checkfirst=True)
+                    )
+            finally:
+                if should_dispose:
+                    await engine.dispose()
+
+    return LionAGIAsyncPostgresAdapter
+
+
+LionAGIAsyncPostgresAdapter = create_lionagi_async_postgres_adapter()
+
+__all__ = ("LionAGIAsyncPostgresAdapter",)

lionagi/ln/__init__.py

@@ -1,8 +1,6 @@
 from ._async_call import alcall, bcall
 from ._hash import hash_dict
 from ._json_dump import (
-    DEFAULT_SERIALIZER,
-    DEFAULT_SERIALIZER_OPTION,
     get_orjson_default,
     json_dumpb,
     json_dumps,
@@ -37,8 +35,10 @@ from .fuzzy import (
     extract_json,
     fuzzy_json,
     fuzzy_match_keys,
+    fuzzy_validate_mapping,
     fuzzy_validate_pydantic,
     string_similarity,
+    to_dict,
 )
 from .types import is_sentinel, not_sentinel
 
@@ -46,8 +46,6 @@ __all__ = (
     "alcall",
     "bcall",
     "hash_dict",
-    "DEFAULT_SERIALIZER",
-    "DEFAULT_SERIALIZER_OPTION",
     "get_orjson_default",
     "json_dumps",
     "make_options",
@@ -80,4 +78,6 @@ __all__ = (
     "string_similarity",
     "is_sentinel",
     "not_sentinel",
+    "to_dict",
+    "fuzzy_validate_mapping",
 )

lionagi/ln/_json_dump.py

@@ -15,8 +15,6 @@ import orjson
 
 __all__ = [
     "get_orjson_default",
-    "DEFAULT_SERIALIZER",
-    "DEFAULT_SERIALIZER_OPTION",
     "make_options",
     "json_dumpb",
     "json_dumps",
@@ -193,10 +191,6 @@ def _cached_default(
 
 # --------- defaults & options -------------------------------------------------
 
-# Compact, no newline, no sorting: neutral default for most use-cases.
-DEFAULT_SERIALIZER_OPTION = 0
-DEFAULT_SERIALIZER = get_orjson_default()
-
 
 def make_options(
     *,

lionagi/ln/fuzzy/__init__.py

@@ -1,10 +1,12 @@
 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 ._fuzzy_validate import fuzzy_validate_mapping, fuzzy_validate_pydantic
 from ._string_similarity import SIMILARITY_TYPE, string_similarity
+from ._to_dict import to_dict
 
 __all__ = (
+    "to_dict",
     "fuzzy_json",
     "fuzzy_match_keys",
     "extract_json",
@@ -12,4 +14,5 @@ __all__ = (
     "SIMILARITY_TYPE",
     "fuzzy_validate_pydantic",
     "FuzzyMatchKeysParams",
+    "fuzzy_validate_mapping",
 )

lionagi/ln/fuzzy/_fuzzy_validate.py

@@ -1,9 +1,15 @@
+from collections.abc import Callable, Sequence
+from typing import Any, Literal
+
 from pydantic import BaseModel
 
 from lionagi._errors import ValidationError
 
+from ..types import KeysDict
 from ._extract_json import extract_json
 from ._fuzzy_match import FuzzyMatchKeysParams, fuzzy_match_keys
+from ._string_similarity import SIMILARITY_TYPE
+from ._to_dict import to_dict
 
 __all__ = ("fuzzy_validate_pydantic",)
 
@@ -44,3 +50,106 @@ def fuzzy_validate_pydantic(
         return model_type.model_validate(model_data)
     except Exception as e:
         raise ValidationError(f"Validation failed: {e}") from e
+
+
+def fuzzy_validate_mapping(
+    d: Any,
+    keys: Sequence[str] | KeysDict,
+    /,
+    *,
+    similarity_algo: (
+        SIMILARITY_TYPE | Callable[[str, str], float]
+    ) = "jaro_winkler",
+    similarity_threshold: float = 0.85,
+    fuzzy_match: bool = True,
+    handle_unmatched: Literal[
+        "ignore", "raise", "remove", "fill", "force"
+    ] = "ignore",
+    fill_value: Any = None,
+    fill_mapping: dict[str, Any] | None = None,
+    strict: bool = False,
+    suppress_conversion_errors: bool = False,
+) -> dict[str, Any]:
+    """
+    Validate and correct any input into a dictionary with expected keys.
+
+    Args:
+        d: Input to validate. Can be:
+            - Dictionary
+            - JSON string or markdown code block
+            - XML string
+            - Object with to_dict/model_dump method
+            - Any type convertible to dictionary
+        keys: List of expected keys or dictionary mapping keys to types.
+        similarity_algo: String similarity algorithm or custom function.
+        similarity_threshold: Minimum similarity score for fuzzy matching.
+        fuzzy_match: If True, use fuzzy matching for key correction.
+        handle_unmatched: How to handle unmatched keys:
+            - "ignore": Keep unmatched keys
+            - "raise": Raise error for unmatched keys
+            - "remove": Remove unmatched keys
+            - "fill": Fill missing keys with default values
+            - "force": Combine "fill" and "remove" behaviors
+        fill_value: Default value for filling unmatched keys.
+        fill_mapping: Dictionary mapping keys to default values.
+        strict: Raise error if any expected key is missing.
+        suppress_conversion_errors: Return empty dict on conversion errors.
+
+    Returns:
+        Validated and corrected dictionary.
+
+    Raises:
+        ValueError: If input cannot be converted or validation fails.
+        TypeError: If input types are invalid.
+    """
+    if d is None:
+        raise TypeError("Input cannot be None")
+
+    # Try converting to dictionary
+    try:
+        if isinstance(d, str):
+            # First try to_json for JSON strings and code blocks
+            try:
+                json_result = extract_json(
+                    d, fuzzy_parse=True, return_one_if_single=True
+                )
+                dict_input = (
+                    json_result[0]
+                    if isinstance(json_result, list)
+                    else json_result
+                )
+            except Exception:
+                dict_input = to_dict(
+                    d, str_type="json", fuzzy_parse=True, suppress=True
+                )
+        else:
+            dict_input = to_dict(
+                d, use_model_dump=True, fuzzy_parse=True, suppress=True
+            )
+
+        if not isinstance(dict_input, dict):
+            if suppress_conversion_errors:
+                dict_input = {}
+            else:
+                raise ValueError(
+                    f"Failed to convert input to dictionary: {type(dict_input)}"
+                )
+
+    except Exception as e:
+        if suppress_conversion_errors:
+            dict_input = {}
+        else:
+            raise ValueError(f"Failed to convert input to dictionary: {e}")
+
+    # Validate the dictionary
+    return fuzzy_match_keys(
+        dict_input,
+        keys,
+        similarity_algo=similarity_algo,
+        similarity_threshold=similarity_threshold,
+        fuzzy_match=fuzzy_match,
+        handle_unmatched=handle_unmatched,
+        fill_value=fill_value,
+        fill_mapping=fill_mapping,
+        strict=strict,
+    )