lionagi 0.16.2__tar.gz → 0.16.3__tar.gz

{lionagi-0.16.2 → lionagi-0.16.3}/.github/workflows/ci.yml

@@ -39,12 +39,18 @@ jobs:
       run: |
         uv venv
         uv sync --extra all
-    
-    - name: Run tests
+
+    - name: Run tests with coverage
       run: |
         source .venv/bin/activate
-        uv run pytest --asyncio-mode=auto --maxfail=1 --disable-warnings tests/
-    
+        uv run pytest --asyncio-mode=auto --maxfail=1 --disable-warnings --cov=lionagi --cov-report=xml --cov-report=term tests/
+
+    - name: Upload coverage reports to Codecov
+      uses: codecov/codecov-action@v5
+      with:
+        token: ${{ secrets.CODECOV_TOKEN }}
+        slug: khive-ai/lionagi
+
     - name: Check code style and compatibility
       run: |
         source .venv/bin/activate

{lionagi-0.16.2 → lionagi-0.16.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lionagi
-Version: 0.16.2
+Version: 0.16.3
 Summary: An Intelligence Operating System.
 Author-email: HaiyangLi <quantocean.li@gmail.com>
 License:            Apache License
@@ -226,8 +226,6 @@ Requires-Dist: backoff>=2.0.0
 Requires-Dist: jinja2>=3.0.0
 Requires-Dist: json-repair>=0.40.0
 Requires-Dist: msgspec>=0.18.0
-Requires-Dist: pillow>=10.0.0
-Requires-Dist: psutil>=6.0.0
 Requires-Dist: pydantic-settings>=2.8.0
 Requires-Dist: pydantic>=2.8.0
 Requires-Dist: pydapter[pandas]>=1.1.1
@@ -235,7 +233,6 @@ Requires-Dist: python-dotenv>=1.1.0
 Requires-Dist: tiktoken>=0.9.0
 Provides-Extra: all
 Requires-Dist: aiosqlite>=0.21.0; extra == 'all'
-Requires-Dist: claude-code-sdk>=0.0.15; extra == 'all'
 Requires-Dist: datamodel-code-generator>=0.31.2; extra == 'all'
 Requires-Dist: docling>=2.15.0; extra == 'all'
 Requires-Dist: fastmcp>=2.10.5; extra == 'all'
@@ -244,8 +241,6 @@ Requires-Dist: networkx>=3.0.0; 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.15; extra == 'claude-code'
 Provides-Extra: graph
 Requires-Dist: matplotlib>=3.7.0; extra == 'graph'
 Requires-Dist: networkx>=3.0.0; extra == 'graph'
@@ -263,10 +258,6 @@ Provides-Extra: schema
 Requires-Dist: datamodel-code-generator>=0.31.2; extra == 'schema'
 Provides-Extra: sqlite
 Requires-Dist: aiosqlite>=0.21.0; extra == 'sqlite'
-Provides-Extra: tools
-Requires-Dist: docling>=2.15.0; extra == 'tools'
-Provides-Extra: unstructured
-Requires-Dist: opencv-python>=4.2.0.34; extra == 'unstructured'
 Provides-Extra: xml
 Requires-Dist: xmltodict>=0.12.0; extra == 'xml'
 Description-Content-Type: text/markdown
@@ -274,6 +265,7 @@ Description-Content-Type: text/markdown
 ![PyPI - Version](https://img.shields.io/pypi/v/lionagi?labelColor=233476aa&color=231fc935)
 ![PyPI - Downloads](https://img.shields.io/pypi/dm/lionagi?color=blue)
 ![Python Version](https://img.shields.io/badge/python-3.10%2B-blue)
+[![codecov](https://codecov.io/github/khive-ai/lionagi/graph/badge.svg?token=FAE47FY26T)](https://codecov.io/github/khive-ai/lionagi)
 
 [Documentation](https://khive-ai.github.io/lionagi/) |
 [Discord](https://discord.gg/JDj9ENhUE8) |
@@ -416,7 +408,7 @@ Seamlessly route to different models in the same workflow.
 
 ### Claude Code Integration
 
-LionAGI now supports Anthropic's Claude Code [Python SDK](https://github.com/anthropics/claude-code-sdk-python), and [CLI SDK](https://docs.anthropic.com/en/docs/claude-code/sdk) enabling autonomous coding capabilities with persistent session management. The CLI endpoint
+LionAGI now supports Anthropic's Claude Code [CLI SDK](https://docs.anthropic.com/en/docs/claude-code/sdk) enabling autonomous coding capabilities with persistent session management. The CLI endpoint
 directly connects to claude code, and is recommended, you can either use it via a [proxy server](https://github.com/khive-ai/lionagi/tree/main/cookbooks/claude_proxy) or directly with `query_cli` endpoint, provided you have already logged onto claude code cli in your terminal.
 
 ```python
@@ -484,7 +476,6 @@ Key features:
 ```
 "lionagi[reader]" - Reader tool for any unstructured data and web pages
 "lionagi[ollama]" - Ollama model support for local inference
-"lionagi[claude-code]" - Claude code python SDK integration (cli endpoint does not require this)
 "lionagi[rich]" - Rich output formatting for better console display
 "lionagi[schema]" - Convert pydantic schema to make the Model class persistent
 "lionagi[postgres]" - Postgres database support for storing and retrieving structured data

{lionagi-0.16.2 → lionagi-0.16.3}/README.md

@@ -1,6 +1,7 @@
 ![PyPI - Version](https://img.shields.io/pypi/v/lionagi?labelColor=233476aa&color=231fc935)
 ![PyPI - Downloads](https://img.shields.io/pypi/dm/lionagi?color=blue)
 ![Python Version](https://img.shields.io/badge/python-3.10%2B-blue)
+[![codecov](https://codecov.io/github/khive-ai/lionagi/graph/badge.svg?token=FAE47FY26T)](https://codecov.io/github/khive-ai/lionagi)
 
 [Documentation](https://khive-ai.github.io/lionagi/) |
 [Discord](https://discord.gg/JDj9ENhUE8) |
@@ -143,7 +144,7 @@ Seamlessly route to different models in the same workflow.
 
 ### Claude Code Integration
 
-LionAGI now supports Anthropic's Claude Code [Python SDK](https://github.com/anthropics/claude-code-sdk-python), and [CLI SDK](https://docs.anthropic.com/en/docs/claude-code/sdk) enabling autonomous coding capabilities with persistent session management. The CLI endpoint
+LionAGI now supports Anthropic's Claude Code [CLI SDK](https://docs.anthropic.com/en/docs/claude-code/sdk) enabling autonomous coding capabilities with persistent session management. The CLI endpoint
 directly connects to claude code, and is recommended, you can either use it via a [proxy server](https://github.com/khive-ai/lionagi/tree/main/cookbooks/claude_proxy) or directly with `query_cli` endpoint, provided you have already logged onto claude code cli in your terminal.
 
 ```python
@@ -211,7 +212,6 @@ Key features:
 ```
 "lionagi[reader]" - Reader tool for any unstructured data and web pages
 "lionagi[ollama]" - Ollama model support for local inference
-"lionagi[claude-code]" - Claude code python SDK integration (cli endpoint does not require this)
 "lionagi[rich]" - Rich output formatting for better console display
 "lionagi[schema]" - Convert pydantic schema to make the Model class persistent
 "lionagi[postgres]" - Postgres database support for storing and retrieving structured data

{lionagi-0.16.2 → lionagi-0.16.3}/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-0.16.2 → lionagi-0.16.3}/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-0.16.2 → lionagi-0.16.3}/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-0.16.2/lionagi/libs/validate/fuzzy_validate_mapping.py → lionagi-0.16.3/lionagi/ln/fuzzy/_fuzzy_validate.py

@@ -1,45 +1,55 @@
-# Copyright (c) 2023 - 2025, HaiyangLi <quantocean.li at gmail dot com>
-#
-# SPDX-License-Identifier: Apache-2.0
-
 from collections.abc import Callable, Sequence
 from typing import Any, Literal
 
-from lionagi.utils import KeysDict, Params, to_dict, to_json
+from pydantic import BaseModel
 
-from .fuzzy_match_keys import fuzzy_match_keys
-from .string_similarity import SIMILARITY_TYPE
+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
 
-class FuzzyValidateMappingParams(Params):
-    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
-
-    def __call__(
-        self, d_: dict[str, Any], keys: Sequence[str] | KeysDict
-    ) -> dict[str, Any]:
-        return fuzzy_validate_mapping(
-            d_,
-            keys,
-            similarity_algo=self.similarity_algo,
-            similarity_threshold=self.similarity_threshold,
-            fuzzy_match=self.fuzzy_match,
-            handle_unmatched=self.handle_unmatched,
-            fill_value=self.fill_value,
-            fill_mapping=self.fill_mapping,
-            strict=self.strict,
-            suppress_conversion_errors=self.suppress_conversion_errors,
-        )
+__all__ = ("fuzzy_validate_pydantic",)
+
+
+def fuzzy_validate_pydantic(
+    text,
+    /,
+    model_type: type[BaseModel],
+    fuzzy_parse: bool = True,
+    fuzzy_match: bool = False,
+    fuzzy_match_params: FuzzyMatchKeysParams | dict = None,
+):
+    try:
+        model_data = extract_json(text, fuzzy_parse=fuzzy_parse)
+    except Exception as e:
+        raise ValidationError(
+            f"Failed to extract valid JSON from model response: {e}"
+        ) from e
+
+    d = model_data
+    if fuzzy_match:
+        if fuzzy_match_params is None:
+            model_data = fuzzy_match_keys(
+                d, model_type.model_fields, handle_unmatched="remove"
+            )
+        elif isinstance(fuzzy_match_params, dict):
+            model_data = fuzzy_match_keys(
+                d, model_type.model_fields, **fuzzy_match_params
+            )
+        elif isinstance(fuzzy_match_params, FuzzyMatchKeysParams):
+            model_data = fuzzy_match_params(d, model_type.model_fields)
+        else:
+            raise TypeError(
+                "fuzzy_keys_params must be a dict or FuzzyMatchKeysParams instance"
+            )
+
+    try:
+        return model_type.model_validate(model_data)
+    except Exception as e:
+        raise ValidationError(f"Validation failed: {e}") from e
 
 
 def fuzzy_validate_mapping(
@@ -100,14 +110,15 @@ def fuzzy_validate_mapping(
         if isinstance(d, str):
             # First try to_json for JSON strings and code blocks
             try:
-                json_result = to_json(d)
+                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:
-                # Fall back to to_dict for other string formats
                 dict_input = to_dict(
                     d, str_type="json", fuzzy_parse=True, suppress=True
                 )

lionagi-0.16.3/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-0.16.2 → lionagi-0.16.3}/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",
 )