Refactor event base classes (#2491)

- Renamed `CrewEvent` to `BaseEvent` across the codebase for consistency
- Created a `CrewBaseEvent` that automatically identifies fingerprints for DRY
- Added a new `to_json()` method for serializing events

tests/utilities/events/test_crewai_event_bus.py

@@ -1,10 +1,10 @@
 from unittest.mock import Mock
 
-from crewai.utilities.events.base_events import CrewEvent
+from crewai.utilities.events.base_events import BaseEvent
 from crewai.utilities.events.crewai_event_bus import crewai_event_bus
 
 
-class TestEvent(CrewEvent):
+class TestEvent(BaseEvent):
     pass
 
 
@@ -24,7 +24,7 @@ def test_specific_event_handler():
 def test_wildcard_event_handler():
     mock_handler = Mock()
 
-    @crewai_event_bus.on(CrewEvent)
+    @crewai_event_bus.on(BaseEvent)
     def handler(source, event):
         mock_handler(source, event)
 

tests/utilities/test_serialization.py

@@ -5,8 +5,7 @@ from unittest.mock import Mock
 import pytest
 from pydantic import BaseModel
 
-from crewai.flow import Flow
-from crewai.flow.state_utils import export_state, to_serializable, to_string
+from crewai.utilities.serialization import to_serializable, to_string
 
 
 class Address(BaseModel):
@@ -23,16 +22,6 @@ class Person(BaseModel):
     skills: List[str]
 
 
-@pytest.fixture
-def mock_flow():
-    def create_flow(state):
-        flow = Mock(spec=Flow)
-        flow._state = state
-        return flow
-
-    return create_flow
-
-
 @pytest.mark.parametrize(
     "test_input,expected",
     [
@@ -47,9 +36,8 @@ def mock_flow():
         ({"nested": [1, [2, 3], {4, 5}]}, {"nested": [1, [2, 3], [4, 5]]}),
     ],
 )
-def test_basic_serialization(mock_flow, test_input, expected):
-    flow = mock_flow(test_input)
-    result = export_state(flow)
+def test_basic_serialization(test_input, expected):
+    result = to_serializable(test_input)
     assert result == expected
 
 
@@ -60,9 +48,8 @@ def test_basic_serialization(mock_flow, test_input, expected):
         (datetime(2024, 1, 1, 12, 30), "2024-01-01T12:30:00"),
     ],
 )
-def test_temporal_serialization(mock_flow, input_date, expected):
-    flow = mock_flow({"date": input_date})
-    result = export_state(flow)
+def test_temporal_serialization(input_date, expected):
+    result = to_serializable({"date": input_date})
     assert result["date"] == expected
 
 
@@ -75,9 +62,8 @@ def test_temporal_serialization(mock_flow, input_date, expected):
         ("normal", "value", str),
     ],
 )
-def test_dictionary_key_serialization(mock_flow, key, value, expected_key_type):
-    flow = mock_flow({key: value})
-    result = export_state(flow)
+def test_dictionary_key_serialization(key, value, expected_key_type):
+    result = to_serializable({key: value})
     assert len(result) == 1
     result_key = next(iter(result.keys()))
     assert isinstance(result_key, expected_key_type)
@@ -91,14 +77,13 @@ def test_dictionary_key_serialization(mock_flow, key, value, expected_key_type):
         (str.upper, "upper"),
     ],
 )
-def test_callable_serialization(mock_flow, callable_obj, expected_in_result):
-    flow = mock_flow({"func": callable_obj})
-    result = export_state(flow)
+def test_callable_serialization(callable_obj, expected_in_result):
+    result = to_serializable({"func": callable_obj})
     assert isinstance(result["func"], str)
     assert expected_in_result in result["func"].lower()
 
 
-def test_pydantic_model_serialization(mock_flow):
+def test_pydantic_model_serialization():
     address = Address(street="123 Main St", city="Tech City", country="Pythonia")
 
     person = Person(
@@ -109,23 +94,21 @@ def test_pydantic_model_serialization(mock_flow):
         skills=["Python", "Testing"],
     )
 
-    flow = mock_flow(
-        {
-            "single_model": address,
-            "nested_model": person,
-            "model_list": [address, address],
-            "model_dict": {"home": address},
-        }
-    )
+    data = {
+        "single_model": address,
+        "nested_model": person,
+        "model_list": [address, address],
+        "model_dict": {"home": address},
+    }
 
-    result = export_state(flow)
+    result = to_serializable(data)
     assert (
         to_string(result)
         == '{"single_model": {"street": "123 Main St", "city": "Tech City", "country": "Pythonia"}, "nested_model": {"name": "John Doe", "age": 30, "address": {"street": "123 Main St", "city": "Tech City", "country": "Pythonia"}, "birthday": "1994-01-01", "skills": ["Python", "Testing"]}, "model_list": [{"street": "123 Main St", "city": "Tech City", "country": "Pythonia"}, {"street": "123 Main St", "city": "Tech City", "country": "Pythonia"}], "model_dict": {"home": {"street": "123 Main St", "city": "Tech City", "country": "Pythonia"}}}'
     )
 
 
-def test_depth_limit(mock_flow):
+def test_depth_limit():
     """Test max depth handling with a deeply nested structure"""
 
     def create_nested(depth):
@@ -134,8 +117,7 @@ def test_depth_limit(mock_flow):
         return {"next": create_nested(depth - 1)}
 
     deep_structure = create_nested(10)
-    flow = mock_flow(deep_structure)
-    result = export_state(flow)
+    result = to_serializable(deep_structure)
 
     assert result == {
         "next": {