lionagi 0.14.5__py3-none-any.whl → 0.14.7__py3-none-any.whl

lionagi/fields/instruct.py

@@ -35,7 +35,6 @@ class Instruct(HashableModel):
         "reason",
         "actions",
         "action_strategy",
-        "batch_size",
         "request_params",
         "response_params",
     ]
@@ -97,16 +96,10 @@ class Instruct(HashableModel):
             "None: Contextual execution."
         ),
     )
-    action_strategy: Literal["batch", "sequential", "concurrent"] | None = (
-        Field(
-            None,
-            description="Action strategy to use for executing actions. Default "
-            "is 'concurrent'. Only provide for if actions are enabled.",
-        )
-    )
-    batch_size: int | None = Field(
+    action_strategy: Literal["sequential", "concurrent"] | None = Field(
         None,
-        description="Batch size for executing actions. Only provide for 'batch' strategy.",
+        description="Action strategy to use for executing actions. Default "
+        "is 'concurrent'. Only provide for if actions are enabled.",
     )
 
     @field_validator("instruction", "guidance", "context", mode="before")
@@ -123,13 +116,6 @@ class Instruct(HashableModel):
             return "concurrent"
         return v
 
-    @field_validator("batch_size", mode="before")
-    def _validate_batch_size(cls, v):
-        try:
-            return to_num(v, num_type=int)
-        except Exception:
-            return None
-
 
 class InstructResponse(HashableModel):
     instruct: Instruct

lionagi/libs/concurrency/cancel.py

@@ -4,7 +4,7 @@ import time
 from collections.abc import Iterator
 from contextlib import contextmanager
 from types import TracebackType
-from typing import Optional, TypeVar
+from typing import TypeVar
 
 import anyio
 

lionagi/libs/hash/__init__.py

@@ -0,0 +1,3 @@
+from .manager import HashUtils
+
+__all__ = ("HashUtils",)

lionagi/libs/hash/hash_dict.py

@@ -0,0 +1,108 @@
+import copy
+
+from pydantic import BaseModel as PydanticBaseModel
+
+__all__ = ("hash_dict",)
+
+# --- Canonical Representation Generator ---
+_PRIMITIVE_TYPES = (str, int, float, bool, type(None))
+_TYPE_MARKER_DICT = 0
+_TYPE_MARKER_LIST = 1
+_TYPE_MARKER_TUPLE = 2
+_TYPE_MARKER_SET = 3
+_TYPE_MARKER_FROZENSET = 4
+_TYPE_MARKER_PYDANTIC = 5  # Distinguishes dumped Pydantic models
+
+
+def _generate_hashable_representation(item: any) -> any:
+    """
+    Recursively converts a Python object into a stable, hashable representation.
+    This ensures that logically identical but structurally different inputs
+    (e.g., dicts with different key orders) produce the same representation.
+    """
+    if isinstance(item, _PRIMITIVE_TYPES):
+        return item
+
+    if isinstance(item, PydanticBaseModel):
+        # Process the Pydantic model by first dumping it to a dict, then processing that dict.
+        # The type marker distinguishes this from a regular dictionary.
+        return (
+            _TYPE_MARKER_PYDANTIC,
+            _generate_hashable_representation(item.model_dump()),
+        )
+
+    if isinstance(item, dict):
+        # Sort dictionary items by key (stringified) for order-insensitivity.
+        return (
+            _TYPE_MARKER_DICT,
+            tuple(
+                (str(k), _generate_hashable_representation(v))
+                for k, v in sorted(item.items(), key=lambda x: str(x[0]))
+            ),
+        )
+
+    if isinstance(item, list):
+        return (
+            _TYPE_MARKER_LIST,
+            tuple(_generate_hashable_representation(elem) for elem in item),
+        )
+
+    if isinstance(item, tuple):
+        return (
+            _TYPE_MARKER_TUPLE,
+            tuple(_generate_hashable_representation(elem) for elem in item),
+        )
+
+    # frozenset must be checked before set
+    if isinstance(item, frozenset):
+        try:  # Attempt direct sort for comparable elements
+            sorted_elements = sorted(list(item))
+        except TypeError:  # Fallback for unorderable mixed types
+            sorted_elements = sorted(
+                list(item), key=lambda x: (str(type(x)), str(x))
+            )
+        return (
+            _TYPE_MARKER_FROZENSET,
+            tuple(
+                _generate_hashable_representation(elem)
+                for elem in sorted_elements
+            ),
+        )
+
+    if isinstance(item, set):
+        try:
+            sorted_elements = sorted(list(item))
+        except TypeError:
+            sorted_elements = sorted(
+                list(item), key=lambda x: (str(type(x)), str(x))
+            )
+        return (
+            _TYPE_MARKER_SET,
+            tuple(
+                _generate_hashable_representation(elem)
+                for elem in sorted_elements
+            ),
+        )
+
+    # Fallback for other types (e.g., custom objects not derived from the above)
+    try:
+        return str(item)
+    except Exception:  # If str() fails for some reason
+        return repr(item)
+
+
+def hash_dict(data: any, strict: bool = False) -> int:
+    data_to_process = data
+    if strict:
+        data_to_process = copy.deepcopy(data)
+
+    hashable_repr = _generate_hashable_representation(data_to_process)
+
+    try:
+        return hash(hashable_repr)
+    except TypeError as e:
+        raise TypeError(
+            f"The generated representation for the input data was not hashable. "
+            f"Input type: {type(data).__name__}, Representation type: {type(hashable_repr).__name__}. "
+            f"Original error: {e}"
+        )

lionagi/libs/hash/manager.py

@@ -0,0 +1,26 @@
+class HashUtils:
+    @staticmethod
+    def hash_dict(data: any, strict: bool = False) -> int:
+        """
+        Computes a deterministic hash for various Python data structures including
+        dictionaries, Pydantic BaseModels, lists, tuples, sets, frozensets, and primitives.
+
+        The hash is deterministic within the same Python process run (respecting
+        PYTHONHASHSEED for built-in hash behavior on strings, bytes, etc.).
+        It's suitable for tasks like finding unique objects within a collection
+        during a single program execution.
+
+        Args:
+            data: The Python object to hash.
+            strict: if True, will make a deep copy of the input data to ensure immutability.
+
+        Returns:
+            An integer hash value.
+
+        Raises:
+            TypeError: If the generated internal representation of the data is not hashable,
+                    though this is unlikely with the current _generate_hashable_representation.
+        """
+        from .hash_dict import hash_dict as _hash_dict
+
+        return _hash_dict(data, strict=strict)

lionagi/models/hashable_model.py

@@ -1,7 +1,8 @@
 from pydantic import BaseModel
 from typing_extensions import Self
 
-from lionagi.utils import UNDEFINED, hash_dict
+from lionagi.libs.hash.hash_dict import hash_dict
+from lionagi.utils import UNDEFINED
 
 
 class HashableModel(BaseModel):

lionagi/operations/builder.py

@@ -14,6 +14,7 @@ from typing import Any
 from lionagi.operations.node import BranchOperations, Operation
 from lionagi.protocols.graph.edge import Edge
 from lionagi.protocols.graph.graph import Graph
+from lionagi.protocols.types import ID
 
 __all__ = (
     "OperationGraphBuilder",
@@ -76,6 +77,7 @@ class OperationGraphBuilder:
         node_id: str | None = None,
         depends_on: list[str] | None = None,
         inherit_context: bool = False,
+        branch=None,
         **parameters,
     ) -> str:
         """
@@ -108,6 +110,9 @@ class OperationGraphBuilder:
             # Add as metadata for easy lookup
             node.metadata["reference_id"] = node_id
 
+        if branch:
+            node.branch_id = ID.get_id(branch)
+
         # Handle dependencies
         if depends_on:
             for dep_id in depends_on:
@@ -227,6 +232,7 @@ class OperationGraphBuilder:
         source_node_ids: list[str] | None = None,
         inherit_context: bool = False,
         inherit_from_source: int = 0,
+        branch=None,
         **parameters,
     ) -> str:
         """
@@ -264,6 +270,9 @@ class OperationGraphBuilder:
         if node_id:
             node.metadata["reference_id"] = node_id
 
+        if branch:
+            node.branch_id = ID.get_id(branch)
+
         # Store context inheritance for aggregations
         if inherit_context and sources:
             node.metadata["inherit_context"] = True

lionagi/operations/flow.py

@@ -60,15 +60,25 @@ class DependencyAwareExecutor:
         self.operation_branches = {}  # operation_id -> Branch
 
         # Initialize completion events for all operations
+        # and check for already completed operations
         for node in graph.internal_nodes.values():
             if isinstance(node, Operation):
                 self.completion_events[node.id] = ConcurrencyEvent()
 
+                # If operation is already completed, mark it and store results
+                if node.execution.status == EventStatus.COMPLETED:
+                    self.completion_events[node.id].set()
+                    if hasattr(node, "response"):
+                        self.results[node.id] = node.response
+
     async def execute(self) -> dict[str, Any]:
         """Execute the operation graph."""
         if not self.graph.is_acyclic():
             raise ValueError("Graph must be acyclic for flow execution")
 
+        # Pre-allocate ALL branches upfront to avoid any locking during execution
+        await self._preallocate_all_branches()
+
         # Create capacity limiter for concurrency control
         # None means no limit, use the configured unlimited value
         capacity = (
@@ -91,10 +101,97 @@ class DependencyAwareExecutor:
             "final_context": self.context,
         }
 
+    async def _preallocate_all_branches(self):
+        """Pre-allocate ALL branches including for context inheritance to eliminate runtime locking."""
+        operations_needing_branches = []
+
+        # First pass: identify all operations that need branches
+        for node in self.graph.internal_nodes.values():
+            if not isinstance(node, Operation):
+                continue
+
+            # Skip if operation already has a branch_id
+            if node.branch_id:
+                try:
+                    # Ensure the branch exists in our local map
+                    branch = self.session.branches[node.branch_id]
+                    self.operation_branches[node.id] = branch
+                except:
+                    pass
+                continue
+
+            # Check if operation needs a new branch
+            predecessors = self.graph.get_predecessors(node)
+            if predecessors or node.metadata.get("inherit_context"):
+                operations_needing_branches.append(node)
+
+        if not operations_needing_branches:
+            return
+
+        # Create all branches in a single lock acquisition
+        async with self.session.branches.async_lock:
+            # For context inheritance, we need to create placeholder branches
+            # that will be updated once dependencies complete
+            for operation in operations_needing_branches:
+                # Create a fresh branch for now
+                branch_clone = self.session.default_branch.clone(
+                    sender=self.session.id
+                )
+
+                # Store in our operation branches map
+                self.operation_branches[operation.id] = branch_clone
+
+                # Add to session branches collection directly
+                # Check if this is a real branch (not a mock)
+                try:
+                    from lionagi.protocols.types import IDType
+
+                    # Try to validate the ID
+                    if hasattr(branch_clone, "id"):
+                        branch_id = branch_clone.id
+                        # Only add to collections if it's a valid ID
+                        if isinstance(branch_id, (str, IDType)) or (
+                            hasattr(branch_id, "__str__")
+                            and not hasattr(branch_id, "_mock_name")
+                        ):
+                            self.session.branches.collections[branch_id] = (
+                                branch_clone
+                            )
+                            self.session.branches.progression.append(branch_id)
+                except:
+                    # If validation fails, it's likely a mock - skip adding to collections
+                    pass
+
+                # Mark branches that need context inheritance for later update
+                if operation.metadata.get("inherit_context"):
+                    branch_clone.metadata = branch_clone.metadata or {}
+                    branch_clone.metadata["pending_context_inheritance"] = True
+                    branch_clone.metadata["inherit_from_operation"] = (
+                        operation.metadata.get("primary_dependency")
+                    )
+
+        if self.verbose:
+            print(f"Pre-allocated {len(operations_needing_branches)} branches")
+
     async def _execute_operation(
         self, operation: Operation, limiter: CapacityLimiter
     ):
         """Execute a single operation with dependency waiting."""
+        # Skip if operation is already completed
+        if operation.execution.status == EventStatus.COMPLETED:
+            if self.verbose:
+                print(
+                    f"Skipping already completed operation: {str(operation.id)[:8]}"
+                )
+            # Ensure results are available for dependencies
+            if operation.id not in self.results and hasattr(
+                operation, "response"
+            ):
+                self.results[operation.id] = operation.response
+            # Signal completion for any waiting operations
+            self.completion_events[operation.id].set()
+            return
+
         try:
             # Wait for dependencies
             await self._wait_for_dependencies(operation)
@@ -102,7 +199,7 @@ class DependencyAwareExecutor:
             # Acquire capacity to limit concurrency
             async with limiter:
                 # Prepare operation context
-                await self._prepare_operation(operation)
+                self._prepare_operation(operation)
 
                 # Execute the operation
                 if self.verbose:
@@ -191,7 +288,7 @@ class DependencyAwareExecutor:
                         f"Edge condition not satisfied for {str(operation.id)[:8]}"
                     )
 
