randaugment

def AutoContrast(img: Image.Image, _: float) -> Image.Image:
    """Apply automatic contrast to the image.

    Args:
        img: PIL Image to be processed

    Returns:
        PIL Image with automatic contrast applied
    """
    return PIL.ImageOps.autocontrast(img)

def Brightness(img: Image.Image, v: float) -> Image.Image:
    """Adjust the brightness of the image.

    Args:
        img: PIL Image to be processed
        v: Brightness factor (must be >= 0.0)

    Returns:
        PIL Image with adjusted brightness
    """
    assert v >= 0.0
    return PIL.ImageEnhance.Brightness(img).enhance(v)

def Color(img: Image.Image, v: float) -> Image.Image:
    """Adjust the color saturation of the image.

    Args:
        img: PIL Image to be processed
        v: Color saturation factor (must be >= 0.0)

    Returns:
        PIL Image with adjusted color saturation
    """
    assert v >= 0.0
    return PIL.ImageEnhance.Color(img).enhance(v)

def Contrast(img: Image.Image, v: float) -> Image.Image:
    """Adjust the contrast of the image.

    Args:
        img: PIL Image to be processed
        v: Contrast factor (must be >= 0.0)

    Returns:
        PIL Image with adjusted contrast
    """
    assert v >= 0.0
    return PIL.ImageEnhance.Contrast(img).enhance(v)

def Equalize(img: Image.Image, _: float) -> Image.Image:
    """Equalize the histogram of the image.

    Args:
        img: PIL Image to be processed

    Returns:
        PIL Image with equalized histogram
    """
    return PIL.ImageOps.equalize(img)

def Identity(img: Image.Image, v: float) -> Image.Image:
    """Return the image unchanged.

    Args:
        img: PIL Image to be processed
        v: Unused parameter

    Returns:
        The original PIL Image
    """
    return img

def Posterize(img: Image.Image, v: float) -> Image.Image:
    """Reduce the number of bits for each color channel.

    Args:
        img: PIL Image to be processed
        v: Number of bits to keep for each channel (range [4, 8])

    Returns:
        PIL Image with reduced color channels
    """
    v = int(v)
    v = max(1, v)
    return PIL.ImageOps.posterize(img, v)

def Rotate(img: Image.Image, v: float) -> Image.Image:
    """Rotate the image by v degrees.

    Args:
        img: PIL Image to be processed
        v: Rotation angle in degrees (range [-30, 30])

    Returns:
        Rotated PIL Image
    """
    return img.rotate(v)

def Sharpness(img: Image.Image, v: float) -> Image.Image:
    """Adjust the sharpness of the image.

    Args:
        img: PIL Image to be processed
        v: Sharpness factor (must be >= 0.0)

    Returns:
        PIL Image with adjusted sharpness
    """
    assert v >= 0.0
    return PIL.ImageEnhance.Sharpness(img).enhance(v)

def ShearX(img: Image.Image, v: float) -> Image.Image:
    """Apply horizontal shear to the image.

    Args:
        img: PIL Image to be processed
        v: Shear factor (range [-0.3, 0.3])

    Returns:
        PIL Image with horizontal shear applied
    """
    return img.transform(img.size, PIL.Image.AFFINE, (1, v, 0, 0, 1, 0))

def ShearY(img: Image.Image, v: float) -> Image.Image:
    """Apply vertical shear to the image.

    Args:
        img: PIL Image to be processed
        v: Shear factor (range [-0.3, 0.3])

    Returns:
        PIL Image with vertical shear applied
    """
    return img.transform(img.size, PIL.Image.AFFINE, (1, 0, 0, v, 1, 0))

def TranslateX(img: Image.Image, v: float) -> Image.Image:
    """Translate the image horizontally by a percentage of its width.

    Args:
        img: PIL Image to be processed
        v: Translation factor as a percentage of image width (range [-0.3, 0.3])

    Returns:
        PIL Image with horizontal translation applied
    """
    v = v * img.size[0]
    return img.transform(img.size, PIL.Image.AFFINE, (1, 0, v, 0, 1, 0))

def TranslateY(img: Image.Image, v: float) -> Image.Image:
    """Translate the image vertically by a percentage of its height.

    Args:
        img: PIL Image to be processed
        v: Translation factor as a percentage of image height (range [-0.3, 0.3])

    Returns:
        PIL Image with vertical translation applied
    """
    v = v * img.size[1]
    return img.transform(img.size, PIL.Image.AFFINE, (1, 0, 0, 0, 1, v))

def Solarize(img: Image.Image, v: float) -> Image.Image:
    """Invert all pixel values above a threshold.

    Args:
        img: PIL Image to be processed
        v: Threshold for solarization (range [0, 256])

    Returns:
        Solarized PIL Image
    """
    assert 0 <= v <= 256
    return PIL.ImageOps.solarize(img, v)

def Cutout(img: Image.Image | np.ndarray, v: float) -> Image.Image | np.ndarray:
    """Apply cutout augmentation to the image.

    Creates a square mask at a random location in the image.

    Args:
        img: PIL Image or numpy array to be processed
        v: Size of the cutout as a percentage of image size (range [0.0, 0.5])

    Returns:
        Image with cutout applied
    """
    assert 0.0 <= v <= 0.5
    if v <= 0.0:
        return img

    if isinstance(img, np.ndarray):
        v = int(v * img.shape[0])
        return A.Cutout(1, v, v, always_apply=True, fill_value=(128))(image=img)["image"]
    else:
        v = v * img.size[0]
        return CutoutAbs(img, v)

def CutoutAbs(img: Image.Image, v: float) -> Image.Image:
    """Apply cutout augmentation with absolute size to the image.

    Creates a square mask at a random location in the image with specified absolute size.

    Args:
        img: PIL Image to be processed
        v: Absolute size of the cutout in pixels

    Returns:
        PIL Image with cutout applied
    """
    if v < 0:
        return img
    w, h = img.size
    x0 = np.random.uniform(w)
    y0 = np.random.uniform(h)

    x0 = int(max(0, x0 - v / 2.0))
    y0 = int(max(0, y0 - v / 2.0))
    x1 = min(w, x0 + v)
    y1 = min(h, y0 + v)

    xy = (x0, y0, x1, y1)
    color = (125, 123, 114)
    img = img.copy()
    PIL.ImageDraw.Draw(img).rectangle(xy, color)
    return img

def augment_list() -> list[tuple]:
    """Return a list of available augmentation operations with their value ranges.

    Returns:
        List of tuples (operation, min_value, max_value) for each augmentation
    """
    augments = [
        (AutoContrast, 0, 1),
        (Brightness, 0.05, 0.95),
        (Color, 0.05, 0.95),
        (Contrast, 0.05, 0.95),
        (Equalize, 0, 1),
        (Identity, 0, 1),
        (Posterize, 4, 8),
        (Rotate, -30, 30),
        (Sharpness, 0.05, 0.95),
        (ShearX, -0.3, 0.3),
        (ShearY, -0.3, 0.3),
        (Solarize, 0, 256),
        (TranslateX, -0.3, 0.3),
        (TranslateY, -0.3, 0.3),
    ]
    return augments