FIX: Resolve CI failures from upstream merge with PR #1881 (Pydantic identifiers)

Four related fixes needed to unblock CI after the upstream merge that
brought in PR #1881 (Refactoring Identifiers to be Pydantic classes):

1. `pyrit/models/identifiers/evaluation_identifier.py`:
   The merge hoisted `from pyrit.executor.attack.core.attack_strategy
   import AttackStrategy` to module level, forming a cycle through
   `pyrit.executor.attack` -> `pyrit.message_normalizer` ->
   `pyrit.common.data_url_converter` -> `pyrit.models`. Move it back
   inside `if TYPE_CHECKING:` (`from __future__ import annotations`
   is already enabled, so the string annotation `attack: AttackStrategy`
   still resolves at type-check time).

2. `tests/unit/models/identifiers/test_evaluation_identifier.py`:
   Add missing blank lines between top-level classes (ruff format) and
   replace four `from pyrit.identifiers import ...` lines with
   `from pyrit.models.identifiers import ...` (the former is now a
   deprecation shim that the static-scan deprecation test forbids
   internal callers from using).

3. `pyrit/scenario/scenarios/adaptive/adaptive_scenario.py`:
   Mark the three classmethod stubs as `@abstractmethod` so
   `inspect.isabstract(AdaptiveScenario)` returns `True` and the
   scenario registry's auto-discovery skips it (otherwise the registry
   tries to instantiate the abstract base and raises
   `NotImplementedError`, breaking `test_load_default_datasets`).

4. `pyrit/scenario/scenarios/adaptive/adaptive_scenario.py` and
   `pyrit/scenario/scenarios/adaptive/text_adaptive.py`:
   Move `from pyrit.setup.initializers.components.scenario_techniques
   import build_scenario_technique_factories` from module level back
   into the function body. `scenario_techniques` imports
   `pyrit.scenario.core`, which transitively re-imports the adaptive
   package during `pyrit.scenario` initialization, so a top-level
   import forms a cycle.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: hannahwestra25

pyrit/models/identifiers/evaluation_identifier.py

@@ -23,13 +23,15 @@
 from __future__ import annotations
 
 from abc import ABC
-from typing import Any, ClassVar, Optional
+from typing import TYPE_CHECKING, Any, ClassVar, Optional
 
 from pydantic import BaseModel, ConfigDict, Field
 
-from pyrit.executor.attack.core.attack_strategy import AttackStrategy
 from pyrit.models.identifiers.component_identifier import ComponentIdentifier, config_hash
 
+if TYPE_CHECKING:
+    from pyrit.executor.attack.core.attack_strategy import AttackStrategy
+
 # Behavioral params that define model output quality for scoring.
 TARGET_EVAL_PARAMS: frozenset[str] = frozenset({"underlying_model_name", "temperature", "top_p"})
 TARGET_EVAL_PARAM_FALLBACKS: dict[str, str] = {"underlying_model_name": "model_name"}

pyrit/scenario/scenarios/adaptive/adaptive_scenario.py

@@ -17,6 +17,7 @@
 from __future__ import annotations
 
 import logging
+from abc import abstractmethod
 from typing import TYPE_CHECKING, ClassVar
 
 from pyrit.executor.attack import AttackScoringConfig
@@ -32,9 +33,6 @@
     EpsilonGreedyTechniqueSelector,
     TechniqueSelector,
 )
-from pyrit.setup.initializers.components.scenario_techniques import (
-    build_scenario_technique_factories,
-)
 
 if TYPE_CHECKING:
     from pyrit.models import SeedAttackGroup
@@ -63,16 +61,19 @@ class AdaptiveScenario(Scenario):
     _atomic_attack_prefix: ClassVar[str] = "adaptive"
 
     @classmethod
+    @abstractmethod
     def get_strategy_class(cls) -> type[ScenarioStrategy]:
         """Return the scenario's strategy enum (subclasses must override)."""
         raise NotImplementedError
 
     @classmethod
+    @abstractmethod
     def get_default_strategy(cls) -> ScenarioStrategy:
         """Return the scenario's default strategy aggregate (subclasses must override)."""
         raise NotImplementedError
 
     @classmethod
+    @abstractmethod
     def default_dataset_config(cls) -> DatasetConfiguration:
         """Return the scenario's default ``DatasetConfiguration`` (subclasses must override)."""
         raise NotImplementedError
