Imagecodecs

import imagecodecs

# Direct codec access
import imagecodecs
data_compressed = imagecodecs.zlib_encode(data)
data_decompressed = imagecodecs.zlib_decode(data_compressed)

# High-level image I/O
import imagecodecs
image_array = imagecodecs.imread('image.jpg')
imagecodecs.imwrite('output.png', image_array)

import imagecodecs
import numpy as np

# High-level image reading and writing
image = imagecodecs.imread('input.jpg')
imagecodecs.imwrite('output.png', image)

# Direct compression/decompression  
data = np.random.randint(0, 256, (100, 100), dtype=np.uint8)
compressed = imagecodecs.zlib_encode(data)
decompressed = imagecodecs.zlib_decode(compressed)

# Check codec availability
if imagecodecs.JPEG.available:
    encoded = imagecodecs.jpeg_encode(image, level=95)
    decoded = imagecodecs.jpeg_decode(encoded)

# Get version information
print(imagecodecs.version())

def imread(fileobj, /, codec=None, *, memmap=True, return_codec=False, **kwargs):
    """
    Return image array from file.
    
    Parameters:
    - fileobj: str | os.PathLike[Any] | bytes | mmap.mmap - File path or data
    - codec: str | Callable[..., NDArray[Any]] | list[str | Callable[..., NDArray[Any]]] | None - Codec(s) to try for decoding
    - memmap: bool - Use memory mapping for large files (default True)
    - return_codec: bool - Return (array, codec) tuple if True (default False)
    - **kwargs: Additional codec-specific parameters
    
    Returns:
    NDArray[Any] | tuple[NDArray[Any], Callable[..., NDArray[Any]]]: Image array or (array, codec) tuple
    """

def imwrite(fileobj, data, /, codec=None, **kwargs):
    """
    Write image array to file.
    
    Parameters:
    - fileobj: str | os.PathLike[Any] | IO[bytes] - Output file path
    - data: ArrayLike - Image data to write
    - codec: str | Callable[..., bytes | bytearray] | None - Codec for encoding
    - **kwargs: Additional codec-specific parameters
    
    Returns:
    None
    """

def imagefileext():
    """
    Return list of image file extensions handled by imread/imwrite.
    
    Returns:
    list[str]: List of supported file extensions
    """

def zlib_encode(data, level=None, *, out=None):
    """
    Return ZLIB encoded data.
    
    Parameters:
    - data: bytes-like - Input data to compress
    - level: int | None - Compression level (0-9, default 6)
    - out: bytes | bytearray | None - Output buffer
    
    Returns:
    bytes | bytearray: Compressed data
    """

def blosc_encode(data, level=None, *, compressor=None, shuffle=None, typesize=None, blocksize=None, numthreads=None, out=None):
    """
    Return BLOSC encoded data.
    
    Parameters:
    - data: bytes-like - Input data to compress
    - level: int | None - Compression level (0-9)
    - compressor: str | None - Compression algorithm ('blosclz', 'lz4', 'lz4hc', 'snappy', 'zlib', 'zstd')
    - shuffle: int | None - Shuffle filter (0=none, 1=byte, 2=bit)
    - typesize: int | None - Element size for shuffle
    - blocksize: int | None - Block size in bytes
    - numthreads: int | None - Number of threads
    - out: bytes | bytearray | None - Output buffer
    
    Returns:
    bytes | bytearray: Compressed data
    """

def zstd_encode(data, level=None, *, out=None):
    """
    Return ZSTD encoded data.
    
    Parameters:
    - data: bytes-like - Input data to compress  
    - level: int | None - Compression level (1-22, default 3)
    - out: bytes | bytearray | None - Output buffer
    
    Returns:
    bytes | bytearray: Compressed data
    """

def jpeg_encode(data, level=None, *, colorspace=None, outcolorspace=None, subsampling=None, optimize=None, smoothing=None, out=None):
    """
    Return JPEG encoded image.
    
    Parameters:
    - data: NDArray - Image data to encode
    - level: int | None - Quality level (0-100, default 75)
    - colorspace: str | None - Input color space
    - outcolorspace: str | None - Output color space
    - subsampling: str | None - Chroma subsampling ('444', '422', '420', '411')
    - optimize: bool | None - Optimize Huffman tables
    - smoothing: int | None - Smoothing factor (0-100)
    - out: bytes | bytearray | None - Output buffer
    
    Returns:
    bytes | bytearray: JPEG encoded image
    """

def png_encode(data, level=None, *, strategy=None, filter=None, out=None):
    """
    Return PNG encoded image.
    
    Parameters:
    - data: NDArray - Image data to encode
    - level: int | None - Compression level (0-9, default 6)
    - strategy: str | None - Compression strategy
    - filter: str | None - Row filter type
    - out: bytes | bytearray | None - Output buffer
    
    Returns:
    bytes | bytearray: PNG encoded image
    """

def jpegxl_encode(data, level=None, *, effort=None, distance=None, lossless=None, out=None):
    """
    Return JPEG XL encoded image.
    
    Parameters:
    - data: NDArray - Image data to encode
    - level: int | None - Quality level (0-100) for lossy mode
    - effort: int | None - Encoding effort (1-9, default 7)
    - distance: float | None - Psychovisual distance (0.0-25.0)
    - lossless: bool | None - Use lossless compression
    - out: bytes | bytearray | None - Output buffer
    
    Returns:
    bytes | bytearray: JPEG XL encoded image
    """

