python-libphash 2.0.1.0__cp315-cp315t-win_amd64.whl

libphash/_sources.py

@@ -0,0 +1,278 @@
+"""Turning what a caller has into C arguments.
+
+A caller has a path, bytes, an array of pixels or a Pillow image.
+"""
+
+from __future__ import annotations
+
+import os
+import sys
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Any, Literal, Protocol, Union, cast, runtime_checkable
+
+from ._errors import PH_ERR_IO, make_error
+from ._native import ffi
+
+if TYPE_CHECKING:
+    from collections.abc import Mapping
+
+    from typing_extensions import Buffer
+
+    from ._native import char_ptr, uint8_t_ptr
+
+#: A file system path, as ``open()`` takes it.
+StrPath = Union[str, bytes, "os.PathLike[str]", "os.PathLike[bytes]"]
+#: Order of the color channels in an array of pixels: ``"bgr"`` is OpenCV's.
+ChannelOrder = Literal["rgb", "bgr"]
+
+
+class SupportsRead(Protocol):
+    """A binary file object: an open file, ``io.BytesIO``, a response body."""
+
+    def read(self) -> bytes: ...
+
+
+@runtime_checkable
+class SupportsArrayInterface(Protocol):
+    """An array exposing numpy's ``__array_interface__``.
+
+    A numpy array is one, and so is a Pillow image.
+    """
+
+    @property
+    def __array_interface__(self) -> Mapping[str, Any]: ...
+
+
+class PILImage(Protocol):
+    """The part of ``PIL.Image.Image`` the binding reads."""
+
+    @property
+    def mode(self) -> str: ...
+    @property
+    def size(self) -> tuple[int, int]: ...
+    def tobytes(self) -> bytes: ...
+    def convert(self, mode: str) -> PILImage: ...
+
+
+#: Decoded 8-bit pixels of shape (h, w) or (h, w, 1|3|4): a numpy array, a memoryview.
+PixelArray = SupportsArrayInterface | memoryview
+
+#: Everything :func:`libphash.hash` and :meth:`ImageContext.load` accept: a path,
+#: encoded bytes, a binary file object, an array of pixels or a Pillow image. ``bytes``
+#: are always encoded image data, never a path.
+Source = Union[
+    str,
+    "os.PathLike[str]",
+    "os.PathLike[bytes]",
+    bytes,
+    bytearray,
+    memoryview,
+    SupportsArrayInterface,
+    SupportsRead,
+]
+
+#: Paths reach the C library's narrow-character open(), which on Windows reads the ANSI
+#: code page, not the UTF-8 that os.fsencode() gives. On Windows the binding therefore
+#: reads the file itself and loads it from memory.
+READ_FILES_IN_PYTHON = sys.platform == "win32"
+
+
+def encode_path(path: StrPath) -> bytes:
+    """Return the path as the bytes the C library gets.
+
+    They are the file system encoding of the path: on POSIX, the path's bytes unchanged.
+    A path with a null byte raises ValueError, as ``open()`` does: C would read only the
+    part before it and open another file.
+    """
+    try:
+        encoded = os.fsencode(path)
+    except TypeError:
+        raise TypeError(
+            f"expected a path (str, bytes or os.PathLike), got {type(path).__name__}"
+        ) from None
+    if b"\0" in encoded:
+        raise ValueError("embedded null byte")
+    return encoded
+
+
+def encode_text(text: str) -> bytes:
+    """Return a name or a hex form as the ASCII string a C parser reads.
+
+    C reads up to the first null byte, so a null byte, like any other character outside
+    ASCII, becomes ``?``, which no parser of libphash accepts.
+    """
+    return text.encode("ascii", "replace").replace(b"\0", b"?")
+
+
+def is_pil_image(obj: object) -> bool:
+    module = str(type(obj).__module__)
+    return (
+        module.startswith("PIL.") and hasattr(obj, "mode") and hasattr(obj, "tobytes")
+    )
+
+
+@dataclass
+class Pixels:
+    """Arguments for ph_load_from_pixels().
+
+    The pointer is either ``ffi.from_buffer()``'s, which keeps its object alive, or an
+    array's own address, valid while the caller holds the array.
+    """
+
+    pointer: char_ptr | uint8_t_ptr
+    width: int
+    height: int
+    channels: int
+    stride: int
+
+
+def pixels_from_array(obj: PixelArray, channel_order: ChannelOrder) -> Pixels:
+    """Read the pixels of an 8-bit array of shape (h, w) or (h, w, 1|3|4).
+
+    A numpy array whose rows are spaced apart (a crop, ``arr[10:-10, 5:-5]``) is passed
+    without a copy, its row step as the C stride; one with gaps or reversed order inside
+    a row, or in BGR order, is copied once.
+    """
+    if channel_order not in ("rgb", "bgr"):
+        raise ValueError(f"channel_order must be 'rgb' or 'bgr', got {channel_order!r}")
+    iface = getattr(obj, "__array_interface__", None)
+    if iface is not None:
+        return _from_array_interface(obj, iface, channel_order)
+    try:
+        # Any object with the buffer protocol and a shape, beyond what PixelArray names.
+        view = memoryview(cast("Buffer", obj))
+    except TypeError:
+        raise TypeError(
+            "expected an array of pixels (numpy, memoryview with a shape), "
+            f"got {type(obj).__name__}"
+        ) from None
+    if view.format not in ("B", "c"):
+        raise TypeError(
+            f"pixels must be 8-bit unsigned (format 'B'), got format {view.format!r}; "
+            "convert the array to uint8 first"
+        )
+    height, width, channels = _shape(tuple(view.shape or ()))
+    if view.c_contiguous and channel_order == "rgb":
+        return Pixels(ffi.from_buffer(view), width, height, channels, 0)
+    data = view.tobytes()
+    return _packed(data, width, height, channels, channel_order)
+
+
+def _from_array_interface(
+    obj: object, iface: Mapping[str, Any], channel_order: ChannelOrder
+) -> Pixels:
+    typestr = iface.get("typestr", "")
+    if typestr[1:] != "u1":
+        raise TypeError(
+            f"pixels must be uint8, got typestr {typestr!r}; "
+            "convert the array to uint8 first"
+        )
+    height, width, channels = _shape(tuple(iface["shape"]))
+    strides = iface.get("strides")
+    if strides is None:  # C-contiguous
+        strides = (width * channels, channels, 1)[: len(iface["shape"])]
+    row = strides[0]
+    pixel = strides[1]
+    channel = strides[2] if len(strides) == 3 else 1
+    data: object = iface.get("data")
+    # numpy states the address as (pointer, read_only); other exporters may not.
+    address = cast("tuple[object, ...]", data)[0] if isinstance(data, tuple) else None
+    zero_copy = (
+        channel_order == "rgb"
+        and pixel == channels
+        and channel == 1
+        and row >= width * channels
+    )
+    if zero_copy and isinstance(address, int):
+        pointer = ffi.cast("const uint8_t *", address)
+        return Pixels(pointer, width, height, channels, row)
+    # Any other layout: one C-ordered copy through the buffer protocol.
+    try:
+        packed = memoryview(cast("Buffer", obj)).tobytes()
+    except TypeError:
+        raise TypeError(
+            "the array does not expose its data through the buffer protocol"
+        ) from None
+    return _packed(packed, width, height, channels, channel_order)
+
+
+def _packed(
+    data: bytes, width: int, height: int, channels: int, order: ChannelOrder
+) -> Pixels:
+    if order == "bgr":
+        if channels < 3:
+            raise ValueError("channel_order='bgr' needs 3 or 4 channels")
+        swapped = bytearray(data)
+        swapped[0::channels], swapped[2::channels] = (
+            data[2::channels],
+            data[0::channels],
+        )
+        data = bytes(swapped)
+    return Pixels(ffi.from_buffer(data), width, height, channels, 0)
+
+
+def _shape(shape: tuple[int, ...]) -> tuple[int, int, int]:
+    if len(shape) == 2:
+        return shape[0], shape[1], 1
+    if len(shape) == 3 and shape[2] in (1, 3, 4):
+        return shape[0], shape[1], shape[2]
+    raise ValueError(
+        f"pixels must have shape (height, width) or (height, width, 1|3|4), got {shape}"
+    )
+
+
+_PIL_DIRECT = {"L": 1, "RGB": 3, "RGBA": 4}
+_PIL_UNSUPPORTED = ("I", "I;16", "I;16B", "I;16L", "I;16N", "F")
+
+
+def pixels_from_pil(img: PILImage) -> Pixels:
+    """Read the pixels of a Pillow image.
+
+    ``L``, ``RGB`` and ``RGBA`` are read as they are. ``1`` becomes ``L``; palette and
+    gray-with-alpha images become ``RGBA``, which hashes as ``RGB`` where every pixel is
+    opaque; ``CMYK``, ``YCbCr``, ``HSV`` and ``LAB`` become ``RGB``. 16-bit, 32-bit
+    integer and float modes are refused: there is no single right way to bring them to
+    8 bits.
+    Pillow does not apply the EXIF orientation to the pixels; pass the image through
+    ``PIL.ImageOps.exif_transpose`` first if it matters.
+    """
+    mode = img.mode
+    if mode in _PIL_UNSUPPORTED:
+        raise TypeError(
+            f"Pillow mode {mode!r} is not 8-bit; "
+            "convert it (img.convert('L') or 'RGB') first"
+        )
+    if mode not in _PIL_DIRECT:
+        if mode == "1":
+            target = "L"
+        elif mode in ("P", "PA", "LA", "La", "RGBa"):
+            if mode == "La":
+                # Pillow converts premultiplied gray-with-alpha only to LA.
+                img = img.convert("LA")
+            target = "RGBA"
+        else:
+            target = "RGB"
+        img = img.convert(target)
+        mode = target
+    width, height = img.size
+    data = img.tobytes()
+    channels = _PIL_DIRECT[mode]
+    return Pixels(ffi.from_buffer(data), width, height, channels, 0)
+
+
+def read_file(path: StrPath) -> bytes:
+    """Read an image file for the C library to load from memory.
+
+    A file that cannot be opened, or is empty, raises the ImageIOError that the C
+    library's own open would, with the same message.
+    """
+    try:
+        with open(path, "rb") as f:
+            data = f.read()
+    except OSError as e:
+        detail = f"Cannot open '{os.fsdecode(path)}': {e.strerror}"
+        raise make_error(PH_ERR_IO, detail=detail, path=path) from e
+    if not data:
+        detail = f"Cannot read '{os.fsdecode(path)}': file is empty"
+        raise make_error(PH_ERR_IO, detail=detail, path=path)
+    return data