-    async def _prepare_operation(self, operation: Operation):
+    def _prepare_operation(self, operation: Operation):
         """Prepare operation with context and branch assignment."""
         # Update operation context with predecessors
         predecessors = self.graph.get_predecessors(operation)
@@ -209,77 +306,83 @@ class DependencyAwareExecutor:
             if "context" not in operation.parameters:
                 operation.parameters["context"] = pred_context
             else:
-                operation.parameters["context"].update(pred_context)
+                # Handle case where context might be a string
+                existing_context = operation.parameters["context"]
+                if isinstance(existing_context, dict):
+                    existing_context.update(pred_context)
+                else:
+                    # If it's a string or other type, create a new dict
+                    operation.parameters["context"] = {
+                        "original_context": existing_context,
+                        **pred_context,
+                    }
 
         # Add execution context
         if self.context:
             if "context" not in operation.parameters:
                 operation.parameters["context"] = self.context.copy()
             else:
-                operation.parameters["context"].update(self.context)
+                # Handle case where context might be a string
+                existing_context = operation.parameters["context"]
+                if isinstance(existing_context, dict):
+                    existing_context.update(self.context)
+                else:
+                    # If it's a string or other type, create a new dict
+                    operation.parameters["context"] = {
+                        "original_context": existing_context,
+                        **self.context,
+                    }
 
         # Determine and assign branch
