imagequant 1.1.2__cp313-cp313-win_amd64.whl

imagequant/__init__.py

@@ -0,0 +1,204 @@
+# The library can be used without PIL/Pillow
+try:
+    from PIL import Image
+except ImportError:
+    Image = None
+
+from ._libimagequant import lib, ffi
+
+
+def _get_error_msg(code):
+    """Get error string from libimagequant return codes.
+
+    :param int code: The code returned by libimagequant.
+
+    :rtype: str
+    """
+    if code == lib.LIQ_QUALITY_TOO_LOW:
+        return "Quality too low"
+    elif code == lib.LIQ_VALUE_OUT_OF_RANGE:
+        return "Value out of range"
+    elif code == lib.LIQ_OUT_OF_MEMORY:
+        return "Out of memory"
+    elif code == lib.LIQ_ABORTED:
+        return "Aborted"
+    elif code == lib.LIQ_BITMAP_NOT_AVAILABLE:
+        return "Bitmap not available"
+    elif code == lib.LIQ_BUFFER_TOO_SMALL:
+        return "Buffer too small"
+    elif code == lib.LIQ_INVALID_POINTER:
+        return "Invalid pointer"
+    elif code == lib.LIQ_UNSUPPORTED:
+        return "Unsupported"
+    else:
+        return "Unknown error"
+
+
+def _pil_image_to_raw_bytes(image):
+    """Get raw bytes from a PIL/Pillow image.
+
+    :param PIL.Image.Image image: The image.
+
+    :rtype: bytes
+    :return: The image as raw bytes (``b"RGBARGBARGBA..."``).
+    """
+    return bytes([comp for pix in image.getdata() for comp in pix])
+
+
+def _liq_palette_to_raw_palette(liq_palette):
+    """Converts a liq_palette to a raw RGBA palette usable with PIL/Pillow image.
+
+    :param liq_palette: The palette de convert.
+
+    :rtype: list
+    :return: The raw RGBA palette (``[r0, g0, b0, a0, r1, g1, b1, a1,...]``).
+    """
+    return sum(
+        [[color.r, color.g, color.b, color.a] for color in liq_palette.entries], []
+    )
+
+
+def quantize_raw_rgba_bytes(
+    image_data,
+    width,
+    height,
+    dithering_level=1.0,
+    max_colors=256,
+    min_quality=0,
+    max_quality=100,
+):
+    """Converts an RGBA image to an optimized 8bit paletted image.
+
+    :param bytes image_data: Raw RGBA image data (format: ``b"RGBARGBARGBA..."``).
+    :param int width: Image's width.
+    :param int height: Image's height.
+    :param float dithering_level: The dithering level, from ``0.0`` (no
+                                  dithering) to ``1.0`` (default: ``1.0``).
+    :param int max_colors: Maximum number of color to use in the palette, from
+                           ``1`` to ``256`` (default: ``256``).
+    :param int min_quality: Minimum acceptable quality. If the minimum quality
+                            can’t be met, the quantization will be aborted and
+                            a ``RuntimeError`` will be raised. From ``0`` to
+                            ``100`` (default: ``0``).
+    :param int max_quality: The target quality, from ``0`` to ``100``
+                            (default: ``100``).
+
+    :rtype: tuple(bytes, list)
+    :return: The processed image bytes (each byte represents a pixel and its
+             value is the index of a color from the palette), and the palette
+             (format: ``[r0, g0, b0, a0, r1, g1, b1, a1,...]``).
+
+    >>> import imagequant
+    >>> imagequant.quantize_raw_rgba_bytes(
+    ...     b"\\xFF\\x00\\x00\\xFF"
+    ...     b"\\x00\\xFF\\x00\\xFF"
+    ...     b"\\x00\\x00\\xFF\\xFF"
+    ...     b"\\xFF\\xFF\\xFF\\xFF",
+    ...     2, 2
+    ... )
+    (b'...', [...])
+    """
+    if len(image_data) != 4 * width * height:
+        raise ValueError("image_data length do not match the given width and height")
+
+    if not 0.0 <= dithering_level <= 1.0:
+        raise ValueError("dithering_level must be a float between 0.0 and 1.0")
+
+    if not 1 <= max_colors <= 256:
+        raise ValueError("max_colors must be an integer between 1 and 256")
+
+    if not 0 <= min_quality <= 100:
+        raise ValueError("min_quality must be an integer between 0 and 100")
+
+    if not 0 <= max_quality <= 100:
+        raise ValueError("max_quality must be an integer between 0 and 100")
+
+    if min_quality > max_quality:
+        raise ValueError("min_quality must be lower or equal to max_quality")
+
+    liq_attr = lib.liq_attr_create()
+    liq_attr.max_colors = max_colors
+    lib.liq_set_quality(liq_attr, min_quality, max_quality)
+
+    liq_image = lib.liq_image_create_rgba(liq_attr, image_data, width, height, 0)
+
+    liq_result_p = ffi.new("liq_result**")
+    code = lib.liq_image_quantize(liq_image, liq_attr, liq_result_p)
+    if code != lib.LIQ_OK:
+        raise RuntimeError(_get_error_msg(code))
+    lib.liq_set_dithering_level(liq_result_p[0], dithering_level)
+
+    raw_8bit_pixels = ffi.new("char[]", width * height)
+    lib.liq_write_remapped_image(
+        liq_result_p[0], liq_image, raw_8bit_pixels, width * height
+    )
+
+    pal = lib.liq_get_palette(liq_result_p[0])
+
+    output_image_data = ffi.unpack(raw_8bit_pixels, width * height)
+    output_palette = _liq_palette_to_raw_palette(pal)
+
+    lib.liq_result_destroy(liq_result_p[0])
+    lib.liq_image_destroy(liq_image)
+    lib.liq_attr_destroy(liq_attr)
+    ffi.release(raw_8bit_pixels)
+
+    return output_image_data, output_palette
+
+
+def quantize_pil_image(
+    image,
+    dithering_level=1.0,
+    max_colors=256,
+    min_quality=0,
+    max_quality=100,
+):
+    """Converts an RGBA image to an optimized 8bit paletted image.
+
+    :param PIL.Image.Image image: The image to process.
+    :param float dithering_level: The dithering level, from ``0.0`` (no
+                                  dithering) to ``1.0`` (default: ``1.0``).
+    :param int max_colors: Maximum number of color to use in the palette, from
+                           ``1`` to ``256`` (default: ``256``).
+    :param int min_quality: Minimum acceptable quality. If the minimum quality
+                            can’t be met, the quantization will be aborted and
+                            a ``RuntimeError`` will be raised. From ``0`` to
+                            ``100`` (default: ``0``).
+    :param int max_quality: The target quality, from ``0`` to ``100``
+                            (default: ``100``).
+
+    :rtype: PIL.Image.Image
+    :return: The processed image as a PIL/Pillow image.
+
+    >>> import imagequant
+    >>> input_image = Image.open("./example.png")
+    >>> imagequant.quantize_pil_image(input_image)
+    <PIL.Image.Image image mode=P size=... at ...>
+    """
+    if Image is None:
+        raise ImportError("PIL or Pillow is required to use this function.")
+
+    if image.mode != "RGBA":
+        image = image.convert(mode="RGBA")
+
+    input_image_data = _pil_image_to_raw_bytes(image)
+
+    output_image_data, output_palette = quantize_raw_rgba_bytes(
+        input_image_data,
+        image.width,
+        image.height,
+        dithering_level=dithering_level,
+        max_colors=max_colors,
+        min_quality=min_quality,
+        max_quality=max_quality,
+    )
+
+    output_image = Image.frombytes(
+        "P",
+        [image.width, image.height],
+        output_image_data,
+        decoder_name="raw",
+    )
+    output_image.putpalette(output_palette, rawmode="RGBA")
+
+    return output_image

