updating tools version

src/crewai/flow/__init__.py

@@ -1,3 +1,5 @@
-from crewai.flow.flow import Flow
+from crewai.flow.flow import Flow, start, listen, or_, and_, router
+from crewai.flow.persistence import persist
+
+__all__ = ["Flow", "start", "listen", "or_", "and_", "router", "persist"]
 
-__all__ = ["Flow"]

src/crewai/flow/flow.py

@@ -63,14 +63,14 @@ def ensure_state_type(state: Any, expected_type: Type[StateT]) -> StateT:
         ValueError: If state validation fails
     """
     """Ensure state matches expected type with proper validation.
-    
+
     Args:
         state: State instance to validate
         expected_type: Expected type for the state
-        
+
     Returns:
         Validated state instance
-        
+
     Raises:
         TypeError: If state doesn't match expected type
         ValueError: If state validation fails
@@ -612,7 +612,6 @@ class Flow(Generic[T], metaclass=FlowMeta):
             # Create new instance of the same class
             model_class = type(model)
             return cast(T, model_class(**state_dict))
-
         raise TypeError(
             f"Initial state must be dict or BaseModel, got {type(self.initial_state)}"
         )

src/crewai/flow/persistence/decorators.py

@@ -5,14 +5,14 @@ Example:
     ```python
     from crewai.flow.flow import Flow, start
     from crewai.flow.persistence import persist, SQLiteFlowPersistence
-    
+
     class MyFlow(Flow):
         @start()
         @persist(SQLiteFlowPersistence())
         def sync_method(self):
             # Synchronous method implementation
             pass
-            
+
         @start()
         @persist(SQLiteFlowPersistence())
         async def async_method(self):
@@ -23,18 +23,15 @@ Example:
 
 import asyncio
 import functools
-import inspect
 import logging
 from typing import (
     Any,
     Callable,
-    Dict,
     Optional,
     Type,
     TypeVar,
     Union,
     cast,
-    get_type_hints,
 )
 
 from pydantic import BaseModel
@@ -48,23 +45,23 @@ T = TypeVar("T")
 
 def persist(persistence: Optional[FlowPersistence] = None):
     """Decorator to persist flow state.
-    
+
     This decorator can be applied at either the class level or method level.
     When applied at the class level, it automatically persists all flow method
     states. When applied at the method level, it persists only that method's
     state.
-    
+
     Args:
         persistence: Optional FlowPersistence implementation to use.
                     If not provided, uses SQLiteFlowPersistence.
-    
+
     Returns:
         A decorator that can be applied to either a class or method
-    
+
     Raises:
         ValueError: If the flow state doesn't have an 'id' field
         RuntimeError: If state persistence fails
-        
+
     Example:
         @persist  # Class-level persistence with default SQLite
         class MyFlow(Flow[MyState]):
@@ -79,18 +76,18 @@ def persist(persistence: Optional[FlowPersistence] = None):
             state = getattr(flow_instance, 'state', None)
             if state is None:
                 raise ValueError("Flow instance has no state")
-                
+
             flow_uuid: Optional[str] = None
             if isinstance(state, dict):
                 flow_uuid = state.get('id')
             elif isinstance(state, BaseModel):
                 flow_uuid = getattr(state, 'id', None)
-                
+
             if not flow_uuid:
                 raise ValueError(
                     "Flow state must have an 'id' field for persistence"
                 )
-                
+
             # Persist the state
             persistence_instance.save_state(
                 flow_uuid=flow_uuid,
@@ -102,11 +99,11 @@ def persist(persistence: Optional[FlowPersistence] = None):
                 f"Failed to persist state for method {method_name}: {str(e)}"
             )
             raise RuntimeError(f"State persistence failed: {str(e)}") from e
-    
+
     def decorator(target: Union[Type, Callable[..., T]]) -> Union[Type, Callable[..., T]]:
         """Decorator that handles both class and method decoration."""
         actual_persistence = persistence or SQLiteFlowPersistence()
-        
+
         if isinstance(target, type):
             # Class decoration
             class_methods = {}
@@ -131,13 +128,13 @@ def persist(persistence: Optional[FlowPersistence] = None):
                             _persist_state(self, method.__name__, actual_persistence)
                             return result
                         class_methods[name] = class_sync_wrapper
-                    
+
                     # Preserve flow-specific attributes
                     for attr in ["__is_start_method__", "__trigger_methods__", "__condition_type__", "__is_router__"]:
                         if hasattr(method, attr):
                             setattr(class_methods[name], attr, getattr(method, attr))
                     setattr(class_methods[name], "__is_flow_method__", True)
-            
+
             # Update class with wrapped methods
             for name, method in class_methods.items():
                 setattr(target, name, method)
@@ -146,7 +143,7 @@ def persist(persistence: Optional[FlowPersistence] = None):
             # Method decoration
             method = target
             setattr(method, "__is_flow_method__", True)
-            
+
             if asyncio.iscoroutinefunction(method):
                 @functools.wraps(method)
                 async def method_async_wrapper(flow_instance: Any, *args: Any, **kwargs: Any) -> T:
@@ -173,5 +170,5 @@ def persist(persistence: Optional[FlowPersistence] = None):
                         setattr(method_sync_wrapper, attr, getattr(method, attr))
                 setattr(method_sync_wrapper, "__is_flow_method__", True)
                 return cast(Callable[..., T], method_sync_wrapper)
-            
+
     return decorator