Apply automatic linting fixes to src directory

Co-Authored-By: Joe Moura <joao@crewai.com>

src/crewai/flow/persistence/decorators.py

@@ -1,5 +1,4 @@
-"""
-Decorators for flow state persistence.
+"""Decorators for flow state persistence.
 
 Example:
     ```python
@@ -19,18 +18,16 @@ Example:
             # Asynchronous method implementation
             await some_async_operation()
     ```
+
 """
 
 import asyncio
 import functools
 import logging
+from collections.abc import Callable
 from typing import (
     Any,
-    Callable,
-    Optional,
-    Type,
     TypeVar,
-    Union,
     cast,
 )
 
@@ -48,7 +45,7 @@ LOG_MESSAGES = {
     "save_state": "Saving flow state to memory for ID: {}",
     "save_error": "Failed to persist state for method {}: {}",
     "state_missing": "Flow instance has no state",
-    "id_missing": "Flow state must have an 'id' field for persistence"
+    "id_missing": "Flow state must have an 'id' field for persistence",
 }
 
 
@@ -74,20 +71,23 @@ class PersistenceDecorator:
             ValueError: If flow has no state or state lacks an ID
             RuntimeError: If state persistence fails
             AttributeError: If flow instance lacks required state attributes
+
         """
         try:
-            state = getattr(flow_instance, 'state', None)
+            state = getattr(flow_instance, "state", None)
             if state is None:
-                raise ValueError("Flow instance has no state")
+                msg = "Flow instance has no state"
+                raise ValueError(msg)
 
-            flow_uuid: Optional[str] = None
+            flow_uuid: str | None = None
             if isinstance(state, dict):
-                flow_uuid = state.get('id')
+                flow_uuid = state.get("id")
             elif isinstance(state, BaseModel):
-                flow_uuid = getattr(state, 'id', None)
+                flow_uuid = getattr(state, "id", None)
 
             if not flow_uuid:
-                raise ValueError("Flow state must have an 'id' field for persistence")
+                msg = "Flow state must have an 'id' field for persistence"
+                raise ValueError(msg)
 
             # Log state saving only if verbose is True
             if verbose:
@@ -103,21 +103,22 @@ class PersistenceDecorator:
             except Exception as e:
                 error_msg = LOG_MESSAGES["save_error"].format(method_name, str(e))
                 cls._printer.print(error_msg, color="red")
-                logger.error(error_msg)
-                raise RuntimeError(f"State persistence failed: {str(e)}") from e
+                logger.exception(error_msg)
+                msg = f"State persistence failed: {e!s}"
+                raise RuntimeError(msg) from e
         except AttributeError:
             error_msg = LOG_MESSAGES["state_missing"]
             cls._printer.print(error_msg, color="red")
-            logger.error(error_msg)
+            logger.exception(error_msg)
             raise ValueError(error_msg)
         except (TypeError, ValueError) as e:
             error_msg = LOG_MESSAGES["id_missing"]
             cls._printer.print(error_msg, color="red")
-            logger.error(error_msg)
+            logger.exception(error_msg)
             raise ValueError(error_msg) from e
 
 
-def persist(persistence: Optional[FlowPersistence] = None, verbose: bool = False):
+def persist(persistence: FlowPersistence | None = None, verbose: bool = False):
     """Decorator to persist flow state.
 
     This decorator can be applied at either the class level or method level.
@@ -143,22 +144,23 @@ def persist(persistence: Optional[FlowPersistence] = None, verbose: bool = False
             @start()
             def begin(self):
                 pass
+
     """
-    def decorator(target: Union[Type, Callable[..., T]]) -> Union[Type, Callable[..., T]]:
+    def decorator(target: type | Callable[..., T]) -> type | Callable[..., T]:
         """Decorator that handles both class and method decoration."""
         actual_persistence = persistence or SQLiteFlowPersistence()
 
         if isinstance(target, type):
             # Class decoration
-            original_init = getattr(target, "__init__")
+            original_init = target.__init__
 
             @functools.wraps(original_init)
             def new_init(self: Any, *args: Any, **kwargs: Any) -> None:
-                if 'persistence' not in kwargs:
-                    kwargs['persistence'] = actual_persistence
+                if "persistence" not in kwargs:
+                    kwargs["persistence"] = actual_persistence
                 original_init(self, *args, **kwargs)
 
