imgproxykit 0.1.0__py3-none-any.whl

imgproxykit/options/max_result_dimension.py

@@ -0,0 +1,39 @@
+from dataclasses import dataclass
+from typing import ClassVar, final, override
+
+from imgproxykit.options.base import Option
+from imgproxykit.types import Argument, OptionType
+
+
+@final
+@dataclass(frozen=True, slots=True, kw_only=True)
+class MaxResultDimension(Option):
+    """
+    Override output dimension limit; requires ALLOW_SECURITY_OPTIONS.
+
+    Overrides the corresponding server limit for this request. Requires
+    ``IMGPROXY_ALLOW_SECURITY_OPTIONS=true`` on the imgproxy server.
+
+    Attributes:
+        value: Maximum resulting width or height in pixels.
+
+    Usage:
+
+    >>> option = MaxResultDimension(value=4096)
+    >>> option.arguments
+    (4096,)
+
+    See `imgproxy max result dimension
+    <https://docs.imgproxy.net/usage/processing#max-result-dimension>`_.
+
+    """
+
+    value: int
+
+    _name: ClassVar[OptionType] = 'mrd'
+
+    @property
+    @override
+    def arguments(self) -> tuple[Argument, ...]:
+        """Positional arguments in imgproxy protocol order."""
+        return (self.value,)

imgproxykit/options/max_src_file_size.py

@@ -0,0 +1,39 @@
+from dataclasses import dataclass
+from typing import ClassVar, final, override
+
+from imgproxykit.options.base import Option
+from imgproxykit.types import Argument, OptionType
+
+
+@final
+@dataclass(frozen=True, slots=True, kw_only=True)
+class MaxSrcFileSize(Option):
+    """
+    Override source byte limit; requires ALLOW_SECURITY_OPTIONS.
+
+    Overrides the corresponding server limit for this request. Requires
+    ``IMGPROXY_ALLOW_SECURITY_OPTIONS=true`` on the imgproxy server.
+
+    Attributes:
+        value: Source file size limit in bytes.
+
+    Usage:
+
+    >>> option = MaxSrcFileSize(value=10_000_000)
+    >>> option.arguments
+    (10000000,)
+
+    See `imgproxy max src file size
+    <https://docs.imgproxy.net/usage/processing#max-src-file-size>`_.
+
+    """
+
+    value: int
+
+    _name: ClassVar[OptionType] = 'msfs'
+
+    @property
+    @override
+    def arguments(self) -> tuple[Argument, ...]:
+        """Positional arguments in imgproxy protocol order."""
+        return (self.value,)

imgproxykit/options/max_src_resolution.py

@@ -0,0 +1,39 @@
+from dataclasses import dataclass
+from typing import ClassVar, final, override
+
+from imgproxykit.options.base import Option
+from imgproxykit.types import Argument, OptionType
+
+
+@final
+@dataclass(frozen=True, slots=True, kw_only=True)
+class MaxSrcResolution(Option):
+    """
+    Override source megapixel limit; requires ALLOW_SECURITY_OPTIONS.
+
+    Overrides the corresponding server limit for this request. Requires
+    ``IMGPROXY_ALLOW_SECURITY_OPTIONS=true`` on the imgproxy server.
+
+    Attributes:
+        value: Source resolution limit in megapixels.
+
+    Usage:
+
+    >>> option = MaxSrcResolution(value=50)
+    >>> option.arguments
+    (50,)
+
+    See `imgproxy max src resolution
+    <https://docs.imgproxy.net/usage/processing#max-src-resolution>`_.
+
+    """
+
+    value: float
+
+    _name: ClassVar[OptionType] = 'msr'
+
+    @property
+    @override
+    def arguments(self) -> tuple[Argument, ...]:
+        """Positional arguments in imgproxy protocol order."""
+        return (self.value,)

imgproxykit/options/min_height.py