-        branch = await self._resolve_branch_for_operation(operation)
+        branch = self._resolve_branch_for_operation(operation)
         self.operation_branches[operation.id] = branch
 
-    async def _resolve_branch_for_operation(
-        self, operation: Operation
-    ) -> Branch:
-        """Resolve which branch an operation should use based on inheritance rules."""
-        # Check if operation has an explicit branch_id
-        if operation.branch_id:
-            try:
-                return self.session.branches[operation.branch_id]
-            except:
-                pass
-
-        # Get predecessors for context inheritance check
-        predecessors = self.graph.get_predecessors(operation)
+    def _resolve_branch_for_operation(self, operation: Operation) -> Branch:
+        """Resolve which branch an operation should use - all branches are pre-allocated."""
+        # All branches should be pre-allocated
+        if operation.id in self.operation_branches:
+            branch = self.operation_branches[operation.id]
+
+            # Handle deferred context inheritance
+            if (
+                hasattr(branch, "metadata")
+                and branch.metadata
+                and branch.metadata.get("pending_context_inheritance")
+            ):
+
+                primary_dep_id = branch.metadata.get("inherit_from_operation")
+                if primary_dep_id and primary_dep_id in self.results:
+                    # Find the primary dependency's branch
+                    primary_branch = self.operation_branches.get(
+                        primary_dep_id, self.session.default_branch
+                    )
 
