mistral_common.tokens.tokenizers.image

def image_from_chunk(chunk: ImageURLChunk | ImageChunk) -> SerializableImage:
    r"""Load a serializable image from a chunk.

    Resolves the image from the chunk's data, accepting base64 data URLs,
    file URIs, and http(s) URLs.

    Args:
        chunk: The chunk to get the image from.

    Returns:
        The image as a PIL Image object.

    Raises:
        ValueError: If a data URL does not contain a base64 payload or the URL
            scheme is unsupported.
    """
    if isinstance(chunk, ImageChunk):
        return chunk.image
    url = chunk.get_url()
    if url.startswith("data:image"):
        _, _, data = url.partition(",")
        if not data:
            raise ValueError(f"Invalid image data URL {url[:64]}: expected a base64 payload after a comma.")
        image_data = base64.b64decode(data)
        return Image.open(BytesIO(image_data))
    if url.startswith("file://"):
        with open(url.removeprefix("file://"), "rb") as file:
            image = Image.open(file)
            image.load()
        return image
    if url.startswith("http"):
        return download_image(url=url, timeout=None)

    raise ValueError(f"Unsupported image url scheme {url}")

def normalize(
    np_image: np.ndarray,
    mean: tuple[float, float, float],
    std: tuple[float, float, float],
) -> np.ndarray:
    r"""Normalize an image array with per-channel mean and standard deviation.

    Args:
        np_image: Image to normalize, with shape (H, W, C) and values in [0, 255].
        mean: Mean for each channel, values in [0, 1].
        std: Standard deviation for each channel, values in [0, 1].

    Returns:
        Normalized image with shape (C, H, W), scaled to unit variance.

    Raises:
        AssertionError: If `np_image` is not (H, W, C) or the channel count does
            not match mean and std.
    """
    np_image = np.divide(np_image, np.float32(255.0), dtype=np_image.dtype)

    assert len(np_image.shape) == 3, f"{np_image.shape=}"
    assert np_image.shape[2] == len(mean) == len(std), f"{np_image.shape=}, {mean=}, {std=}"

    mean_array = np.asarray(mean, dtype=np_image.dtype)
    std_array = np.asarray(std, dtype=np_image.dtype)

    np_image -= mean_array
    np_image /= std_array

    return np_image.transpose(2, 0, 1)

def transform_image(image: Image.Image, new_size: tuple[int, int]) -> np.ndarray:
    r"""Resize and normalize an image for the model.

    Converts to RGB (transparent backgrounds become white), resizes with cubic
    interpolation, then normalizes with the dataset statistics.

    Args:
        image: PIL image to transform.
        new_size: Target (width, height) in pixels.

    Returns:
        Transformed image with shape (C, H, W), normalized.

    Raises:
        ImportError: If opencv is not installed.
    """
    assert_opencv_installed()

    np_image = cv2.resize(np.array(_convert_to_rgb(image), dtype=np.float32), new_size, interpolation=cv2.INTER_CUBIC)
    return normalize(np_image, DATASET_MEAN, DATASET_STD)