ImageFile

def get_info(self) -> "Image":
    """
    Retrieves metadata and information about the image file.

    With prefetch and cache off, reads only the parts of the file it needs.

    Returns:
        Image: A Model containing image metadata such as width, height and format.
    """
    from .image import image_info

    return image_info(self)

def read(self):
    """Returns `PIL.Image.Image` object."""
    from PIL import Image as PilImage

    fobj = super().read()
    return PilImage.open(BytesIO(fobj))

def save(  # type: ignore[override]
    self,
    destination: str,
    format: str | None = None,
    client_config: dict | None = None,
    *,
    content_type: str | None = None,
    content_disposition: str | None = None,
    cache_control: str | None = None,
    content_encoding: str | None = None,
    metadata: dict[str, str] | None = None,
    write_options: dict[str, Any] | None = None,
) -> "ImageFile":
    """Save the image to *destination*, optionally re-encoding to *format*.

    If ``destination`` is a remote path, the image will be uploaded to
    remote storage.  See :meth:`File.save` for full destination semantics
    and the object-metadata keyword arguments.
    """
    if self._catalog is None:
        raise RuntimeError("Cannot save file: catalog is not set")
    destination = stringify_path(destination)

    # If format is not provided, determine it from the file extension
    if format is None:
        from pathlib import PurePosixPath

        from PIL import Image as PilImage

        ext = PurePosixPath(destination).suffix.lower()
        format = PilImage.registered_extensions().get(ext)

    if not format:
        raise FileError(
            f"Can't determine format for destination '{destination}'",
            self.source,
            self.path,
        )

    buf = BytesIO()
    self.read().save(buf, format=format)
    client, rel_path = self._resolve_destination(destination, client_config)
    result = client.upload(
        buf.getvalue(),
        rel_path,
        write_config=WriteConfig(
            content_type=content_type,
            content_disposition=content_disposition,
            cache_control=cache_control,
            content_encoding=content_encoding,
            metadata=metadata,
            write_options=write_options,
        ),
    )
    img = ImageFile(**result.model_dump())
    img._set_stream(self._catalog)
    return img