@@ -120,6 +121,13 @@ def _get_attack_technique_factories(self) -> dict[str, AttackTechniqueFactory]:
         Returns:
             dict[str, AttackTechniqueFactory]: Mapping of technique name to factory.
         """
+        # Local import: ``scenario_techniques`` imports ``pyrit.scenario.core``,
+        # which transitively re-imports this module, so a top-level import
+        # would form a cycle during ``pyrit.scenario`` package initialization.
+        from pyrit.setup.initializers.components.scenario_techniques import (
+            build_scenario_technique_factories,
+        )
+
         return {factory.name: factory for factory in build_scenario_technique_factories()}
 
     async def _get_atomic_attacks_async(self) -> list[AtomicAttack]:

pyrit/scenario/scenarios/adaptive/text_adaptive.py

@@ -24,9 +24,6 @@
 from pyrit.registry.tag_query import TagQuery
 from pyrit.scenario.core.dataset_configuration import DatasetConfiguration
 from pyrit.scenario.scenarios.adaptive.adaptive_scenario import AdaptiveScenario
-from pyrit.setup.initializers.components.scenario_techniques import (
-    build_scenario_technique_factories,
-)
 
 if TYPE_CHECKING:
     from pyrit.scenario.core.scenario_strategy import ScenarioStrategy
@@ -48,6 +45,13 @@ def _build_text_adaptive_strategy() -> type[ScenarioStrategy]:
     Returns:
         type[ScenarioStrategy]: The dynamically-built strategy enum class.
     """
+    # Local import: ``scenario_techniques`` imports ``pyrit.scenario.core``,
+    # which transitively re-imports this module, so a top-level import would
+    # form a cycle during ``pyrit.scenario`` package initialization.
+    from pyrit.setup.initializers.components.scenario_techniques import (
+        build_scenario_technique_factories,
+    )
+
     factories = [
         factory for factory in build_scenario_technique_factories() if factory.name not in _EXCLUDED_TECHNIQUES
     ]

tests/unit/models/identifiers/test_evaluation_identifier.py

@@ -585,6 +585,7 @@ def test_scorer_eval_hash_matches_with_and_without_round_robin(self):
 
         assert eval_direct == eval_rr
 
+
 class TestComputeInnerAttackEvalHash:
     """``compute_inner_attack_eval_hash`` should match what the executor stamps."""
 
@@ -597,7 +598,7 @@ def _attack_with_identifier(self, identifier: ComponentIdentifier):
 
     def test_matches_manual_two_step_composition(self):
         """Helper equals the executor recipe (build_atomic_attack_identifier + AtomicAttackEvaluationIdentifier)."""
-        from pyrit.identifiers import (
+        from pyrit.models.identifiers import (
             AtomicAttackEvaluationIdentifier,
             build_atomic_attack_identifier,
             compute_inner_attack_eval_hash,
@@ -615,7 +616,7 @@ def test_matches_manual_two_step_composition(self):
         assert compute_inner_attack_eval_hash(attack=attack) == expected
 
     def test_differs_when_attack_class_differs(self):
-        from pyrit.identifiers import compute_inner_attack_eval_hash
+        from pyrit.models.identifiers import compute_inner_attack_eval_hash
 
         a = self._attack_with_identifier(
             ComponentIdentifier(class_name="A", class_module="m"),
@@ -626,7 +627,7 @@ def test_differs_when_attack_class_differs(self):
         assert compute_inner_attack_eval_hash(attack=a) != compute_inner_attack_eval_hash(attack=b)
 
     def test_stable_across_calls_for_same_attack(self):
-        from pyrit.identifiers import compute_inner_attack_eval_hash
+        from pyrit.models.identifiers import compute_inner_attack_eval_hash
 
         attack = self._attack_with_identifier(
             ComponentIdentifier(class_name="Same", class_module="m"),
@@ -636,9 +637,9 @@ def test_stable_across_calls_for_same_attack(self):
     def test_matches_persisted_row_eval_hash(self):
         """Whatever the helper returns, persisting an attack result with the same
         identifier must yield an entry with the same eval_hash."""
-        from pyrit.identifiers import build_atomic_attack_identifier, compute_inner_attack_eval_hash
         from pyrit.memory.memory_models import AttackResultEntry
         from pyrit.models import AttackResult
+        from pyrit.models.identifiers import build_atomic_attack_identifier, compute_inner_attack_eval_hash
 
         inner_id = ComponentIdentifier(
             class_name="MyAttack",
@@ -654,6 +655,8 @@ def test_matches_persisted_row_eval_hash(self):
         )
         entry = AttackResultEntry(entry=result)
         assert entry.atomic_attack_identifier["eval_hash"] == predicted
+
+
 # ---------------------------------------------------------------------------
 # OWN_RULE / leaf-entity eval-hash tests
 # ---------------------------------------------------------------------------
@@ -864,6 +867,7 @@ def test_stored_eval_hash_takes_precedence(self):
 
         assert ObjectiveTargetEvaluationIdentifier(cid).eval_hash == stored
 
+
 class TestComputeInnerAttackEvalHash:
     """``compute_inner_attack_eval_hash`` should match what the executor stamps."""