trestle.transforms.transformer_factory

class FromOscalTransformer(TransformerBase):
    """Abstract interface for transformers from OSCAL."""

    @abstractmethod
    def transform(self, obj: OscalBaseModel) -> str:
        """Transform the from OSCAL."""

class ResultsTransformer(TransformerBase):
    """Abstract interface for transformers that specifically return Results."""

    @abstractmethod
    def transform(self, blob: str) -> Results:
        """Transform the blob into Results."""

class ToOscalTransformer(TransformerBase):
    """Abstract interface for transformers to OSCAL."""

    @abstractmethod
    def transform(self, obj: str) -> OscalBaseModel:
        """Transform the to OSCAL."""

class TransformerBase(ABC):
    """Abstract base interface for all transformers."""

    # the current time for consistent timestamping
    _timestamp = datetime.datetime.now(datetime.timezone.utc).replace(microsecond=0).isoformat()

    @staticmethod
    def set_timestamp(value: str) -> None:
        """Set the default timestamp value."""
        datetime.datetime.strptime(value, '%Y-%m-%dT%H:%M:%S%z')
        TransformerBase._timestamp = value

    @staticmethod
    def get_timestamp() -> str:
        """Get the default timestamp value."""
        return TransformerBase._timestamp

    @abstractmethod
    def transform(self, blob: Any) -> Any:
        """Transform the blob into a general OscalBaseModel."""

class TransformerFactory:
    """Perform registration and creation of transformers."""

    def __init__(self) -> None:
        """Initialize the transformers dictionary as empty."""
        self._transformers: Dict[str, Type[TransformerBase]] = {}

    def register_transformer(self, name: str, transformer: Type[TransformerBase]) -> None:
        """
        Register the transformer.

        This registers transformers in the factory so they may be created by name.

        Args:
            name (str): The name of the transformer.
            transformer (TransformerBase): The transformer class to be registered.

        Returns:
            None
        """
        self._transformers[name] = transformer

    def get(self, name: str) -> TransformerBase:
        """
        Create an instance of the desired transformer based its name.

        Args:
            name (str): The name of the transformer.

        Returns:
            An instance of the desired transformer.

        Raises:
            TrestleError: if the name does not exist in the registry.
        """
        t = self._transformers.get(name)
        if t is not None:
            return t()
        raise TrestleError(f'Error getting non-registered transform {name}')