@@ -0,0 +1,38 @@
+from dataclasses import dataclass
+from typing import ClassVar, final, override
+
+from imgproxykit.options.base import Option
+from imgproxykit.types import Argument, OptionType
+
+
+@final
+@dataclass(frozen=True, slots=True, kw_only=True)
+class MinHeight(Option):
+    """
+    Set the minimum resulting height in pixels.
+
+    Combining this option with a target height can crop the result.
+
+    Attributes:
+        value: Minimum resulting height in pixels.
+
+    Usage:
+
+    >>> option = MinHeight(value=200)
+    >>> option.arguments
+    (200,)
+
+    See `imgproxy min height
+    <https://docs.imgproxy.net/usage/processing#min-height>`_.
+
+    """
+
+    value: int
+
+    _name: ClassVar[OptionType] = 'mh'
+
+    @property
+    @override
+    def arguments(self) -> tuple[Argument, ...]:
+        """Positional arguments in imgproxy protocol order."""
+        return (self.value,)

imgproxykit/options/min_width.py

@@ -0,0 +1,38 @@
+from dataclasses import dataclass
+from typing import ClassVar, final, override
+
+from imgproxykit.options.base import Option
+from imgproxykit.types import Argument, OptionType
+
+
+@final
+@dataclass(frozen=True, slots=True, kw_only=True)
+class MinWidth(Option):
+    """
+    Set the minimum resulting width in pixels.
+
+    Combining this option with a target width can crop the result.
+
+    Attributes:
+        value: Minimum resulting width in pixels.
+
+    Usage:
+
+    >>> option = MinWidth(value=300)
+    >>> option.arguments
+    (300,)
+
+    See `imgproxy min width
+    <https://docs.imgproxy.net/usage/processing#min-width>`_.
+
+    """
+
+    value: int
+
+    _name: ClassVar[OptionType] = 'mw'
+
+    @property
+    @override
+    def arguments(self) -> tuple[Argument, ...]:
+        """Positional arguments in imgproxy protocol order."""
+        return (self.value,)

imgproxykit/options/padding.py

@@ -0,0 +1,50 @@
+from dataclasses import dataclass
+from typing import ClassVar, final, override
+
+from imgproxykit.options.base import Option
+from imgproxykit.types import EMPTY, Argument, OptionType
+
+
+@final
+@dataclass(frozen=True, slots=True, kw_only=True)
+class Padding(Option):
+    """
+    Add padding using CSS side order; specify at least one side.
+
+    Uses CSS side order and is applied after image transformations,
+    except watermarking. Padding follows DPR and uses the background color.
+    Supply at least one side; omitted arguments remain
+    :data:`~imgproxykit.types.EMPTY`.
+
+    Attributes:
+        top: Top padding in pixels; fallback for omitted sides.
+        right: Right padding; also used for an omitted left side.
+        bottom: Bottom padding in pixels.
+        left: Left padding in pixels.
+
+    Usage:
+
+    >>> option = Padding(top=10)
+    >>> option.arguments
+    (10, EMPTY, EMPTY, EMPTY)
+    >>> option = Padding(top=10, right=20, bottom=30, left=40)
+    >>> option.arguments
+    (10, 20, 30, 40)
+
+    See `imgproxy padding
+    <https://docs.imgproxy.net/usage/processing#padding>`_.
+
+    """
+
+    top: int | EMPTY = EMPTY
+    right: int | EMPTY = EMPTY
+    bottom: int | EMPTY = EMPTY
+    left: int | EMPTY = EMPTY
+
+    _name: ClassVar[OptionType] = 'pd'
+
+    @property
+    @override
+    def arguments(self) -> tuple[Argument, ...]:
+        """Positional arguments in imgproxy protocol order."""
+        return (self.top, self.right, self.bottom, self.left)

imgproxykit/options/pixelate.py