-            setattr(target, "__init__", new_init)
+            target.__init__ = new_init
 
             # Store original methods to preserve their decorators
             original_methods = {}
@@ -191,7 +193,7 @@ def persist(persistence: Optional[FlowPersistence] = None, verbose: bool = False
                     for attr in ["__is_start_method__", "__trigger_methods__", "__condition_type__", "__is_router__"]:
                         if hasattr(method, attr):
                             setattr(wrapped, attr, getattr(method, attr))
-                    setattr(wrapped, "__is_flow_method__", True)
+                    wrapped.__is_flow_method__ = True
 
                     # Update the class with the wrapped method
                     setattr(target, name, wrapped)
@@ -211,44 +213,42 @@ def persist(persistence: Optional[FlowPersistence] = None, verbose: bool = False
                     for attr in ["__is_start_method__", "__trigger_methods__", "__condition_type__", "__is_router__"]:
                         if hasattr(method, attr):
                             setattr(wrapped, attr, getattr(method, attr))
-                    setattr(wrapped, "__is_flow_method__", True)
+                    wrapped.__is_flow_method__ = True
 
                     # Update the class with the wrapped method
                     setattr(target, name, wrapped)
 
             return target
-        else:
-            # Method decoration
-            method = target
-            setattr(method, "__is_flow_method__", True)
+        # Method decoration
+        method = target
+        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:
-                    method_coro = method(flow_instance, *args, **kwargs)
-                    if asyncio.iscoroutine(method_coro):
-                        result = await method_coro
-                    else:
-                        result = method_coro
-                    PersistenceDecorator.persist_state(flow_instance, method.__name__, actual_persistence, verbose)
-                    return result
+        if asyncio.iscoroutinefunction(method):
+            @functools.wraps(method)
+            async def method_async_wrapper(flow_instance: Any, *args: Any, **kwargs: Any) -> T:
+                method_coro = method(flow_instance, *args, **kwargs)
+                if asyncio.iscoroutine(method_coro):
+                    result = await method_coro
+                else:
+                    result = method_coro
+                PersistenceDecorator.persist_state(flow_instance, method.__name__, actual_persistence, verbose)
+                return result
 
-                for attr in ["__is_start_method__", "__trigger_methods__", "__condition_type__", "__is_router__"]:
-                    if hasattr(method, attr):
-                        setattr(method_async_wrapper, attr, getattr(method, attr))
-                setattr(method_async_wrapper, "__is_flow_method__", True)
-                return cast(Callable[..., T], method_async_wrapper)
-            else:
-                @functools.wraps(method)
-                def method_sync_wrapper(flow_instance: Any, *args: Any, **kwargs: Any) -> T:
-                    result = method(flow_instance, *args, **kwargs)
-                    PersistenceDecorator.persist_state(flow_instance, method.__name__, actual_persistence, verbose)
-                    return result
+            for attr in ["__is_start_method__", "__trigger_methods__", "__condition_type__", "__is_router__"]:
+                if hasattr(method, attr):
+                    setattr(method_async_wrapper, attr, getattr(method, attr))
+            method_async_wrapper.__is_flow_method__ = True
+            return cast("Callable[..., T]", method_async_wrapper)
+        @functools.wraps(method)
+        def method_sync_wrapper(flow_instance: Any, *args: Any, **kwargs: Any) -> T:
+            result = method(flow_instance, *args, **kwargs)
+            PersistenceDecorator.persist_state(flow_instance, method.__name__, actual_persistence, verbose)
+            return result
 
-                for attr in ["__is_start_method__", "__trigger_methods__", "__condition_type__", "__is_router__"]:
-                    if hasattr(method, attr):
-                        setattr(method_sync_wrapper, attr, getattr(method, attr))
-                setattr(method_sync_wrapper, "__is_flow_method__", True)
-                return cast(Callable[..., T], method_sync_wrapper)
+        for attr in ["__is_start_method__", "__trigger_methods__", "__condition_type__", "__is_router__"]:
+            if hasattr(method, attr):
+                setattr(method_sync_wrapper, attr, getattr(method, attr))
+        method_sync_wrapper.__is_flow_method__ = True
+        return cast("Callable[..., T]", method_sync_wrapper)
 
     return decorator