libphash/_version.py

@@ -0,0 +1,3 @@
+# X.Y.Z.N: X.Y.Z is the bundled libphash, N the binding revision on top of it
+# (0 for the first binding of a libphash release, and written out).
+__version__ = "2.0.1.0"

libphash/exceptions.py

@@ -0,0 +1,157 @@
+"""Exceptions raised by libphash.
+
+Every failure of the C library becomes a subclass of :class:`PhashError`, chosen by its
+``ph_error_t`` code. The classes also derive from the built-in exception a Python
+programmer would reach for: an unreadable file is an :class:`OSError` (with ``errno``,
+so ``except FileNotFoundError`` works), a bad argument a :class:`ValueError`, a failed
+allocation a :class:`MemoryError`.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+from ._native import lib
+
+__all__ = [
+    "AllocationError",
+    "BatchCancelledError",
+    "CorruptDataError",
+    "DecodeError",
+    "DecoderUnavailableError",
+    "DigestKindError",
+    "EmptyImageError",
+    "ImageIOError",
+    "ImageTooLargeError",
+    "InvalidArgumentError",
+    "NoStructureError",
+    "PhashError",
+    "RequiresColorError",
+    "UnsupportedFormatError",
+]
+
+
+class PhashError(Exception):
+    """Base class of every libphash error.
+
+    Attributes:
+        code: the ``ph_error_t`` value, or 0 for an error raised by the binding itself.
+        code_name: the C name of the code (``"PH_ERR_IO"``), or ``""``.
+        detail: the C library's description of this failure (for loading: the path and
+            the reason), or ``""``.
+    """
+
+    code: int
+    code_name: str
+    detail: str
+
+    def __init__(self, message: str, *, code: int = 0, detail: str = "") -> None:
+        super().__init__(message)
+        self.code = code
+        self.code_name = _CODE_NAMES.get(code, "") if code else ""
+        self.detail = detail
+
+    def __reduce__(self) -> tuple[Any, ...]:
+        return (_rebuild, (type(self), str(self), self.code, self.detail))
+
+
+def _rebuild(cls: type[PhashError], message: str, code: int, detail: str) -> PhashError:
+    exc = cls.__new__(cls)
+    PhashError.__init__(exc, message, code=code, detail=detail)
+    return exc
+
+
+class ImageIOError(PhashError, OSError):
+    """The path could not be used as an image source (``PH_ERR_IO``).
+
+    ``errno`` and ``filename`` are filled in when the cause can be told (a missing file,
+    a directory, no permission), so the matching :class:`OSError` subclass catches it:
+    ``except FileNotFoundError`` sees a missing image file.
+    """
+
+    def __init__(self, message: str, *, code: int = 0, detail: str = "") -> None:
+        PhashError.__init__(self, message, code=code, detail=detail)
+
+    def __str__(self) -> str:
+        # OSError's own would print "[Errno 2] ..." once errno is set.
+        return str(self.args[0])
+
+    def __repr__(self) -> str:
+        # The errno-specific subclasses are an implementation detail.
+        return f"ImageIOError({str(self)!r})"
+
+    def __reduce__(self) -> tuple[Any, ...]:
+        return (
+            _rebuild_io,
+            (type(self), str(self), self.code, self.detail, self.errno, self.filename),
+        )
+
+
+def _rebuild_io(  # noqa: PLR0913 -- one argument per pickled field
+    cls: type[ImageIOError],
+    message: str,
+    code: int,
+    detail: str,
+    err: int | None,
+    filename: object,
+) -> ImageIOError:
+    exc = cls.__new__(cls)
+    ImageIOError.__init__(exc, message, code=code, detail=detail)
+    exc.errno = err
+    exc.filename = filename
+    return exc
+
+
+class DecodeError(PhashError):
+    """The data could not be decoded into an image. Parent of the four reasons below."""
+
+
+class UnsupportedFormatError(DecodeError):
+    """The data is in no image format libphash recognizes."""
+
+
+class CorruptDataError(DecodeError):
+    """The format was recognized, but the data is malformed or truncated."""
+
+
+class DecoderUnavailableError(DecodeError):
+    """The format was recognized, but this build has no decoder for it."""
+
+
+class ImageTooLargeError(DecodeError):
+    """The image is larger than ``Config.max_pixels`` or the library's fixed limits."""
+
+
+class InvalidArgumentError(PhashError, ValueError):
+    """An argument is outside the range the C library accepts."""
+
+
+class AllocationError(PhashError, MemoryError):
+    """A memory allocation failed in the C library."""
+
+
+class EmptyImageError(PhashError):
+    """A hash was requested from a context that holds no image."""
+
+
+class RequiresColorError(PhashError):
+    """A color algorithm was asked for an image loaded in grayscale."""
+
+
+class NoStructureError(PhashError):
+    """A Radial digest has no structure to correlate (a flat image)."""
+
+
+class BatchCancelledError(PhashError):
+    """A batch was stopped before every item was started."""
+
+
+class DigestKindError(PhashError, TypeError):
+    """Two digests were compared by a metric their kind does not support."""
+
+
+_CODE_NAMES: dict[int, str] = {
+    int(getattr(lib, name)): name
+    for name in dir(lib)
+    if name.startswith("PH_ERR_") and not name.endswith("_")
+}