@@ -0,0 +1,38 @@
+from dataclasses import dataclass
+from typing import ClassVar, final, override
+
+from imgproxykit.options.base import Option
+from imgproxykit.types import Argument, OptionType
+
+
+@final
+@dataclass(frozen=True, slots=True, kw_only=True)
+class Pixelate(Option):
+    """
+    Set the pixelation block size.
+
+    Larger blocks produce a coarser pixelation effect.
+
+    Attributes:
+        value: Individual pixel block size in pixels.
+
+    Usage:
+
+    >>> option = Pixelate(value=10)
+    >>> option.arguments
+    (10,)
+
+    See `imgproxy pixelate
+    <https://docs.imgproxy.net/usage/processing#pixelate>`_.
+
+    """
+
+    value: int
+
+    _name: ClassVar[OptionType] = 'pix'
+
+    @property
+    @override
+    def arguments(self) -> tuple[Argument, ...]:
+        """Positional arguments in imgproxy protocol order."""
+        return (self.value,)

imgproxykit/options/preserve_hdr.py

@@ -0,0 +1,38 @@
+from dataclasses import dataclass
+from typing import ClassVar, final, override
+
+from imgproxykit.options.base import Option
+from imgproxykit.types import Argument, OptionType
+
+
+@final
+@dataclass(frozen=True, slots=True, kw_only=True)
+class PreserveHDR(Option):
+    """
+    Preserve high bit depth instead of converting to 8 bit.
+
+    Overrides the server high bit depth setting for this request.
+
+    Attributes:
+        value: Whether to retain high bit depth instead of using 8 bit.
+
+    Usage:
+
+    >>> option = PreserveHDR(value=True)
+    >>> option.arguments
+    (True,)
+
+    See `imgproxy preserve hdr
+    <https://docs.imgproxy.net/usage/processing#preserve-hdr>`_.
+
+    """
+
+    value: bool
+
+    _name: ClassVar[OptionType] = 'ph'
+
+    @property
+    @override
+    def arguments(self) -> tuple[Argument, ...]:
+        """Positional arguments in imgproxy protocol order."""
+        return (self.value,)

imgproxykit/options/quality.py

@@ -0,0 +1,38 @@
+from dataclasses import dataclass
+from typing import ClassVar, final, override
+
+from imgproxykit.options.base import Option
+from imgproxykit.types import Argument, OptionType
+
+
+@final
+@dataclass(frozen=True, slots=True)
+class Quality(Option):
+    """
+    Set output image quality.
+
+    Attributes:
+        value: Quality percentage. Zero delegates to server quality settings.
+
+    Usage:
+
+    >>> option = Quality(85)
+    >>> option.arguments
+    (85,)
+
+    See `imgproxy quality
+    <https://docs.imgproxy.net/usage/processing#quality>`_.
+
+    """
+
+    # Public API:
+    value: int
+
+    # Private API:
+    _name: ClassVar[OptionType] = 'q'
+
+    @property
+    @override
+    def arguments(self) -> tuple[Argument, ...]:
+        """Positional arguments in imgproxy protocol order."""
+        return (self.value,)

imgproxykit/options/raw.py

@@ -0,0 +1,39 @@
+from dataclasses import dataclass
+from typing import ClassVar, final, override
+
+from imgproxykit.options.base import Option
+from imgproxykit.types import Argument, OptionType
+
+
+@final
+@dataclass(frozen=True, slots=True, kw_only=True)
+class Raw(Option):
+    """
+    Stream the unchecked source file without processing.
+
+    Streams the source without checking its type, resolution, or size.
+    The output is not transformed.
+
+    Attributes:
+        value: Whether to stream the raw source file.
+
+    Usage:
+
+    >>> option = Raw(value=True)
+    >>> option.arguments
+    (True,)
+
+    See `imgproxy raw
+    <https://docs.imgproxy.net/usage/processing#raw>`_.
+
+    """
+
+    value: bool
+
+    _name: ClassVar[OptionType] = 'raw'
+
+    @property
+    @override
+    def arguments(self) -> tuple[Argument, ...]:
+        """Positional arguments in imgproxy protocol order."""
+        return (self.value,)

