blend_base.py

Go to the documentation of this file.

from __future__ import annotations
 
from abc import ABC, abstractmethod
from dataclasses import dataclass
from typing import Any, ClassVar
 
import numpy as np
from numpy.typing import DTypeLike
 
from ..bbox import Box
from .utils import PersistenceError
 
__all__ = ["ScarletBlendBaseData"]
 
 
@dataclass(kw_only=True)
class ScarletBlendBaseData(ABC):
    """Base data for a scarlet Blend data.
 
    Attributes
    ----------
    blend_registry :
        A registry of all known blend types used for deserialization.
    blend_type :
        The type of blend being stored.
    metadata :
        Metadata associated with the blend.
    version :
        The schema version of the exact data class.
    """
 
    blend_registry: ClassVar[dict[str, type[ScarletBlendBaseData]]] = {}
    blend_type: str
    metadata: dict[str, Any] | None = None
    version: str
 
    @property
    @abstractmethod
    def bbox(self) -> Box:
        """The bounding box of the blend"""
 
    @classmethod
    def register(cls) -> None:
        """Register a new Blend type"""
        ScarletBlendBaseData.blend_registry[cls.blend_type] = cls
 
    @abstractmethod
    def as_dict(self) -> dict:
        """Return the object encoded into a dict for JSON serialization
 
        Returns
        -------
        result :
            The object encoded as a JSON compatible dict
        """
 
    @staticmethod
    def from_dict(data: dict, dtype: DTypeLike = np.float32) -> ScarletBlendBaseData:
        """Reconstruct `ScarletBlendBaseData` from JSON compatible dict.
 
        Parameters
        ----------
        data :
            Dictionary representation of the object
        dtype :
            Datatype of the resulting model.
 
        Returns
        -------
        result :
            The reconstructed object
        """
        # Default to "blend" for backwards compatibility
        blend_type = data.get("blend_type", "blend")
 
        if blend_type not in ScarletBlendBaseData.blend_registry:
            raise PersistenceError(f"Unknown blend type: {blend_type}")
 
        cls = ScarletBlendBaseData.blend_registry[blend_type]
        return cls.from_dict(data, dtype=dtype)