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

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/brainstorm/brainstorm.py

@@ -309,8 +309,8 @@ async def brainstormStream(
                             )
                             print(f"\n-----Exploring Idea-----\n{snippet}")
                         new_branch = session.split(branch)
-                        resp = await new_branch.instruct(
-                            ins_, **(explore_kwargs or {})
+                        resp = await new_branch.operate(
+                            **ins_.to_dict(), **(explore_kwargs or {})
                         )
                         return InstructResponse(instruct=ins_, response=resp)
 
@@ -357,8 +357,8 @@ async def brainstormStream(
                                 else i.guidance
                             )
                             print(f"\n-----Exploring Idea-----\n{snippet}")
-                        seq_res = await branch.instruct(
-                            i, **(explore_kwargs or {})
+                        seq_res = await branch.operate(
+                            **i.to_dict(), **(explore_kwargs or {})
                         )
                         ins_res = InstructResponse(
                             instruct=i, response=seq_res
@@ -389,8 +389,8 @@ async def brainstormStream(
 
                         async def _explore(ins_: Instruct):
                             child_branch = session.split(base_branch)
-                            child_resp = await child_branch.instruct(
-                                ins_, **(explore_kwargs or {})
+                            child_resp = await child_branch.operate(
+                                **ins_.to_dict(), **(explore_kwargs or {})
                             )
                             return InstructResponse(
                                 instruct=ins_, response=child_resp
@@ -453,8 +453,8 @@ async def brainstormStream(
                                     f"\n-----Exploring Idea (sequential in chunk)-----\n{snippet}"
                                 )
 
-                            seq_resp = await local_branch.instruct(
-                                ins_, **(explore_kwargs or {})
+                            seq_resp = await local_branch.operate(
+                                **ins_.to_dict(), **(explore_kwargs or {})
                             )
                             chunk_results.append(
                                 InstructResponse(
@@ -468,8 +468,8 @@ async def brainstormStream(
                     all_responses = await alcall(
                         all_chunks,
                         explore_chunk_sequentially,
-                        flatten=True,
-                        dropna=True,
+                        output_flatten=True,
+                        output_dropna=True,
                     )
                     out.explore = all_responses
 

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/element.py

@@ -315,10 +315,6 @@ class Element(BaseModel, Observable):
             dict_["node_metadata"] = dict_.pop("metadata", {})
             return dict_
 
-    def as_jsonable(self) -> dict:
-        """Converts this Element to a JSON-serializable dictionary."""
-        return self.to_dict(mode="json")
-
     @classmethod
     def from_dict(cls, data: dict) -> Element:
         """Deserializes a dictionary into an Element or subclass of Element.
@@ -363,19 +359,14 @@ class Element(BaseModel, Observable):
     def to_json(self, decode: bool = True) -> str:
         """Converts this Element to a JSON string."""
         dict_ = self._to_dict()
-        if decode:
-            return orjson.dumps(
-                dict_,
-                default=DEFAULT_ELEMENT_SERIALIZER,
-                option=ln.DEFAULT_SERIALIZER_OPTION,
-            ).decode()
-        return orjson.dumps(dict_, default=DEFAULT_ELEMENT_SERIALIZER)
+        return ln.json_dumps(
+            dict_, default=DEFAULT_ELEMENT_SERIALIZER, decode=decode
+        )
 
     @classmethod
-    def from_json(cls, json_str: str, mode: str = "python") -> Element:
+    def from_json(cls, json_str: str) -> Element:
         """Deserializes a JSON string into an Element or subclass of Element."""
-        data = orjson.loads(json_str)
-        return cls.from_dict(data, mode=mode)
+        return cls.from_dict(orjson.loads(json_str))
 
 
 DEFAULT_ELEMENT_SERIALIZER = ln.get_orjson_default(

lionagi/protocols/generic/log.py

@@ -176,9 +176,9 @@ class DataLogger:
         suffix = fp.suffix.lower()
         try:
             if suffix == ".csv":
-                self.logs.to_csv_file(fp)
+                self.logs.dump(fp, "csv")
             elif suffix == ".json":
-                self.logs.to_json_file(fp)
+                self.logs.dump(fp, "json")
             else:
                 raise ValueError(f"Unsupported file extension: {suffix}")
 

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/messages/message.py

@@ -116,7 +116,14 @@ class RoledMessage(Node, Sendable):
             if isinstance(self.template, Template):
                 return self.template.render(**self.content)
         except Exception:
-            return ln.json_dumps(self.content)
+            return ln.json_dumps(
+                self.content,
+                pretty=True,
+                sort_keys=True,
+                append_newline=True,
+                deterministic_sets=True,
+                decimal_as_float=True,
+            )
 
     @classmethod
     def create(cls, **kwargs):

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/endpoint.py

@@ -150,6 +150,13 @@ class Endpoint:
                 "branch",
                 "aggregation_sources",
                 "aggregation_count",
+                "action_strategy",
+                "parse_model",
+                "reason",
+                "actions",
+                "return_operative",
+                "operative_model",
+                "request_model",
             }
             payload = {
                 k: v for k, v in payload.items() if k not in non_api_params

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