-        # Handle context inheritance
-        if operation.metadata.get("inherit_context"):
-            primary_dep_id = operation.metadata.get("primary_dependency")
-            if primary_dep_id and primary_dep_id in self.results:
-                # Find the operation that was the primary dependency
-                for node in self.graph.internal_nodes.values():
-                    if (
-                        isinstance(node, Operation)
-                        and node.id == primary_dep_id
-                        and node.branch_id
+                    # Copy the messages from primary branch to this branch
+                    # This avoids creating a new branch and thus avoids locking
+                    # Access messages through the MessageManager
+                    if hasattr(branch, "_message_manager") and hasattr(
+                        primary_branch, "_message_manager"
                     ):
-                        try:
-                            primary_branch = self.session.branches[
-                                node.branch_id
-                            ]
-                            # Use session.branches context manager for split
-                            async with self.session.branches:
-                                split_branch = self.session.split(
-                                    primary_branch
-                                )
-                            if self.verbose:
-                                print(
-                                    f"Operation {str(operation.id)[:8]} inheriting context from {str(primary_dep_id)[:8]}"
-                                )
-                            return split_branch
-                        except:
-                            pass
-
-        # If operation has dependencies but no inheritance, create fresh branch
-        elif predecessors:
-            try:
-                async with self.session.branches:
-                    fresh_branch = self.session.split(
-                        self.session.default_branch
-                    )
-                if self.verbose:
-                    print(
-                        f"Operation {str(operation.id)[:8]} starting with fresh context"
-                    )
-                return fresh_branch
-            except:
-                pass
+                        branch._message_manager.pile.clear()
+                        for msg in primary_branch._message_manager.pile:
+                            branch._message_manager.pile.append(msg.clone())
+
+                    # Clear the pending flag
+                    branch.metadata["pending_context_inheritance"] = False
+
+                    if self.verbose:
+                        print(
+                            f"Operation {str(operation.id)[:8]} inherited context from {str(primary_dep_id)[:8]}"
+                        )
+
+            return branch
+
+        # Fallback to default branch (should not happen with proper pre-allocation)
+        if self.verbose:
+            print(
+                f"Warning: Operation {str(operation.id)[:8]} using default branch (not pre-allocated)"
+            )
 
-        # Default to session's default branch or the provided branch
         if hasattr(self, "_default_branch") and self._default_branch:
             return self._default_branch
         return self.session.default_branch