image

A Evidence instance for image media.

Image

Bases: Evidence

Image implements the Value interface for image media.

Source code in mlte/evidence/types/image.py

class Image(Evidence):
    """
    Image implements the Value interface for image media.
    """

    def __init__(
        self,
        image: str | Path | bytes,
    ):
        """
        Initialize an Image instance.
        :param image: The path to the image (str, Path) or raw image data (bytes)
        """
        if isinstance(image, str):
            image = Path(image)

        if isinstance(image, Path):
            with image.open("rb") as f:
                image = f.read()
        assert isinstance(image, bytes), "Broken invariant."

        super().__init__()

        # TODO(Kyle): Unsure if storing media inline is the
        # right way to go here (not scalable); reassess this.

        self.image: bytes = image
        """The data of the referenced image."""

    def to_model(self) -> ArtifactModel:
        """
        Convert an image value artifact to its corresponding model.
        :return: The artifact model
        """
        return self._to_artifact_model(
            value_model=ImageValueModel(
                data=base64.encodebytes(self.image).decode("utf-8"),
            ),
        )

    @classmethod
    def from_model(cls, model: BaseModel) -> Image:
        """
        Convert an opaque value model to its corresponding artifact.
        :param model: The model representation
        :return: The real value
        """
        body = cls._check_proper_types(model, EvidenceType.IMAGE)
        return Image(
            image=base64.decodebytes(body.value.data.encode("utf-8"))  # type: ignore
        ).with_metadata(body.metadata)

    @classmethod
    def register_info(cls, info: str) -> Validator:
        """
        Register info about an image value.
        :param info: The information to record.
        :return: The Validator that can be used.
        """
        return Validator.build_info_validator(info)

    # Overriden.
    @classmethod
    def load(cls, identifier: str | None = None) -> Image:
        evidence = super().load(identifier)
        return typing.cast(Image, evidence)

    def __str__(self) -> str:
        """Return a string representation of this Evidence."""
        return f"Image size: {len(self.image)}"

image = image instance-attribute

The data of the referenced image.

__init__(image)

Initialize an Image instance.

Parameters:

Name	Type	Description	Default
image	str | Path | bytes	The path to the image (str, Path) or raw image data (bytes)	required

Source code in mlte/evidence/types/image.py

def __init__(
    self,
    image: str | Path | bytes,
):
    """
    Initialize an Image instance.
    :param image: The path to the image (str, Path) or raw image data (bytes)
    """
    if isinstance(image, str):
        image = Path(image)

    if isinstance(image, Path):
        with image.open("rb") as f:
            image = f.read()
    assert isinstance(image, bytes), "Broken invariant."

    super().__init__()

    # TODO(Kyle): Unsure if storing media inline is the
    # right way to go here (not scalable); reassess this.

    self.image: bytes = image
    """The data of the referenced image."""

__str__()

Return a string representation of this Evidence.

Source code in mlte/evidence/types/image.py

def __str__(self) -> str:
    """Return a string representation of this Evidence."""
    return f"Image size: {len(self.image)}"

from_model(model) classmethod

Convert an opaque value model to its corresponding artifact.

Parameters:

Name	Type	Description	Default
model	BaseModel	The model representation	required

Returns:

Type	Description
Image	The real value

Source code in mlte/evidence/types/image.py

@classmethod
def from_model(cls, model: BaseModel) -> Image:
    """
    Convert an opaque value model to its corresponding artifact.
    :param model: The model representation
    :return: The real value
    """
    body = cls._check_proper_types(model, EvidenceType.IMAGE)
    return Image(
        image=base64.decodebytes(body.value.data.encode("utf-8"))  # type: ignore
    ).with_metadata(body.metadata)

register_info(info) classmethod

Register info about an image value.

Parameters:

Name	Type	Description	Default
info	str	The information to record.	required

Returns:

Type	Description
Validator	The Validator that can be used.

Source code in mlte/evidence/types/image.py

@classmethod
def register_info(cls, info: str) -> Validator:
    """
    Register info about an image value.
    :param info: The information to record.
    :return: The Validator that can be used.
    """
    return Validator.build_info_validator(info)

to_model()

Convert an image value artifact to its corresponding model.

Returns:

Type	Description
ArtifactModel	The artifact model

Source code in mlte/evidence/types/image.py

def to_model(self) -> ArtifactModel:
    """
    Convert an image value artifact to its corresponding model.
    :return: The artifact model
    """
    return self._to_artifact_model(
        value_model=ImageValueModel(
            data=base64.encodebytes(self.image).decode("utf-8"),
        ),
    )