python_libphash-2.0.1.0.dist-info/METADATA

@@ -0,0 +1,138 @@
+Metadata-Version: 2.4
+Name: python-libphash
+Version: 2.0.1.0
+Summary: Perceptual image hashing: Python binding for the libphash C library
+Author-email: gudoshnikovn <gudoshnikovna@gmail.com>
+License-Expression: MIT AND IJG AND Zlib AND libpng-2.0 AND BSD-3-Clause AND (MIT OR Unlicense)
+Project-URL: Homepage, https://github.com/gudoshnikovn/python-libphash
+Project-URL: Source, https://github.com/gudoshnikovn/python-libphash
+Project-URL: Issues, https://github.com/gudoshnikovn/python-libphash/issues
+Project-URL: Changelog, https://github.com/gudoshnikovn/python-libphash/blob/main/CHANGELOG.md
+Project-URL: libphash, https://gudoshnikovn.github.io/libphash/
+Keywords: perceptual hash,phash,image hashing,duplicate images,dhash
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: MacOS
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: C
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python :: 3.15
+Classifier: Programming Language :: Python :: Free Threading :: 2 - Beta
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Topic :: Multimedia :: Graphics
+Classifier: Topic :: Scientific/Engineering :: Image Recognition
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+License-File: native/libphash/THIRD-PARTY-NOTICES.md
+License-File: native/libphash/vendor/libjpeg-turbo/LICENSE.md
+License-File: native/libphash/vendor/libjpeg-turbo/README.ijg
+License-File: native/libphash/vendor/libpng/LICENSE
+License-File: native/libphash/vendor/libwebp/COPYING
+License-File: native/libphash/vendor/libwebp/PATENTS
+License-File: native/libphash/vendor/zlib-ng/LICENSE.md
+Requires-Dist: cffi>=2.0
+Provides-Extra: dev
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: pytest-randomly; extra == "dev"
+Requires-Dist: pytest-timeout; extra == "dev"
+Requires-Dist: hypothesis; extra == "dev"
+Requires-Dist: psutil; extra == "dev"
+Requires-Dist: coverage; extra == "dev"
+Requires-Dist: mypy; extra == "dev"
+Requires-Dist: basedpyright; extra == "dev"
+Requires-Dist: ruff; extra == "dev"
+Requires-Dist: typos; extra == "dev"
+Requires-Dist: setuptools; extra == "dev"
+Requires-Dist: types-setuptools; extra == "dev"
+Requires-Dist: types-cffi; extra == "dev"
+Requires-Dist: types-psutil; extra == "dev"
+Requires-Dist: typing_extensions; extra == "dev"
+Requires-Dist: numpy; extra == "dev"
+Requires-Dist: Pillow; extra == "dev"
+Requires-Dist: opencv-python-headless; extra == "dev"
+Requires-Dist: mutmut; sys_platform != "win32" and extra == "dev"
+Requires-Dist: lief; extra == "dev"
+Dynamic: license-file
+
+# python-libphash
+
+Perceptual image hashing in Python, with the [libphash](https://github.com/gudoshnikovn/libphash)
+C library inside.
+
+[![CI](https://github.com/gudoshnikovn/python-libphash/actions/workflows/ci.yml/badge.svg)](https://github.com/gudoshnikovn/python-libphash/actions/workflows/ci.yml)
+[![PyPI](https://img.shields.io/pypi/v/python-libphash.svg)](https://pypi.org/project/python-libphash/)
+[![Python](https://img.shields.io/pypi/pyversions/python-libphash.svg)](https://pypi.org/project/python-libphash/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://github.com/gudoshnikovn/python-libphash/blob/main/LICENSE)
+
+A perceptual hash changes little when an image is resized, recompressed or slightly
+edited, so comparing hashes finds the copies of a picture among many images; an
+unrelated picture lands about half the bits away. The package computes nine algorithms
+in C, decodes JPEG, PNG and WebP with libraries linked into the wheel, and gives the same
+hash for the same file on every platform, bit for bit libphash's.
+
+**[Documentation](https://gudoshnikovn.github.io/python-libphash/)** · the theory
+(algorithms, comparing, choosing a threshold) is on
+[libphash's site](https://gudoshnikovn.github.io/libphash/).
+
+```bash
+pip install python-libphash
+```
+
+Wheels for Linux (x86-64, arm64), macOS (arm64) and Windows (x86-64), CPython 3.10 and
+later, free-threaded builds included; elsewhere pip builds from source with a C compiler.
+
+```python
+import libphash as ph
+from libphash import Algorithm
+
+a = ph.hash("photo.jpg")                       # pHash, a 64-bit int
+b = ph.hash("photo_copy.jpg")
+print(ph.hamming_distance(a, b))               # 0..64 bits differ: 0 for a copy
+
+r = ph.hash("photo.jpg", Algorithm.RADIAL)     # a Digest
+print(r.similarity(ph.hash("photo_rotated.jpg", Algorithm.RADIAL)))
+
+results = ph.hash_files(["photo.jpg", "photo_copy.jpg"], threads=0)   # all CPUs
+```
+
+`ph.hash()` takes a path, encoded bytes, a file object, a numpy array of pixels or a
+Pillow image; `ImageContext` computes several hashes of one image and reuses its buffers
+from image to image; `Config` holds every setting of libphash and checks it.
+
+From a shell, `libphash hash`, `compare` and `dupes` do the same for files
+(`python -m libphash` where the command is not on `PATH`):
+
+```bash
+libphash dupes --max-bits 10 ~/Pictures
+```
+
+## Scope
+
+Hashes are deterministic and unkeyed: they find the copies of a picture in a collection
+you control. They are not for moderation, blocklists or checking untrusted input, since
+anyone who can choose the images can make two pictures hash alike or keep a copy from
+matching. Decoding files from anywhere is the expected use, and a crash on one is a
+vulnerability: see [SECURITY.md](https://github.com/gudoshnikovn/python-libphash/blob/main/SECURITY.md).
+
+## Versions
+
+The version is `X.Y.Z.N`: `X.Y.Z` is the bundled libphash, `N` the revision of the
+binding. Hash values depend on `X.Y.Z` and the settings only, so
+`pip install "python-libphash==2.0.1.*"` keeps a stored collection comparable while
+taking the binding's fixes. Upgrading from 1.x changes hash values and the API: read
+[MIGRATION.md](https://github.com/gudoshnikovn/python-libphash/blob/main/MIGRATION.md).
+
+## License
+
+MIT, see [LICENSE](https://github.com/gudoshnikovn/python-libphash/blob/main/LICENSE). The
+wheels include libphash and the libraries it bundles (libjpeg-turbo, libpng, libwebp,
+zlib-ng, stb_image), each under its own license, carried in the wheel.

python_libphash-2.0.1.0.dist-info/RECORD

@@ -0,0 +1,29 @@
+libphash/__init__.py,sha256=gjy7yG4OfjBDpB4p7GtzHHoCJvr85bbbJOQ0p3xaENA,5775
+libphash/__main__.py,sha256=sLikFD6ofBKa5swu8fWWCxDH_FlzidWH3JJcmXH1CnA,145
+libphash/_algorithms.py,sha256=ZAk8KqF_d1XyDHaMpCMQJSeSu6XYnsPHbu2c_6eTdBQ,2689
+libphash/_batch.py,sha256=mDxyMOpVsKeLikotxGQNuU24LsaC1UllSlbwsJQlPYs,13263
+libphash/_cli.py,sha256=Au033w2Q2ww50i-294aoC7mSR4SfUiobLOgaL6KYHZ8,18598
+libphash/_config.py,sha256=s8hy6sbVZ2_pW-aOJsMFN1RkGWL7gmzrc4RHBIut0WI,8213
+libphash/_context.py,sha256=QrGMeI9VZUvqmfTm0OQpbWqIZfjbN5rQbPq5iQceLm8,14309
+libphash/_digest.py,sha256=pBRXOwDXPcvP-L9qR2rDqrUwuoonRxnQgqksB9Ucbjs,11201
+libphash/_errors.py,sha256=nnOrzpFt4sW8I3-tO60MKWTIfSYh8DvgmRgOxuEAtec,3695
+libphash/_native.pyd,sha256=_2mf2F4YV12ONgcNnmHbz9W-w-hi34MKeCC3hD_BSUw,1292288
+libphash/_native.pyi,sha256=DxfxZtvVnG2FiRZbYqGzL_USBEaB0NRNuGmsgUoAshY,31335
+libphash/_sources.py,sha256=fiR6PMkQGP9KP4GrbjX-yn72B4Zz9siSNf8Z3EdzB1w,9888
+libphash/_version.py,sha256=hzV08Wy1L0XhmKoiIdHtGxsgDAIydpymWju7paJUGlA,173
+libphash/exceptions.py,sha256=zIxDbRIDhI1SnYlxIcwZdMTkppKoy1GtQT4lD0zKmQM,4881
+libphash/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+python_libphash-2.0.1.0.dist-info/licenses/LICENSE,sha256=y0PvbnMHXl-CFTfDpc55kAgVCUT22vsWFpdkOp11-N8,1090
+python_libphash-2.0.1.0.dist-info/licenses/native/libphash/THIRD-PARTY-NOTICES.md,sha256=e95tvS69Y0JFF2BnpN91ymIuOERf3u0qe4kR-t4hZjA,8236
+python_libphash-2.0.1.0.dist-info/licenses/native/libphash/vendor/libjpeg-turbo/LICENSE.md,sha256=z_hwHcmZ45tQROzo8i7WWzoQ1qjb3cqP-4AtJFgBgds,6224
+python_libphash-2.0.1.0.dist-info/licenses/native/libphash/vendor/libjpeg-turbo/README.ijg,sha256=2xagQSgXGHnGBwjRcbiNlzRaLdIPm_wXNoCkSXxz9wQ,13059
+python_libphash-2.0.1.0.dist-info/licenses/native/libphash/vendor/libpng/LICENSE,sha256=RSOQQzug-Iqj4rEixkd0G3KgwRfNbtejKbSXha7LVRE,5479
+python_libphash-2.0.1.0.dist-info/licenses/native/libphash/vendor/libwebp/COPYING,sha256=F8ApqQKtRaGZ3-jjocOTBaso0wKwcDNgxKJzUaRnPcs,1526
+python_libphash-2.0.1.0.dist-info/licenses/native/libphash/vendor/libwebp/PATENTS,sha256=1Xi3pHHUhAahbGTjxqhoXmYpLzxnCSFMScpVsvIu180,1459
+python_libphash-2.0.1.0.dist-info/licenses/native/libphash/vendor/zlib-ng/LICENSE.md,sha256=bJ8Nl1tBr6o00i9Vu4mGzmnly3rTJ8srKIIM1CXt9e4,867
+python_libphash-2.0.1.0.dist-info/sboms/python-libphash.cdx.json,sha256=H9ZrHM4lLPhzasvsTUvVUi1lpKovJ33FGKS6S3Jn07c,3814
+python_libphash-2.0.1.0.dist-info/METADATA,sha256=m7B84MRFIVQvwCMTq-faVuDZlmOBSK8V7_coXGFyzLQ,6765
+python_libphash-2.0.1.0.dist-info/WHEEL,sha256=_nx_6fOfFB2ir5m3GgtWLIoU4BeBcd0Dd-_9POcQKIM,102
+python_libphash-2.0.1.0.dist-info/entry_points.txt,sha256=JBVFrsnjo0jM6NzdRnl_goKwNQAg5ciaUTy4e8nfFHk,48
+python_libphash-2.0.1.0.dist-info/top_level.txt,sha256=_Iys95-wvePR99MGJ1ikgjscpcotnUJ2m3JzmLvCG7w,9
+python_libphash-2.0.1.0.dist-info/RECORD,,

python_libphash-2.0.1.0.dist-info/WHEEL

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

python_libphash-2.0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+libphash = libphash._cli:main

python_libphash-2.0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 gudoshnikovn
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.