MAINT: Refactor printers into lightweight printer module

[rlundeen2]

The printer classes for attacks, scenarios, and scorers were tightly coupled to CentralMemory and the module they were in; they fetched conversations and scores at print time. This made them unusable from thin clients that don't have the full PyRIT framework but need the same pretty-printing with data fetched via REST APIs.

This refactor moves abstract base classes into a new pyrit/printer/ module. Data-fetching operations are abstract, so in the framework we can grab them from memory. Or a REST API caller can grab them from the REST endpoints.

All functionality is the same; but this allows us to use the same printing once we replace our cli frontend to use the REST API

[nina-msft]

nit: why not name this ConsoleAttackResultPrinter for continuity?

[rlundeen2]

I want to distinguish between the printer that uses memory and the future printer that uses the rest api. So there will also be a ConsoleAttackRestPrinter

Similar with other classes

[nina-msft]

should we have an empty implementation of this defined as AttackResultPrinter so we can avoid importing ABC as that? Or do we intend for the console & markdown printers to be the only concrete implementations?

[nina-msft]

First reaction to all the to_dict and from_dict implementations is "wow that's a lot of string literals" 😆

I asked copilot if there was an easier way to reduce these to avoid duplication and also make it more maintainable and here's what it came up with - lmk what you think!

Suggestion: Reduce string-literal duplication in to_dict / from_dict

Across AttackResult, ScenarioResult, Score, MessagePiece, RetryEvent, ConversationReference, etc., every field name appears as a string literal 2–3 times (once in to_dict, once in
from_dict, and once as the attribute). This is error-prone and verbose.

Since the dict keys almost always match the attribute names exactly, we could add a small shared helper like:

   def _serialize_value(value):
       if isinstance(value, datetime):    return value.isoformat()
       if isinstance(value, Enum):        return value.value
       if isinstance(value, uuid.UUID):   return str(value)
       if hasattr(value, 'to_dict'):      return value.to_dict()
       if isinstance(value, (list, set)): return [_serialize_value(v) for v in value]
       if isinstance(value, dict):        return {k: _serialize_value(v) for k, v in value.items()}
       return value

Then most to_dict() implementations collapse to:

   def to_dict(self):
       return {k: _serialize_value(v) for k, v in vars(self).items() if not k.startswith('_')}

Simple classes like RetryEvent and ConversationReference would need zero overrides. More complex ones could call the base and patch a few keys. This could also be a Serializable mixin
so to_dict() is inherited.

[rlundeen2]

I like how you're thinking about this Nina!

But I think in this case is the easier; from_dict is tricky. And I think if the serialization is split, it makes it tough. And things like ComponentIdentifier is fairly incompatible since it flattens various things. So I think the mixin would need a lot of special cases

As is, it's verbose, but I think it's easier to debug and maintain.

BUT I did add some tests based on this comment so we can verify

Class.from_dict(obj.to_dict()) == obj