refactor(giskard-checks)!: remove Scenario.from_sequence

Author: henchaves

libs/giskard-checks/README.md

@@ -280,7 +280,7 @@ from giskard.checks import Scenario
 
 chat = ChatInteraction(session_id="session_123", messages=["hi", "hello"])
 check = AdvancedSecurityCheck(name="security_test", threshold=0.7)
-scenario = Scenario.from_sequence(chat, check, name="custom_test")
+scenario = Scenario(name="custom_test").extend(chat, check)
 
 serialized = scenario.model_dump()
 restored = Scenario.model_validate(serialized)
@@ -552,10 +552,9 @@ from giskard.checks import (
     Equals # Inherits from `Check`
 )
 
-scenario = Scenario.from_sequence(
+scenario = Scenario(name="programmatic_scenario").extend(
     Interact(inputs="Hello", outputs=lambda inputs: "Hi"),
     Equals(expected_value="Hi", key="trace.last.outputs"),
-    name="programmatic_scenario",
 )
 
 result = await scenario.run()

libs/giskard-checks/src/giskard/checks/core/scenario.py

@@ -48,7 +48,7 @@ class Scenario[InputType, OutputType, TraceType: Trace](BaseModel):  # pyright:
         result = await scenario.run()
 
     For advanced usage you can instantiate with pre-filled steps or use
-    ``from_sequence()`` for a flat list of components:
+    ``extend()`` for a flat list of components:
 
         from giskard.checks import Scenario, Interact, Equals
         scenario = Scenario(
@@ -110,36 +110,6 @@ def __init__(
             kwargs["name"] = name
         super().__init__(**kwargs)
 
-    @classmethod
-    def from_sequence(
-        cls,
-        *components: (
-            InteractionSpec[InputType, OutputType, TraceType]
-            | Check[InputType, OutputType, TraceType]
-        ),
-        name: str = "Unnamed Scenario",
-        trace_type: type[TraceType] | None = None,
-        annotations: dict[str, Any] | None = None,
-        target: (
-            ProviderType[[InputType], OutputType]
-            | ProviderType[[InputType, TraceType], OutputType]
-            | NotProvided
-        ) = NOT_PROVIDED,
-    ) -> Self:
-        """Create a scenario from a flat sequence of components.
-
-        Components are grouped into steps: a new step is created whenever an
-        InteractionSpec follows a Check.
-        """
-        without_steps = cls(
-            name=name,
-            trace_type=trace_type,
-            annotations=annotations or {},
-            target=target,
-        )
-
-        return without_steps.extend(*components)
-
     def _append_step(self) -> Step[InputType, OutputType, TraceType]:
         """Append a new step."""
         step = Step(interacts=[], checks=[])

libs/giskard-checks/tests/core/test_scenario.py

@@ -1016,24 +1016,23 @@ async def test_interact_with_trace_dependent_inputs(self):
         assert result.final_trace.interactions[0].outputs == "Received: Message #1"
 
 
-class TestScenarioFromSequenceAndSerialization:
-    """Test Scenario.from_sequence() and step-based serialization."""
+class TestScenarioExtendAndSerialization:
+    """Test Scenario.extend() and step-based serialization."""
 
-    async def test_from_sequence_equivalent_to_fluent_api(self):
-        """Scenario.from_sequence() produces same result as fluent API."""
+    async def test_extend_equivalent_to_fluent_api(self):
+        """Scenario(...).extend(...) produces same result as fluent API."""
         fluent = (
             Scenario("fluent")
             .interact("Hello", "Hi")
             .check(Equals(expected_value="Hi", key="trace.last.outputs"))
             .interact("World", "Echo: World")
             .check(Equals(expected_value="Echo: World", key="trace.last.outputs"))
         )
-        from_seq = Scenario.from_sequence(
+        from_seq = Scenario(name="fluent").extend(
             Interact(inputs="Hello", outputs="Hi"),
             Equals(expected_value="Hi", key="trace.last.outputs"),
             Interact(inputs="World", outputs="Echo: World"),
             Equals(expected_value="Echo: World", key="trace.last.outputs"),
-            name="fluent",
         )
 
         result_fluent = await fluent.run()
@@ -1045,10 +1044,10 @@ async def test_from_sequence_equivalent_to_fluent_api(self):
             result_from_seq.final_trace.interactions
         )
 
-    async def test_from_sequence_with_only_checks(self):
-        """from_sequence handles scenario starting with checks only."""
+    async def test_extend_with_only_checks(self):
+        """extend handles scenario starting with checks only."""
         check = MockCheck(result=CheckResult.success(message="OK"))
-        scenario = Scenario.from_sequence(check, name="checks_only")
+        scenario = Scenario(name="checks_only").extend(check)
         result = await scenario.run()
         assert result.passed
         assert len(result.steps) == 1

libs/giskard-checks/tests/integration/test_stateless.py

@@ -91,7 +91,10 @@ async def adapter(message: agents.Message, trace: MessageTraces) -> agents.Messa
 async def test_single_message(
     adapter: Callable[[agents.Message, MessageTraces], Awaitable[agents.Message]],
 ):
-    scenario = Scenario[Any, Any, MessageTraces].from_sequence(
+    scenario = Scenario[Any, Any, MessageTraces](
+        name="test_single_message",
+        trace_type=MessageTraces,
+    ).extend(
         WithSpy(
             interaction_generator=Interact(
                 inputs=agents.Message(
@@ -122,8 +125,6 @@ async def test_single_message(
             expected_value="Hello, I want to apply for a job.",
             key="trace.interactions[-1].metadata['tests.integration.test_stateless.mock_apply_tool']['call_args'].args[1]",
         ),
-        name="test_single_message",
-        trace_type=MessageTraces,
     )
     result = await scenario.run()
     assert result.failed  # No tool call is made somehow