lionagi 0.16.2__py3-none-any.whl → 0.17.0__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/__init__.py

@@ -2,11 +2,9 @@
 #
 # SPDX-License-Identifier: Apache-2.0
 
-from .brainstorm.brainstorm import BrainstormOperation, brainstorm
 from .builder import ExpansionStrategy, OperationGraphBuilder
 from .flow import flow
 from .node import BranchOperations, Operation
-from .plan.plan import PlanOperation, plan
 
 Builder = OperationGraphBuilder
 
@@ -17,9 +15,5 @@ __all__ = (
     "flow",
     "BranchOperations",
     "Operation",
-    "plan",
-    "PlanOperation",
-    "brainstorm",
-    "BrainstormOperation",
     "Builder",
 )

lionagi/operations/_visualize_graph.py

@@ -0,0 +1,285 @@
+def visualize_graph(
+    builder,
+    title: str = "Operation Graph",
+    figsize=(14, 10),
+):
+    """Visualization with improved layout for complex graphs."""
+    from lionagi.utils import is_import_installed
+
+    if not is_import_installed("matplotlib"):
+        raise ImportError(
+            "matplotlib is required for visualization. "
+            "Please install it using `pip install matplotlib`."
+        )
+    if not is_import_installed("networkx"):
+        raise ImportError(
+            "networkx is required for visualization. "
+            "Please install it using `pip install networkx`."
+        )
+
+    import matplotlib.pyplot as plt
+    import networkx as nx
+    import numpy as np
+
+    graph = builder.get_graph()
+
+    # Convert to networkx
+    G = nx.DiGraph()
+
+    # Track node positions for hierarchical layout
+    node_levels = {}
+    node_labels = {}
+    node_colors = []
+    node_sizes = []
+
+    # First pass: add nodes and determine levels
+    for node in graph.internal_nodes.values():
+        node_id = str(node.id)[:8]
+        G.add_node(node_id)
+
+        # Determine level based on dependencies
+        in_edges = [
+            e
+            for e in graph.internal_edges.values()
+            if str(e.tail)[:8] == node_id
+        ]
+        if not in_edges:
+            level = 0  # Root nodes
+        else:
+            # Get max level of predecessors + 1
+            pred_levels = []
+            for edge in in_edges:
+                pred_id = str(edge.head)[:8]
+                if pred_id in node_levels:
+                    pred_levels.append(node_levels[pred_id])
+            level = max(pred_levels, default=0) + 1
+
+        node_levels[node_id] = level
+
+        # Create label
+        ref_id = node.metadata.get("reference_id", "")
+        if ref_id:
+            label = f"{node.operation}\n[{ref_id}]"
+        else:
+            label = f"{node.operation}\n{node_id}"
+        node_labels[node_id] = label
+
+        # Color and size based on status and type
+        if node.id in builder._executed:
+            node_colors.append("#90EE90")  # Light green
+            node_sizes.append(4000)
+        elif node.metadata.get("expansion_source"):
+            node_colors.append("#87CEEB")  # Sky blue
+            node_sizes.append(3500)
+        elif node.metadata.get("aggregation"):
+            node_colors.append("#FFD700")  # Gold
+            node_sizes.append(4500)
+        elif node.metadata.get("is_condition_check"):
+            node_colors.append("#DDA0DD")  # Plum
+            node_sizes.append(3500)
+        else:
+            node_colors.append("#E0E0E0")  # Light gray
+            node_sizes.append(3000)
+
+    # Add edges
+    edge_colors = []
+    edge_styles = []
+    edge_widths = []
+    edge_labels = {}
+
+    for edge in graph.internal_edges.values():
+        head_id = str(edge.head)[:8]
+        tail_id = str(edge.tail)[:8]
+        G.add_edge(head_id, tail_id)
+
+        # Style edges based on type
+        edge_label = edge.label[0] if edge.label else ""
+        edge_labels[(head_id, tail_id)] = edge_label
+
+        if "expansion" in edge_label:
+            edge_colors.append("#4169E1")  # Royal blue
+            edge_styles.append("dashed")
+            edge_widths.append(2)
+        elif "aggregate" in edge_label:
+            edge_colors.append("#FF6347")  # Tomato
+            edge_styles.append("dotted")
+            edge_widths.append(2.5)
+        else:
+            edge_colors.append("#808080")  # Gray
+            edge_styles.append("solid")
+            edge_widths.append(1.5)
+
+    # Create improved hierarchical layout
+    pos = {}
+    nodes_by_level = {}
+
+    for node_id, level in node_levels.items():
+        if level not in nodes_by_level:
+            nodes_by_level[level] = []
+        nodes_by_level[level].append(node_id)
+
+    # Position nodes with better spacing algorithm
+    y_spacing = 2.5
+    max_width = 16  # Maximum horizontal spread
+
+    for level, nodes in nodes_by_level.items():
+        num_nodes = len(nodes)
+
+        if num_nodes <= 6:
+            # Normal spacing for small levels
+            x_spacing = 2.5
+            x_offset = -(num_nodes - 1) * x_spacing / 2
+            for i, node_id in enumerate(nodes):
+                pos[node_id] = (x_offset + i * x_spacing, -level * y_spacing)
+        else:
+            # Multi-row layout for large levels
+            nodes_per_row = min(6, int(np.ceil(np.sqrt(num_nodes * 1.5))))
+            rows = int(np.ceil(num_nodes / nodes_per_row))
+
+            for i, node_id in enumerate(nodes):
+                row = i // nodes_per_row
+                col = i % nodes_per_row
+
+                # Calculate row width
+                nodes_in_row = min(
+                    nodes_per_row, num_nodes - row * nodes_per_row
+                )
+                x_spacing = 2.5
+                x_offset = -(nodes_in_row - 1) * x_spacing / 2
+
+                # Add slight y offset for different rows
+                y_offset = row * 0.8
+
+                pos[node_id] = (
+                    x_offset + col * x_spacing,
+                    -level * y_spacing - y_offset,
+                )
+
+    # Create figure
+    plt.figure(figsize=figsize)
+
+    # Draw nodes
+    nx.draw_networkx_nodes(
+        G,
+        pos,
+        node_color=node_colors,
+        node_size=node_sizes,
+        alpha=0.9,
+        linewidths=2,
+        edgecolors="black",
+    )
+
+    # Draw edges with different styles - use curved edges for better visibility
+    for i, (u, v) in enumerate(G.edges()):
+        # Calculate curve based on node positions
+        u_pos = pos[u]
+        v_pos = pos[v]
+
+        # Determine connection style based on relative positions
+        if abs(u_pos[0] - v_pos[0]) > 5:  # Far apart horizontally
+            connectionstyle = "arc3,rad=0.2"
+        else:
+            connectionstyle = "arc3,rad=0.1"
+
+        nx.draw_networkx_edges(
+            G,
+            pos,
+            [(u, v)],
+            edge_color=[edge_colors[i]],
+            style=edge_styles[i],
+            width=edge_widths[i],
+            alpha=0.7,
+            arrows=True,
+            arrowsize=20,
+            arrowstyle="-|>",
+            connectionstyle=connectionstyle,
+        )
+
+    # Draw labels
+    nx.draw_networkx_labels(
+        G,
+        pos,
+        node_labels,
+        font_size=9,
+        font_weight="bold",
+        font_family="monospace",
+    )
+
+    # Draw edge labels (only for smaller graphs)
+    if len(G.edges()) < 20:
+        nx.draw_networkx_edge_labels(
+            G,
+            pos,
+            edge_labels,
+            font_size=7,
+            font_color="darkblue",
+            bbox=dict(
+                boxstyle="round,pad=0.3",
+                facecolor="white",
+                edgecolor="none",
+                alpha=0.7,
+            ),
+        )
+
+    plt.title(title, fontsize=18, fontweight="bold", pad=20)
+    plt.axis("off")
+
+    # Enhanced legend
+    from matplotlib.lines import Line2D
+    from matplotlib.patches import Patch, Rectangle
+
+    legend_elements = [
+        Patch(facecolor="#90EE90", edgecolor="black", label="Executed"),
+        Patch(facecolor="#87CEEB", edgecolor="black", label="Expanded"),
+        Patch(facecolor="#FFD700", edgecolor="black", label="Aggregation"),
+        Patch(facecolor="#DDA0DD", edgecolor="black", label="Condition"),
+        Patch(facecolor="#E0E0E0", edgecolor="black", label="Pending"),
+        Line2D([0], [0], color="#808080", linewidth=2, label="Sequential"),
+        Line2D(
+            [0],
+            [0],
+            color="#4169E1",
+            linewidth=2,
+            linestyle="dashed",
+            label="Expansion",
+        ),
+        Line2D(
+            [0],
+            [0],
+            color="#FF6347",
+            linewidth=2,
+            linestyle="dotted",
+            label="Aggregate",
+        ),
+    ]
+
+    plt.legend(
+        handles=legend_elements,
+        loc="upper left",
+        bbox_to_anchor=(0, 1),
+        frameon=True,
+        fancybox=True,
+        shadow=True,
+        ncol=2,
+    )
+
+    # Add statistics box
+    stats_text = f"Nodes: {len(G.nodes())}\nEdges: {len(G.edges())}\nExecuted: {len(builder._executed)}"
+    if nodes_by_level:
+        max_level = max(nodes_by_level.keys())
+        stats_text += f"\nLevels: {max_level + 1}"
+
+    plt.text(
+        0.98,
+        0.02,
+        stats_text,
+        transform=plt.gca().transAxes,
+        bbox=dict(boxstyle="round,pad=0.5", facecolor="lightgray", alpha=0.8),
+        verticalalignment="bottom",
+        horizontalalignment="right",
+        fontsize=10,
+        fontfamily="monospace",
+    )
+
+    plt.tight_layout()
+    plt.show()