imgproxykit/options/resize.py

@@ -0,0 +1,55 @@
+from dataclasses import dataclass
+from typing import ClassVar, final, override
+
+from imgproxykit.options.base import Option
+from imgproxykit.types import EMPTY, Argument, OptionType, ResizeType
+
+
+@final
+@dataclass(frozen=True, slots=True, kw_only=True)
+class Resize(Option):
+    """
+    Configure image dimensions and resizing behavior.
+
+    Values left as :data:`~imgproxykit.types.EMPTY` are not supplied
+    explicitly; imgproxy resolves their defaults.
+
+    Attributes:
+        width: Target width in pixels.
+        height: Target height in pixels.
+        mode: Resizing strategy, such as ``fit`` or ``fill``.
+        enlarge: Allow upscaling smaller source images.
+        extend: Pad images that are smaller than the target dimensions.
+
+    Usage:
+
+    >>> option = Resize(width=96, height=96, mode='fill')
+    >>> option.arguments
+    ('fill', 96, 96, EMPTY, EMPTY)
+
+    See `imgproxy resize
+    <https://docs.imgproxy.net/usage/processing#resize>`_.
+
+    """
+
+    # Public API:
+    width: int | EMPTY = EMPTY
+    height: int | EMPTY = EMPTY
+    mode: ResizeType | EMPTY = EMPTY
+    enlarge: bool | EMPTY = EMPTY
+    extend: bool | EMPTY = EMPTY
+
+    # Private API:
+    _name: ClassVar[OptionType] = 'rs'
+
+    @property
+    @override
+    def arguments(self) -> tuple[Argument, ...]:
+        """Positional arguments in imgproxy protocol order."""
+        return (
+            self.mode,
+            self.width,
+            self.height,
+            self.enlarge,
+            self.extend,
+        )

imgproxykit/options/resizing_type.py

@@ -0,0 +1,39 @@
+from dataclasses import dataclass
+from typing import ClassVar, final, override
+
+from imgproxykit.options.base import Option
+from imgproxykit.types import Argument, OptionType, ResizeType
+
+
+@final
+@dataclass(frozen=True, slots=True, kw_only=True)
+class ResizingType(Option):
+    """
+    Choose the resizing strategy.
+
+    Controls how target dimensions and the source aspect ratio interact.
+
+    Attributes:
+        value: Resizing strategy: ``fit``, ``fill``, ``fill-down``,
+            ``force``, or ``auto``.
+
+    Usage:
+
+    >>> option = ResizingType(value='fill')
+    >>> option.arguments
+    ('fill',)
+
+    See `imgproxy resizing type
+    <https://docs.imgproxy.net/usage/processing#resizing-type>`_.
+
+    """
+
+    value: ResizeType
+
+    _name: ClassVar[OptionType] = 'rt'
+
+    @property
+    @override
+    def arguments(self) -> tuple[Argument, ...]:
+        """Positional arguments in imgproxy protocol order."""
+        return (self.value,)

imgproxykit/options/return_attachment.py

@@ -0,0 +1,39 @@
+from dataclasses import dataclass
+from typing import ClassVar, final, override
+
+from imgproxykit.options.base import Option
+from imgproxykit.types import Argument, OptionType
+
+
+@final
+@dataclass(frozen=True, slots=True, kw_only=True)
+class ReturnAttachment(Option):
+    """
+    Request attachment disposition for downloading.
+
+    Sets attachment disposition so browsers can offer to save the image.
+    Combine with Filename to choose the downloaded filename.
+
+    Attributes:
+        value: Whether to return an attachment disposition.
+
+    Usage:
+
+    >>> option = ReturnAttachment(value=True)
+    >>> option.arguments
+    (True,)
+
+    See `imgproxy return attachment
+    <https://docs.imgproxy.net/usage/processing#return-attachment>`_.
+
+    """
+
+    value: bool
+
+    _name: ClassVar[OptionType] = 'att'
+
+    @property
+    @override
+    def arguments(self) -> tuple[Argument, ...]:
+        """Positional arguments in imgproxy protocol order."""
+        return (self.value,)