imagequant/libimagequant_build.py

@@ -0,0 +1,37 @@
+import os
+
+from cffi import FFI
+from distutils import ccompiler
+
+
+_ROOT = os.path.abspath(os.path.dirname(__file__))
+_LIBIMAGEQUANT_H = os.path.join(_ROOT, "libimagequant.h")
+_LIBIMAGEQUANT_SRC = [
+    "blur.c",
+    "kmeans.c",
+    "mediancut.c",
+    "mempool.c",
+    "nearest.c",
+    "pam.c",
+    "libimagequant.c",
+]
+
+CC_ARGS = []
+if ccompiler.get_default_compiler() == "unix":
+    CC_ARGS = ["-Wno-incompatible-pointer-types"]
+
+
+ffibuilder = FFI()
+ffibuilder.set_source(
+    "imagequant._libimagequant",
+    "\n".join(['#include "%s"' % c for c in _LIBIMAGEQUANT_SRC]),
+    include_dirs=[
+        os.path.join(_ROOT, "..", "libimagequant"),
+    ],
+    extra_compile_args=CC_ARGS,
+)
+ffibuilder.cdef(open(_LIBIMAGEQUANT_H, "r").read())
+
+
+if __name__ == "__main__":
+    ffibuilder.compile(verbose=True)

imagequant-1.1.2.dist-info/LICENSE

@@ -0,0 +1,24 @@
+Copyright (c) 2021, Wanadev <http://www.wanadev.fr/>
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the name of Wanadev nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL WANADEV BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

imagequant-1.1.2.dist-info/METADATA

