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

lionagi/adapters/_utils.py

@@ -10,17 +10,3 @@ def check_async_postgres_available():
             "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]"`.'
-        )

lionagi/ln/__init__.py

@@ -37,8 +37,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
 
@@ -80,4 +82,6 @@ __all__ = (
     "string_similarity",
     "is_sentinel",
     "not_sentinel",
+    "to_dict",
+    "fuzzy_validate_mapping",
 )

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,
+    )

lionagi/ln/fuzzy/_to_dict.py

@@ -0,0 +1,388 @@
+from __future__ import annotations
+
+import contextlib
+import dataclasses
+import json
+from collections.abc import Callable, Iterable, Mapping, Sequence
+from enum import Enum as _Enum
+from typing import Any, Literal
+
+from ._fuzzy_json import fuzzy_json
+
+# ----------------------------
+# Helpers (small, tight, local)
+# ----------------------------
+
+
+def _is_na(obj: Any) -> bool:
+    """None / Pydantic undefined sentinels -> treat as NA."""
+    if obj is None:
+        return True
+    # Avoid importing pydantic types; match by typename to stay lightweight
+    tname = type(obj).__name__
+    return tname in {
+        "Undefined",
+        "UndefinedType",
+        "PydanticUndefined",
+        "PydanticUndefinedType",
+    }
+
+
+def _enum_class_to_dict(
+    enum_cls: type[_Enum], use_enum_values: bool
+) -> dict[str, Any]:
+    members = dict(enum_cls.__members__)  # cheap, stable
+    if use_enum_values:
+        return {k: v.value for k, v in members.items()}
+    return {k: v for k, v in members.items()}
+
+
+def _parse_str(
+    s: str,
+    *,
+    fuzzy_parse: bool,
+    str_type: Literal["json", "xml"] | None,
+    parser: Callable[[str], Any] | None,
+    **kwargs: Any,
+) -> Any:
+    """Parse str -> Python object. Keep imports local to avoid cold start overhead."""
+    if parser is not None:
+        return parser(s, **kwargs)
+
+    if str_type == "xml":
+        # xmltodict is optional; import only if needed
+        import xmltodict
+
+        return xmltodict.parse(s, **kwargs)
+
+    # JSON path
+    if fuzzy_parse:
+        # If the caller supplied a fuzzy parser in scope, use it; otherwise fallback.
+        # We intentionally do not import anything heavy here.
+        with contextlib.suppress(NameError):
+            return fuzzy_json(s, **kwargs)  # type: ignore[name-defined]
+    return json.loads(s, **kwargs)
+
+
+def _object_to_mapping_like(
+    obj: Any,
+    *,
+    use_model_dump: bool,
+    **kwargs: Any,
+) -> Mapping | dict | Any:
+    """
+    Convert 'custom' objects to mapping-like, if possible.
+    Order:
+      1) Pydantic v2 'model_dump' (duck-typed)
+      2) Common methods: to_dict, dict, to_json/json (parsed if string)
+      3) Dataclass
+      4) __dict__
+      5) dict(obj)
+    """
+    # 1) Pydantic v2
+    if use_model_dump and hasattr(obj, "model_dump"):
+        return obj.model_dump(**kwargs)
+
+    # 2) Common methods
+    for name in ("to_dict", "dict", "to_json", "json"):
+        if hasattr(obj, name):
+            res = getattr(obj, name)(**kwargs)
+            return json.loads(res) if isinstance(res, str) else res
+
+    # 3) Dataclass
+    if dataclasses.is_dataclass(obj):
+        # asdict is already recursive; keep it (fast enough & simple)
+        return dataclasses.asdict(obj)
+
+    # 4) __dict__
+    if hasattr(obj, "__dict__"):
+        return obj.__dict__
+
+    # 5) Try dict() fallback
+    return dict(obj)  # may raise -> handled by caller
+
+
+def _enumerate_iterable(it: Iterable) -> dict[int, Any]:
+    return {i: v for i, v in enumerate(it)}
+
+
+# ---------------------------------------
+# Recursive pre-processing (single pass)
+# ---------------------------------------
+
+
+def _preprocess_recursive(
+    obj: Any,
+    *,
+    depth: int,
+    max_depth: int,
+    recursive_custom_types: bool,
+    str_parse_opts: dict[str, Any],
+    use_model_dump: bool,
+) -> Any:
+    """
+    Recursively process nested structures:
+      - Parse strings (JSON/XML/custom parser)
+      - Recurse into dict/list/tuple/set/etc.
+      - If recursive_custom_types=True, convert custom objects to mapping-like then continue
+    Containers retain their original types (dict stays dict, list stays list, set stays set, etc.)
+    """
+    if depth >= max_depth:
+        return obj
+
+    # Fast paths by exact type where possible
+    t = type(obj)
+
+    # Strings: try to parse; on failure, keep as-is
+    if t is str:
+        try:
+            parsed = _parse_str(obj, **str_parse_opts)
+        except Exception:
+            return obj
+        return _preprocess_recursive(
+            parsed,
+            depth=depth + 1,
+            max_depth=max_depth,
+            recursive_custom_types=recursive_custom_types,
+            str_parse_opts=str_parse_opts,
+            use_model_dump=use_model_dump,
+        )
+
+    # Dict-like
+    if isinstance(obj, Mapping):
+        # Recurse only into values (keys kept as-is)
+        return {
+            k: _preprocess_recursive(
+                v,
+                depth=depth + 1,
+                max_depth=max_depth,
+                recursive_custom_types=recursive_custom_types,
+                str_parse_opts=str_parse_opts,
+                use_model_dump=use_model_dump,
+            )
+            for k, v in obj.items()
+        }
+
+    # Sequence/Set-like (but not str)
+    if isinstance(obj, (list, tuple, set, frozenset)):
+        items = [
+            _preprocess_recursive(
+                v,
+                depth=depth + 1,
+                max_depth=max_depth,
+                recursive_custom_types=recursive_custom_types,
+                str_parse_opts=str_parse_opts,
+                use_model_dump=use_model_dump,
+            )
+            for v in obj
+        ]
+        if t is list:
+            return items
+        if t is tuple:
+            return tuple(items)
+        if t is set:
+            return set(items)
+        if t is frozenset:
+            return frozenset(items)
+
+    # Enum *class* (rare in values, but preserve your original attempt)
+    if isinstance(obj, type) and issubclass(obj, _Enum):
+        try:
+            enum_map = _enum_class_to_dict(
+                obj,
+                use_enum_values=str_parse_opts.get("use_enum_values", True),
+            )
+            return _preprocess_recursive(
+                enum_map,
+                depth=depth + 1,
+                max_depth=max_depth,
+                recursive_custom_types=recursive_custom_types,
+                str_parse_opts=str_parse_opts,
+                use_model_dump=use_model_dump,
+            )
+        except Exception:
+            return obj
+
+    # Custom objects
+    if recursive_custom_types:
+        with contextlib.suppress(Exception):
+            mapped = _object_to_mapping_like(
+                obj, use_model_dump=use_model_dump
+            )
+            return _preprocess_recursive(
+                mapped,
+                depth=depth + 1,
+                max_depth=max_depth,
+                recursive_custom_types=recursive_custom_types,
+                str_parse_opts=str_parse_opts,
+                use_model_dump=use_model_dump,
+            )
+
+    return obj
+
+
+# ---------------------------------------
+# Top-level conversion (non-recursive)
+# ---------------------------------------
+
+
+def _convert_top_level_to_dict(
+    obj: Any,
+    *,
+    fuzzy_parse: bool,
+    str_type: Literal["json", "xml"] | None,
+    parser: Callable[[str], Any] | None,
+    use_model_dump: bool,
+    use_enum_values: bool,
+    **kwargs: Any,
+) -> dict[str, Any]:
+    """
+    Convert a *single* object to dict using the 'brute force' rules.
+    Mirrors your original order, with fixes & optimizations.
+    """
+    # Set -> {v: v}
+    if isinstance(obj, set):
+        return {v: v for v in obj}
+
+    # Enum class -> members mapping
+    if isinstance(obj, type) and issubclass(obj, _Enum):
+        return _enum_class_to_dict(obj, use_enum_values)
+
+    # Mapping -> copy to plain dict (preserve your copy semantics)
+    if isinstance(obj, Mapping):
+        return dict(obj)
+
+    # None / pydantic undefined -> {}
+    if _is_na(obj):
+        return {}
+
+    # str -> parse (and return *as parsed*, which may be list, dict, etc.)
+    if isinstance(obj, str):
+        return _parse_str(
+            obj,
+            fuzzy_parse=fuzzy_parse,
+            str_type=str_type,
+            parser=parser,
+            **kwargs,
+        )
+
+    # Try "custom" object conversions
+    # (Covers BaseModel via model_dump, dataclasses, __dict__, json-strings, etc.)
+    try:
+        # If it's *not* a Sequence (e.g., numbers, objects) we try object conversion first,
+        # faithfully following your previous "non-Sequence -> model path" behavior.
+        if not isinstance(obj, Sequence):
+            converted = _object_to_mapping_like(
+                obj, use_model_dump=use_model_dump, **kwargs
+            )
+            # If conversion returned a string, try to parse JSON to mapping; else pass-through
+            if isinstance(converted, str):
+                return _parse_str(
+                    converted,
+                    fuzzy_parse=fuzzy_parse,
+                    str_type="json",
+                    parser=None,
+                )
+            if isinstance(converted, Mapping):
+                return dict(converted)
+            # If it's a list/tuple/etc., enumerate (your original did that after the fact)
+            if isinstance(converted, Iterable) and not isinstance(
+                converted, (str, bytes, bytearray)
+            ):
+                return _enumerate_iterable(converted)
+            # Best effort final cast
+            return dict(converted)
+
+    except Exception:
+        # Fall through to other strategies
+        pass
+
+    # Iterable (list/tuple/namedtuple/frozenset/…): enumerate
+    if isinstance(obj, Iterable) and not isinstance(
+        obj, (str, bytes, bytearray)
+    ):
+        return _enumerate_iterable(obj)
+
+    # Dataclass fallback (reachable only if it wasn't caught above)
+    with contextlib.suppress(Exception):
+        if dataclasses.is_dataclass(obj):
+            return dataclasses.asdict(obj)
+
+    # Last-ditch attempt
+    return dict(obj)  # may raise, handled by top-level try/except
+
+
+# ---------------
+# Public function
+# ---------------
+
+
+def to_dict(
+    input_: Any,
+    /,
+    *,
+    use_model_dump: bool = True,
+    fuzzy_parse: bool = False,
+    suppress: bool = False,
+    str_type: Literal["json", "xml"] | None = "json",
+    parser: Callable[[str], Any] | None = None,
+    recursive: bool = False,
+    max_recursive_depth: int | None = None,
+    recursive_python_only: bool = True,
+    use_enum_values: bool = False,
+    **kwargs: Any,
+) -> dict[str, Any]:
+    """
+    Convert various input types to a dictionary, with optional recursive processing.
+    Semantics preserved from original implementation.
+    """
+    try:
+        # Clamp recursion depth (match your constraints)
+        if not isinstance(max_recursive_depth, int):
+            max_depth = 5
+        else:
+            if max_recursive_depth < 0:
+                raise ValueError(
+                    "max_recursive_depth must be a non-negative integer"
+                )
+            if max_recursive_depth > 10:
+                raise ValueError(
+                    "max_recursive_depth must be less than or equal to 10"
+                )
+            max_depth = max_recursive_depth
+
+        # Prepare one small dict to avoid repeated arg passing and lookups
+        str_parse_opts = {
+            "fuzzy_parse": fuzzy_parse,
+            "str_type": str_type,
+            "parser": parser,
+            "use_enum_values": use_enum_values,  # threaded for enum class in recursion
+            **kwargs,
+        }
+
+        obj = input_
+        if recursive:
+            obj = _preprocess_recursive(
+                obj,
+                depth=0,
+                max_depth=max_depth,
+                recursive_custom_types=not recursive_python_only,
+                str_parse_opts=str_parse_opts,
+                use_model_dump=use_model_dump,
+            )
+
+        # Final top-level conversion
+        return _convert_top_level_to_dict(
+            obj,
+            fuzzy_parse=fuzzy_parse,
+            str_type=str_type,
+            parser=parser,
+            use_model_dump=use_model_dump,
+            use_enum_values=use_enum_values,
+            **kwargs,
+        )
+
+    except Exception as e:
+        if suppress or input_ == "":
+            return {}
+        raise e

lionagi/models/__init__.py

@@ -5,7 +5,6 @@
 from .field_model import FieldModel
 from .hashable_model import HashableModel
 from .model_params import ModelParams
-from .note import Note
 from .operable_model import OperableModel
 from .schema_model import SchemaModel
 
@@ -13,7 +12,6 @@ __all__ = (
     "FieldModel",
     "ModelParams",
     "OperableModel",
-    "Note",
     "SchemaModel",
     "HashableModel",
 )

lionagi/operations/communicate/communicate.py

@@ -5,7 +5,7 @@
 import logging
 from typing import TYPE_CHECKING
 
-from lionagi.libs.validate.fuzzy_validate_mapping import fuzzy_validate_mapping
+from lionagi.ln.fuzzy._fuzzy_validate import fuzzy_validate_mapping
 from lionagi.utils import UNDEFINED
 
 if TYPE_CHECKING:

lionagi/operations/parse/parse.py

@@ -6,7 +6,7 @@ from typing import TYPE_CHECKING, Any, Literal
 
 from pydantic import BaseModel
 
-from lionagi.libs.validate.fuzzy_validate_mapping import fuzzy_validate_mapping
+from lionagi.ln.fuzzy._fuzzy_validate import fuzzy_validate_mapping
 from lionagi.protocols.types import Operative
 from lionagi.utils import breakdown_pydantic_annotation
 

lionagi/protocols/generic/pile.py

@@ -25,7 +25,7 @@ from pydapter import Adaptable, AsyncAdaptable
 from typing_extensions import Self, deprecated, override
 
 from lionagi._errors import ItemExistsError, ItemNotFoundError, ValidationError
-from lionagi.libs.concurrency import Lock as ConcurrencyLock
+from lionagi.ln.concurrency import Lock as ConcurrencyLock
 from lionagi.utils import (
     UNDEFINED,
     is_same_dtype,

lionagi/protocols/operatives/operative.py

@@ -2,12 +2,12 @@
 #
 # SPDX-License-Identifier: Apache-2.0
 
-from typing import Any, Optional
+from typing import Any
 
 from pydantic import BaseModel
 from pydantic.fields import FieldInfo
 
-from lionagi.libs.validate.fuzzy_match_keys import fuzzy_match_keys
+from lionagi.ln.fuzzy._fuzzy_match import fuzzy_match_keys
 from lionagi.models import FieldModel, ModelParams, OperableModel
 from lionagi.utils import UNDEFINED, to_json
 

lionagi/service/connections/match_endpoint.py

@@ -57,17 +57,9 @@ def match_endpoint(
 
             return NvidiaNimChatEndpoint(None, **kwargs)
     if provider == "claude_code":
-        if "cli" in endpoint:
-            from .providers.claude_code_cli import ClaudeCodeCLIEndpoint
+        from .providers.claude_code_cli import ClaudeCodeCLIEndpoint
 
-            return ClaudeCodeCLIEndpoint(None, **kwargs)
-
-        if "query" in endpoint or "code" in endpoint:
-            from lionagi.service.connections.providers.claude_code_ import (
-                ClaudeCodeEndpoint,
-            )
-
-            return ClaudeCodeEndpoint(None, **kwargs)
+        return ClaudeCodeCLIEndpoint(None, **kwargs)
 
     from .providers.oai_ import OpenaiChatEndpoint
 

lionagi/service/connections/providers/types.py

@@ -1,6 +1,5 @@
 from .anthropic_ import AnthropicMessagesEndpoint
-from .claude_code_ import ClaudeCodeEndpoint, ClaudeCodeRequest
-from .claude_code_cli import ClaudeCodeCLIEndpoint
+from .claude_code_cli import ClaudeCodeCLIEndpoint, ClaudeCodeRequest
 from .exa_ import ExaSearchEndpoint, ExaSearchRequest
 from .oai_ import (
     GroqChatEndpoint,
@@ -14,7 +13,6 @@ from .perplexity_ import PerplexityChatEndpoint, PerplexityChatRequest
 
 __all__ = (
     "AnthropicMessagesEndpoint",
-    "ClaudeCodeEndpoint",
     "ClaudeCodeRequest",
     "ClaudeCodeCLIEndpoint",
     "ExaSearchEndpoint",

lionagi/service/hooks/hook_event.py

@@ -8,7 +8,7 @@ from typing import Any
 import anyio
 from pydantic import Field, PrivateAttr
 
-from lionagi.libs.concurrency import fail_after, get_cancelled_exc_class
+from lionagi.ln.concurrency import fail_after, get_cancelled_exc_class
 from lionagi.protocols.types import Event, EventStatus
 
 from ._types import AssosiatedEventInfo, HookEventTypes

lionagi/service/hooks/hook_registry.py

@@ -5,7 +5,7 @@ from __future__ import annotations
 
 from typing import Any, TypeVar
 
-from lionagi.libs.concurrency import get_cancelled_exc_class
+from lionagi.ln.concurrency import get_cancelled_exc_class
 from lionagi.protocols.types import Event, EventStatus
 from lionagi.utils import UNDEFINED
 

lionagi/service/rate_limited_processor.py

@@ -8,7 +8,7 @@ from typing import Any
 
 from typing_extensions import Self, override
 
-from lionagi.libs.concurrency import CapacityLimiter, Lock, move_on_after
+from lionagi.ln.concurrency import CapacityLimiter, Lock, move_on_after
 from lionagi.protocols.types import Executor, Processor
 
 from .connections.api_calling import APICalling