def zfp_encode(data, *, rate=None, precision=None, tolerance=None, out=None):
    """
    Return ZFP encoded floating-point array.
    
    Parameters:
    - data: NDArray - Floating-point array to compress
    - rate: float | None - Target compression rate in bits per value
    - precision: int | None - Number of bit planes to encode
    - tolerance: float | None - Absolute error tolerance
    - out: bytes | bytearray | None - Output buffer
    
    Returns:
    bytes | bytearray: ZFP compressed data
    """

def sperr_encode(data, *, mode=None, quality=None, tolerance=None, out=None):
    """
    Return SPERR encoded floating-point data.
    
    Parameters:
    - data: NDArray - Floating-point data to compress
    - mode: str | None - Compression mode ('rate', 'psnr', 'pwe')
    - quality: float | None - Quality parameter for chosen mode
    - tolerance: float | None - Error tolerance
    - out: bytes | bytearray | None - Output buffer
    
    Returns:
    bytes | bytearray: SPERR compressed data
    """

def floatpred_encode(data, *, axis=-1, dist=1, out=None):
    """
    Return floating-point predictor encoded data.
    
    Parameters:
    - data: NDArray - Floating-point data to encode
    - axis: int - Axis along which to apply predictor
    - dist: int - Predictor distance
    - out: NDArray | None - Output buffer
    
    Returns:
    NDArray: Predictor encoded data
    """

def delta_encode(data, *, axis=-1, dist=1, out=None):
    """
    Return delta encoded data.
    
    Parameters:
    - data: NDArray - Input array to encode
    - axis: int - Axis along which to compute differences
    - dist: int - Distance for delta computation
    - out: NDArray | None - Output buffer
    
    Returns:
    NDArray: Delta encoded data
    """

def bitshuffle_encode(data, *, itemsize=1, blocksize=0, out=None):
    """
    Return bitshuffle encoded data.
    
    Parameters:
    - data: bytes-like | NDArray - Input data
    - itemsize: int - Size of data items in bytes
    - blocksize: int - Block size for shuffling (default auto)
    - out: bytes | bytearray | NDArray | None - Output buffer
    
    Returns:
    bytes | bytearray | NDArray: Bit-shuffled data
    """

def packints_encode(data, *, out=None):
    """
    Return packed integer array.
    
    Parameters:
    - data: NDArray - Integer array to pack
    - out: NDArray | None - Output buffer
    
    Returns:
    NDArray: Packed integer data
    """

def cms_transform(data, profile, outprofile, *, colorspace=None, outcolorspace=None, intent=None, out=None):
    """
    Return color-transformed array.
    
    Parameters:
    - data: NDArray - Image data to transform
    - profile: bytes | str - Input ICC profile or color space name
    - outprofile: bytes | str - Output ICC profile or color space name
    - colorspace: str | None - Input color space interpretation
    - outcolorspace: str | None - Output color space interpretation  
    - intent: str | None - Rendering intent ('perceptual', 'relative', 'saturation', 'absolute')
    - out: NDArray | None - Output buffer
    
    Returns:
    NDArray: Color-transformed image data
    """

def cms_profile(profile, *, whitepoint=None, primaries=None, transferfunction=None, gamma=None):
    """
    Return ICC profile.
    
    Parameters:
    - profile: str - Profile type ('srgb', 'adobe_rgb', 'prophoto_rgb', etc.)
    - whitepoint: tuple | None - White point coordinates
    - primaries: tuple | None - Color primaries
    - transferfunction: str | None - Transfer function type
    - gamma: float | None - Gamma value
    
    Returns:
    bytes: ICC profile data
    """

def version(astype=None, /):
    """
    Return version information about all codecs and dependencies.
    
    All extension modules are imported into the process during this call.
    
    Parameters:
    - astype: type | None - Return type (str, tuple, dict)
    
    Returns:
    str | tuple[str, ...] | dict[str, str]: Version information
    """

def h5checksum_fletcher32(data, value=None):
    """
    Return Fletcher-32 checksum.
    
    Parameters:
    - data: bytes-like - Data to checksum
    - value: int | None - Initial checksum value
    
    Returns:
    int: Fletcher-32 checksum
    """

class DelayedImportError(ImportError):
    """Delayed ImportError for optional codec dependencies."""
    
    def __init__(self, name: str) -> None: ...

from typing import Any, Callable, IO, Literal, overload
from numpy.typing import ArrayLike, DTypeLike, NDArray
import os
import mmap

BytesLike = bytes | bytearray | mmap.mmap

# Codec constants classes
class JPEG:
    available: bool  # True if JPEG codec is available
    
class PNG:
    available: bool  # True if PNG codec is available
    
class ZLIB:
    available: bool  # True if ZLIB codec is available
    
class WEBP:
    available: bool  # True if WebP codec is available
    
class AVIF:
    available: bool  # True if AVIF codec is available
    
class BLOSC:
    available: bool  # True if BLOSC codec is available
    
class ZSTD:
    available: bool  # True if ZSTD codec is available

# Generic codec constants base class pattern
class CodecConstants:
    available: bool  # True if codec is available

# Exception hierarchy
class ImcdError(Exception):
    """Base IMCD codec exception."""

class DelayedImportError(ImportError):
    """Delayed ImportError for lazy loading."""
    
    def __init__(self, name: str) -> None: ...

# Codec-specific exception classes
class JpegError(ImcdError):
    """JPEG codec exception."""

class PngError(ImcdError):
    """PNG codec exception."""

class ZlibError(ImcdError):
    """ZLIB codec exception."""

class WebpError(ImcdError):
    """WebP codec exception."""

class AvifError(ImcdError):
    """AVIF codec exception."""

class BloscError(ImcdError):
    """BLOSC codec exception."""

class ZstdError(ImcdError):
    """ZSTD codec exception."""