imgproxykit/options/rotate.py

@@ -0,0 +1,38 @@
+from dataclasses import dataclass
+from typing import ClassVar, final, override
+
+from imgproxykit.options.base import Option
+from imgproxykit.types import Argument, OptionType
+
+
+@final
+@dataclass(frozen=True, slots=True, kw_only=True)
+class Rotate(Option):
+    """
+    Rotate clockwise by a multiple of 90 degrees.
+
+    Rotation follows EXIF orientation unless automatic rotation is disabled.
+
+    Attributes:
+        value: Clockwise angle in degrees; must be a multiple of 90.
+
+    Usage:
+
+    >>> option = Rotate(value=90)
+    >>> option.arguments
+    (90,)
+
+    See `imgproxy rotate
+    <https://docs.imgproxy.net/usage/processing#rotate>`_.
+
+    """
+
+    value: int
+
+    _name: ClassVar[OptionType] = 'rot'
+
+    @property
+    @override
+    def arguments(self) -> tuple[Argument, ...]:
+        """Positional arguments in imgproxy protocol order."""
+        return (self.value,)

imgproxykit/options/sharpen.py

@@ -0,0 +1,38 @@
+from dataclasses import dataclass
+from typing import ClassVar, final, override
+
+from imgproxykit.options.base import Option
+from imgproxykit.types import Argument, OptionType
+
+
+@final
+@dataclass(frozen=True, slots=True, kw_only=True)
+class Sharpen(Option):
+    """
+    Apply sharpening with the given sigma.
+
+    The sigma controls the size of the sharpening mask.
+
+    Attributes:
+        value: Sharpening filter sigma.
+
+    Usage:
+
+    >>> option = Sharpen(value=1.0)
+    >>> option.arguments
+    (1.0,)
+
+    See `imgproxy sharpen
+    <https://docs.imgproxy.net/usage/processing#sharpen>`_.
+
+    """
+
+    value: float
+
+    _name: ClassVar[OptionType] = 'sh'
+
+    @property
+    @override
+    def arguments(self) -> tuple[Argument, ...]:
+        """Positional arguments in imgproxy protocol order."""
+        return (self.value,)

imgproxykit/options/size.py

@@ -0,0 +1,45 @@
+from dataclasses import dataclass
+from typing import ClassVar, final, override
+
+from imgproxykit.options.base import Option
+from imgproxykit.types import EMPTY, Argument, OptionType
+
+
+@final
+@dataclass(frozen=True, slots=True, kw_only=True)
+class Size(Option):
+    """
+    Set target dimensions, upscaling, and canvas extension.
+
+    Values left as :data:`~imgproxykit.types.EMPTY` are not supplied
+    explicitly; imgproxy resolves their defaults.
+
+    Attributes:
+        width: Target width in pixels.
+        height: Target height in pixels.
+        enlarge: Allow upscaling smaller source images.
+        extend: Pad images smaller than the target dimensions.
+
+    Usage:
+
+    >>> option = Size(width=300, height=200, enlarge=True)
+    >>> option.arguments
+    (300, 200, True, EMPTY)
+
+    See `imgproxy size
+    <https://docs.imgproxy.net/usage/processing#size>`_.
+
+    """
+
+    width: int | EMPTY = EMPTY
+    height: int | EMPTY = EMPTY
+    enlarge: bool | EMPTY = EMPTY
+    extend: bool | EMPTY = EMPTY
+
+    _name: ClassVar[OptionType] = 's'
+
+    @property
+    @override
+    def arguments(self) -> tuple[Argument, ...]:
+        """Positional arguments in imgproxy protocol order."""
+        return (self.width, self.height, self.enlarge, self.extend)