@@ -0,0 +1,218 @@
+Metadata-Version: 2.1
+Name: imagequant
+Version: 1.1.2
+Summary: Image Quantization Library
+Home-page: https://github.com/wanadev/imagequant-python
+Author: Wanadev
+Author-email: contact@wanadev.fr
+Maintainer: Fabien LOISON
+License: BSD-3-Clause
+Project-URL: Source Code, https://github.com/wanadev/imagequant-python
+Project-URL: Documentation, https://github.com/wanadev/imagequant-python#usage
+Project-URL: Changelog, https://github.com/wanadev/imagequant-python#changelog
+Project-URL: Issues, https://github.com/wanadev/imagequant-python/issues
+Project-URL: Chat, https://discord.gg/BmUkEdMuFp
+Keywords: image libimagequant pngquant cffi
+License-File: LICENSE
+Requires-Dist: cffi >=1.0.0
+Requires-Dist: setuptools
+Provides-Extra: dev
+Requires-Dist: nox ; extra == 'dev'
+Requires-Dist: flake8 ; extra == 'dev'
+Requires-Dist: black ; extra == 'dev'
+Requires-Dist: pytest ; extra == 'dev'
+Provides-Extra: pil
+Requires-Dist: pillow ; extra == 'pil'
+
+Imagequant Python - Python Bindings for libimagequant
+=====================================================
+
+|Github| |Discord| |PYPI Version| |Build Status| |Black| |License|
+
+**Imagequant Python** are bindings to allow using libimagequant_ from Python.
+
+**Libimagequant** is a small, portable C library for high-quality conversion of RGBA images to 8-bit indexed-color (palette) images.
+
+.. _libimagequant: https://github.com/ImageOptim/libimagequant
+
+
+Install
+-------
+
+From PyPI::
+
+    pip3 install imagequant
+
+NOTE: you may require compilation tools to build the library if you system is not suitable for the precompiled wheels. On Debian / Ubuntu you can install the build dependencies with the following command::
+
+    sudo apt install build-essential python3-dev
+
+
+Usage
+-----
+
+With PIL / Pillow
+~~~~~~~~~~~~~~~~~
+
+.. code-block:: python
+
+    from PIL import Image
+    import imagequant
+
+    input_image = Image.open("./example.png")
+    output_image = imagequant.quantize_pil_image(
+        input_image,
+        dithering_level=1.0,  # from 0.0 to 1.0
+        max_colors=256,       # from 1 to 256
+        min_quality=0,        # from 0 to 100
+        max_quality=100,      # from 0 to 100
+    )
+    output_image.save("./out.png", format="PNG")
+
+|input_image| → |output_image|
+
+.. |input_image| image:: ./example.png
+.. |output_image| image:: ./example_out.png
+
+
+With Raw Data
+~~~~~~~~~~~~~
+
+.. code-block:: python
+
+    import imagequant
+
+    # 2×2px image
+    IMAGE_DATA = (
+        # | R | G | B | A |
+        b"\xFF\x00\x00\xFF"  # red
+        b"\x00\xFF\x00\xFF"  # lime
+        b"\x00\x00\xFF\xFF"  # blue
+        b"\xFF\xFF\xFF\xFF"  # white
+    )
+
+    output_image_data, output_palette = imagequant.quantize_raw_rgba_bytes(
+        IMAGE_DATA,           # RGBA image data
+        2, 2,                 # width, height
+        dithering_level=1.0,  # from 0.0 to 1.0
+        max_colors=256,       # from 1 to 256
+        min_quality=0,        # from 0 to 100
+        max_quality=100,      # from 0 to 100
+    )
+
+    # you can now encode image data and the palette in any image format...
+
+Example ``output_image_data``:
+
+.. code-block:: python
+
+    b'\x02\x03\x00\x01'
+
+Example ``output_palette``:
+
+.. code-block:: python
+
+    [0, 0, 255, 255, 255, 255, 255, 255, 255, 0, 0, 255, 0, 255, 0, 255, 0, 0, 0, 0, ...]
+    # color 0      | color 1           | color 2       | color 3       | color 4   | ...
+
+
+Development of the Bindings
+---------------------------
+
+Clone the repository and get the submodules::
+
+    git clone https://github.com/wanadev/imagequant-python.git
+    cd imagequant-python
+    git submodule init
+    git submodule update
+
+Install some dependencies (preferably in a virtualenv)::
+
+    pip3 install nox cffi pillow
+
+Build the binary part of the lib::
+
+    python imagequant/libimagequant_build.py
+
+A ``.so`` file (or a ``.pyd`` file on Windows, or a ``.dylib`` file on MacOS) shoud now be present in the ``imagequant/`` folder. You will not need to run this command again until you change something in ``imagequant/libimagequant.h`` or in ``libimagequant/*.{c,h}``.
+
+To check the coding style, you can run the lint with the following command::
+
+    nox -s lint
+
+To run the tests, use the following command::
+
+    nox -s test
+
+
+License
+-------
+
+**Imagequant Python** is licensed under the BSD 3 Clause. See the LICENSE_ file for more information.
+
+**Libimagequant** is dual-licensed:
+
+* For Free/Libre Open Source Software it's available under GPL v3 or later with additional copyright notices for older parts of the code.
+
+* For use in closed-source software, AppStore distribution, and other non-GPL uses, you can obtain a commercial license.
+
+Read its `license terms <https://github.com/ImageOptim/libimagequant#license>`_ for more information.
+
+.. _LICENSE: https://github.com/wanadev/imagequant-python/blob/master/LICENSE
+
+
+Changelog
+---------
+
+* **[NEXT]** (changes on ``master`` that have not been released yet):
+
+  * Nothing yet ;)
+
+* **v1.1.2:**
+
+  * misc: Removed PyPy wheels for Windows AMD64 as they won't build (@flozz)
+  * misc: Fixed libimagequant build on newer GCC versions (@flozz)
+  * misc: Added Python 3.13 support (@flozz)
+  * misc!: Removed Python 3.8 support (@flozz)
+
+* **v1.1.1:**
+
+  * dist: Build and publish arm64 wheels for Linux and Windows (@laggykiller, #9, #10)
+
+* **v1.1.0:**
+
+  * Added options to set minimal and target (maximal) quality (@injet-zhou, #4)
+
+* **v1.0.5:**
+
+  * Added Python 3.12 support (@flozz)
+  * Removed Python 3.7 support (@flozz)
+
+* **v1.0.4:**
+
+  * Added Python 3.11 support
+
+* **v1.0.3:**
+
+  * ``arm64`` and ``universal2`` wheels for macOS M1
+  * ``x86`` and ``x68_64`` wheels for musl-based Linux distro (Alpine,...)
+  * ``x86`` wheels for Windows (``x86_64`` were already available)
+
+* **v1.0.2:** Python 3.10 support and wheels
+* **v1.0.1:** Fix encoding while reading the README in setup.py
+* **v1.0.0:** Initial release with a minimal API.
+
+
+
+.. |Github| image:: https://img.shields.io/github/stars/wanadev/imagequant-python?label=Github&logo=github
+   :target: https://github.com/wanadev/imagequant-python
+.. |Discord| image:: https://img.shields.io/badge/chat-Discord-8c9eff?logo=discord&logoColor=ffffff
+   :target: https://discord.gg/BmUkEdMuFp
+.. |PYPI Version| image:: https://img.shields.io/pypi/v/imagequant.svg
+   :target: https://pypi.python.org/pypi/imagequant
+.. |Build Status| image:: https://github.com/wanadev/imagequant-python/actions/workflows/python-ci.yml/badge.svg
+   :target: https://github.com/wanadev/imagequant-python/actions
+.. |Black| image:: https://img.shields.io/badge/code%20style-black-000000.svg
+   :target: https://black.readthedocs.io/en/stable/
+.. |License| image:: https://img.shields.io/pypi/l/imagequant.svg
+   :target: https://github.com/wanadev/imagequant-python/blob/master/LICENSE

imagequant-1.1.2.dist-info/RECORD

@@ -0,0 +1,8 @@
+imagequant/__init__.py,sha256=Zne82B1a_FXYKbwWMguJmgGfO3NLd7c7L2v00UA7QPg,7109
+imagequant/_libimagequant.pyd,sha256=bcyOq2rCo5_kRg6PlUoCrk_r4A8l-Teyvp3xaCMbdq8,97792
+imagequant/libimagequant_build.py,sha256=OL-3EjI_gjcwOpAaVoRcmYQj1G-rc5Y7jIbTvZgGays,840
+imagequant-1.1.2.dist-info/LICENSE,sha256=WjuRuFXN2gXuJFKlhnK19ITS8sBlwOjdbRMCCU5oISA,1521
+imagequant-1.1.2.dist-info/METADATA,sha256=w2W0JFyQlYTrAJVkYp_-EbkTP31fP_ZnIIr-flgCHBc,6988
+imagequant-1.1.2.dist-info/WHEEL,sha256=UJbDlEYuWWwgv9Hu0As4Rgv2Qpdka2YFe6UlEKs4AoE,101
+imagequant-1.1.2.dist-info/top_level.txt,sha256=9AzQ9NgvAz4fDBTQwr6nG2LtlMnV88Dm3IGIkx0ZfGo,11
+imagequant-1.1.2.dist-info/RECORD,,

imagequant-1.1.2.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (75.3.0)
+Root-Is-Purelib: false
+Tag: cp313-cp313-win_amd64
+

imagequant-1.1.2.dist-info/top_level.txt

@@ -0,0 +1 @@
+imagequant