feat: release duplicate-finder 1.0.0HEAD v1.0.0 main

Introduce the first public release of duplicate-finder, a command-line tool for detecting duplicate files through metadata grouping and content hashing. Support recursive path scanning, optional symlink traversal, hard-link handling, size and extension-based candidate grouping, and parallel content hashing with xxHash or hashlib algorithms. Provide human, plain, table, and JSON output formats together with size filtering, path input from files or stdin, progress reporting, diagnostic output, and configurable terminal colors. Add Python packaging for Python 3.14, project documentation, dependency locking, development tooling, and BSD-3-Clause licensing.
author: Dennis Fink 2026-09-20 20:04:13 +0200
committer: Dennis Fink 2026-09-20 20:04:13 +0200
commit: b751174b4ed7c23786ae54a1bbaf332f653faa81 (patch)
tree: c1951961b7bdd171aa4903d9e2d5ad4f2a063b51
download: duplicate-finder-1.0.0.tar.gz
duplicate-finder-1.0.0.zip
15 files changed, 2361 insertions, 0 deletions
diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000..0b7bfce
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,379 @@
+# SPDX-FileCopyrightText: 2026 Dennis Fink <me+coding@dennisfink.me>
+#
+# SPDX-License-Identifier: BSD-3-Clause
+
+# Created by https://www.toptal.com/developers/gitignore/api/windows,linux,macos,zsh,fish,vim,emacs,git,python
+# Edit at https://www.toptal.com/developers/gitignore?templates=windows,linux,macos,zsh,fish,vim,emacs,git,python
+
+### Emacs ###
+# -*- mode: gitignore; -*-
+*~
+\#*\#
+/.emacs.desktop
+/.emacs.desktop.lock
+*.elc
+auto-save-list
+tramp
+.\#*
+
+# Org-mode
+.org-id-locations
+*_archive
+
+# flymake-mode
+*_flymake.*
+
+# eshell files
+/eshell/history
+/eshell/lastdir
+
+# elpa packages
+/elpa/
+
+# reftex files
+*.rel
+
+# AUCTeX auto folder
+/auto/
+
+# cask packages
+.cask/
+dist/
+
+# Flycheck
+flycheck_*.el
+
+# server auth directory
+/server/
+
+# projectiles files
+.projectile
+
+# directory configuration
+.dir-locals.el
+
+# network security
+/network-security.data
+
+
+### Fish ###
+fishd.*
+fish_history
+fish_variables
+config.local.fish
+
+### Git ###
+# Created by git for backups. To disable backups in Git:
+# $ git config --global mergetool.keepBackup false
+*.orig
+
+# Created by git when using merge tools for conflicts
+*.BACKUP.*
+*.BASE.*
+*.LOCAL.*
+*.REMOTE.*
+*_BACKUP_*.txt
+*_BASE_*.txt
+*_LOCAL_*.txt
+*_REMOTE_*.txt
+
+### Linux ###
+
+# temporary files which can be created if a process still has a handle open of a deleted file
+.fuse_hidden*
+
+# KDE directory preferences
+.directory
+
+# Linux trash folder which might appear on any partition or disk
+.Trash-*
+
+# .nfs files are created when an open file is removed but is still being accessed
+.nfs*
+
+### macOS ###
+# General
+.DS_Store
+.AppleDouble
+.LSOverride
+
+# Icon must end with two \r
+Icon
+
+
+# Thumbnails
+._*
+
+# Files that might appear in the root of a volume
+.DocumentRevisions-V100
+.fseventsd
+.Spotlight-V100
+.TemporaryItems
+.Trashes
+.VolumeIcon.icns
+.com.apple.timemachine.donotpresent
+
+# Directories potentially created on remote AFP share
+.AppleDB
+.AppleDesktop
+Network Trash Folder
+Temporary Items
+.apdisk
+
+### macOS Patch ###
+# iCloud generated files
+*.icloud
+
+### Python ###
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#pdm.lock
+#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
+#   in version control.
+#   https://pdm.fming.dev/#use-with-ide
+.pdm.toml
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/
+
+### Python Patch ###
+# Poetry local configuration file - https://python-poetry.org/docs/configuration/#local-configuration
+poetry.toml
+
+# ruff
+.ruff_cache/
+
+# LSP config files
+pyrightconfig.json
+
+### Vim ###
+# Swap
+[._]*.s[a-v][a-z]
+!*.svg  # comment out if you don't need vector files
+[._]*.sw[a-p]
+[._]s[a-rt-v][a-z]
+[._]ss[a-gi-z]
+[._]sw[a-p]
+
+# Session
+Session.vim
+Sessionx.vim
+
+# Temporary
+.netrwhist
+# Auto-generated tag files
+tags
+# Persistent undo
+[._]*.un~
+
+### Windows ###
+# Windows thumbnail cache files
+Thumbs.db
+Thumbs.db:encryptable
+ehthumbs.db
+ehthumbs_vista.db
+
+# Dump file
+*.stackdump
+
+# Folder config file
+[Dd]esktop.ini
+
+# Recycle Bin used on file shares
+$RECYCLE.BIN/
+
+# Windows Installer files
+*.cab
+*.msi
+*.msix
+*.msm
+*.msp
+
+# Windows shortcuts
+*.lnk
+
+### Zsh ###
+# Zsh compiled script + zrecompile backup
+*.zwc
+*.zwc.old
+
+# Zsh completion-optimization dumpfile
+*zcompdump*
+
+# Zsh history
+.zsh_history
+
+# Zsh sessions
+.zsh_sessions
+
+# Zsh zcalc history
+.zcalc_history
+
+# A popular plugin manager's files
+._zinit
+.zinit_lstupd
+
+# zdharma/zshelldoc tool's files
+zsdoc/data
+
+# robbyrussell/oh-my-zsh/plugins/per-directory-history plugin's files
+# (when set-up to store the history in the local directory)
+.directory_history
+
+# MichaelAquilina/zsh-autoswitch-virtualenv plugin's files
+# (for Zsh plugins using Python)
+
+# Zunit tests' output
+/tests/_output/*
+!/tests/_output/.gitkeep
+
+# End of https://www.toptal.com/developers/gitignore/api/windows,linux,macos,zsh,fish,vim,emacs,git,python
diff --git a/.gitmessage b/.gitmessage
new file mode 100644
index 0000000..0504dbc
--- /dev/null
+++ b/.gitmessage
@@ -0,0 +1,38 @@
+
+# <type>[optional scope]: <short description>  (max 72 chars total) ------>|
+#
+# Types (choose ONE):
+#   feat      New feature (MINOR bump in SemVer)
+#   fix       Bug fix (PATCH bump)
+#   docs      Documentation only (README, man page, comments)
+#   style     Formatting, whitespace — no logic change
+#   refactor  Code restructure — no feature/fix
+#   perf      Performance improvement
+#   test      Tests only
+#   build     Build system / dependency changes
+#   ci        CI/CD configuration
+#   chore     Maintenance (release commits, tooling)
+#   revert    Revert a previous commit
+#
+# Breaking changes: append ! before the colon  →  feat(cli)!: ...
+# --------------------------------------------------------------------------
+
+# [blank line — required before body]
+
+# Body (optional): explain WHY, not WHAT. Wrap at 72 chars.            ---->|
+#
+# Motivation for the change, background, trade-offs considered, etc.
+# Use multiple paragraphs separated by blank lines if needed.
+
+# [blank line before footers]
+
+# Footers (optional):
+#   BREAKING CHANGE: <description of what breaks and how to migrate>
+#   Fixes: #<issue>
+#   Refs: #<issue>, <commit-sha>
+#   Reviewed-by: Name <email>
+#   Co-authored-by: Name <email>
+
+# SPDX-FileCopyrightText: 2026 Dennis Fink <me+coding@dennisfink.me>
+#
+# SPDX-License-Identifier: BSD-3-Clause
diff --git a/.python-version b/.python-version
new file mode 100644
index 0000000..6324d40
--- /dev/null
+++ b/.python-version
@@ -0,0 +1 @@
+3.14
diff --git a/LICENSES/BSD-3-Clause.txt b/LICENSES/BSD-3-Clause.txt
new file mode 100644
index 0000000..092966d
--- /dev/null
+++ b/LICENSES/BSD-3-Clause.txt
@@ -0,0 +1,11 @@
+Copyright (c) 2026 Dennis Fink <me+coding@dennisfink.me>. 
+
+Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
+
+2. 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.
+
+3. Neither the name of the copyright holder 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 THE COPYRIGHT HOLDER OR CONTRIBUTORS 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.
diff --git a/README.md b/README.md
new file mode 100644
index 0000000..c93b843
--- /dev/null
+++ b/README.md
@@ -0,0 +1,382 @@
+<!--
+SPDX-FileCopyrightText: 2026 Dennis Fink <me+coding@dennisfink.me>
+
+SPDX-License-Identifier: BSD-3-Clause
+-->
+
+# duplicate-finder
+
+A command-line tool for finding duplicate files using metadata grouping and
+content hashes.
+
+Files are discovered recursively and first grouped by size and, by default,
+file extension. Paths in each candidate set are also grouped by filesystem
+identity so hard links can be handled efficiently. Only remaining candidates
+are hashed to identify files with matching contents.
+
+## Installation
+
+```bash
+pip install duplicate-finder
+```
+
+## Usage
+
+```text
+Usage: duplicate-finder [OPTIONS] [PATHS]...
+
+  Scan paths and list duplicate files.
+
+  Files are first grouped into candidate sets by size and, by default,
+  case-insensitive file extension. --exclude-file-extension groups candidates
+  by size only. Candidate files are then hashed to identify matching content.
+
+Options:
+  --read-from FILE                Read files and directories to scan from FILE,
+                                  one path per line. Use '-' for standard
+                                  input. When set, positional paths are
+                                  ignored.
+  --follow-symlinks / --no-follow-symlinks
+                                  Follow symlinks when scanning directories.
+  -H, --include-hardlinks / --exclude-hardlinks
+                                  Include hard links in duplicate results, so
+                                  multiple paths to the same underlying file
+                                  may be listed as duplicates.
+  -G, --minsize SIZE              Consider only files >= SIZE bytes. Supports
+                                  suffixes such as 10M, 1G, and 500K.
+  -L, --maxsize SIZE              Consider only files <= SIZE bytes. Supports
+                                  suffixes such as 10M, 1G, and 500K.
+  --include-empty / --exclude-empty
+                                  Include files that are 0 bytes in size.
+  --include-file-extension / --exclude-file-extension
+                                  Include file extensions when grouping
+                                  duplicate candidates. Enabled by default;
+                                  excluding extensions groups candidates by
+                                  size only.
+  --hash HASH                     Select which hash function to use.
+                                  [default: xxh128]
+  -j, --jobs INTEGER              Maximum number of worker threads
+                                  (0 = use default).
+  -o, --output-format [human|plain|table|json]
+                                  Select the output format for duplicate
+                                  groups. 'human' shows a readable text list,
+                                  'plain' prints each duplicate group as a
+                                  space-separated line, 'table' prints a
+                                  column-aligned overview, and 'json' outputs
+                                  machine-readable structured data.
+                                  [default: human]
+  -S, --size                      Show size of duplicate files
+                                  (human/plain/table output only).
+  --human-readable / --no-human-readable
+                                  Display file sizes in human-readable form.
+  -q, --quiet                     Suppress all non-error output.
+  -v, --verbose                   Enable verbose output.
+  --color [auto|always|never]     Control colorized output.
+  --no-color                      Disable colorized output.
+  --version                       Show the version and exit.
+  -h, --help, -?                  Show this message and exit.
+```
+
+If no path is specified, the current directory is scanned.
+
+## Duplicate detection
+
+Duplicate detection is split into inexpensive candidate selection followed by
+content hashing.
+
+Files are initially grouped by:
+
+- file size
+- case-insensitive file extension
+
+Groups that cannot contain duplicates are discarded before their contents are
+hashed.
+
+File extensions can be excluded from candidate grouping with
+`--exclude-file-extension`. In that case, files are grouped by size alone. This
+allows identical files with different or incorrect extensions to be detected,
+at the cost of potentially hashing more files.
+
+Hard links are recognized by filesystem identity. By default, multiple paths
+referring to the same file are treated as one file and are not reported as
+duplicates of each other. Use `--include-hardlinks` to include those paths in
+duplicate groups.
+
+## Input
+
+One or more files or directories can be supplied as positional arguments:
+
+```bash
+duplicate-finder ~/Documents ~/Downloads
+```
+
+Directories are scanned recursively.
+
+If no paths are supplied, `duplicate-finder` scans the current directory:
+
+```bash
+duplicate-finder
+```
+
+Paths can also be read from a file using `--read-from`. The file must contain
+one path per line:
+
+```bash
+duplicate-finder --read-from paths.txt
+```
+
+Use `-` to read paths from standard input:
+
+```bash
+find /data -type d -print | duplicate-finder --read-from -
+```
+
+When `--read-from` is used, positional paths are ignored.
+
+## File selection
+
+Empty files are excluded by default. Include them with:
+
+```bash
+duplicate-finder --include-empty
+```
+
+Limit duplicate detection to files at least a certain size:
+
+```bash
+duplicate-finder --minsize 10M /data
+```
+
+Or set an upper limit:
+
+```bash
+duplicate-finder --maxsize 1G /data
+```
+
+The two options can be combined:
+
+```bash
+duplicate-finder --minsize 10M --maxsize 1G /data
+```
+
+Size suffixes such as `K`, `M`, and `G` are supported.
+
+Symlinks are not followed by default. Enable symlink traversal with:
+
+```bash
+duplicate-finder --follow-symlinks /data
+```
+
+### Additional filtering
+
+`duplicate-finder` intentionally provides only a small set of file-selection
+options directly. For other criteria, use an appropriate external tool to
+select the paths and pass them to `duplicate-finder` with `--read-from`.
+
+For example, use `find` to consider only files modified within the last 30
+days:
+
+```bash
+find /data -type f -mtime -30 -print | duplicate-finder --read-from -
+```
+
+The same approach can be used for filtering by filename, modification time,
+ownership, permissions, or other filesystem metadata supported by the tool
+producing the path list.
+
+`--read-from` accepts one path per line, either from a file or from standard
+input.
+
+## Hash functions
+
+The hash function used for content comparison can be selected with `--hash`.
+
+The default is `xxh128`:
+
+```bash
+duplicate-finder --hash xxh128 /data
+```
+
+`xxh32` and `xxh64` are also supported, together with the hash algorithms
+available through Python's `hashlib` implementation.
+
+For example:
+
+```bash
+duplicate-finder --hash sha256 /data
+```
+
+## Parallel hashing
+
+Candidate files can be hashed using multiple worker threads.
+
+By default, `--jobs=0` lets the application use its default worker count:
+
+```bash
+duplicate-finder /data
+```
+
+Set an explicit maximum number of workers with:
+
+```bash
+duplicate-finder --jobs 4 /data
+```
+
+## Output formats
+
+Four output formats are available.
+
+### Human
+
+`human` is the default format and is intended for interactive use:
+
+```bash
+duplicate-finder /data
+```
+
+### Plain
+
+`plain` prints each duplicate group as a space-separated line and is intended
+for further command-line processing:
+
+```bash
+duplicate-finder --output-format plain /data
+```
+
+The short form is:
+
+```bash
+duplicate-finder -o plain /data
+```
+
+### Table
+
+`table` displays duplicate groups in a column-aligned overview:
+
+```bash
+duplicate-finder --output-format table /data
+```
+
+### JSON
+
+`json` provides machine-readable structured output:
+
+```bash
+duplicate-finder --output-format json /data
+```
+
+For example, it can be passed directly to `jq`:
+
+```bash
+duplicate-finder -o json /data | jq
+```
+
+## File sizes
+
+Use `--size` to include the size of duplicate files in human, plain, and table
+output:
+
+```bash
+duplicate-finder --size /data
+```
+
+The short form is:
+
+```bash
+duplicate-finder -S /data
+```
+
+Combine it with `--human-readable` to display sizes in a human-readable form:
+
+```bash
+duplicate-finder --size --human-readable /data
+```
+
+## Examples
+
+Find duplicates in the current directory:
+
+```bash
+duplicate-finder
+```
+
+Scan several locations:
+
+```bash
+duplicate-finder ~/Documents ~/Downloads
+```
+
+Detect identical files even when their extensions differ:
+
+```bash
+duplicate-finder --exclude-file-extension /data
+```
+
+Include hard links in duplicate groups:
+
+```bash
+duplicate-finder --include-hardlinks /data
+```
+
+Include empty files:
+
+```bash
+duplicate-finder --include-empty /data
+```
+
+Search only files between 1 MiB and 1 GiB:
+
+```bash
+duplicate-finder --minsize 1M --maxsize 1G /data
+```
+
+Use SHA-256 instead of the default xxh128 hash:
+
+```bash
+duplicate-finder --hash sha256 /data
+```
+
+Hash candidates using at most eight worker threads:
+
+```bash
+duplicate-finder --jobs 8 /data
+```
+
+Produce plain output including human-readable file sizes:
+
+```bash
+duplicate-finder --output-format plain --size --human-readable /data
+```
+
+Read the paths to scan from standard input:
+
+```bash
+printf '%s\n' ~/Documents ~/Downloads | duplicate-finder --read-from -
+```
+
+## Exit status
+
+The command exits successfully after duplicate results have been rendered.
+
+If no duplicates are found, non-JSON output formats print:
+
+```text
+No duplicates found!
+```
+
+and exit with status `2`.
+
+JSON output instead renders the empty result normally.
+
+## Environment
+
+`duplicate-finder` respects the
+[NO_COLOR](https://no-color.org/) convention.
+
+Set `DEBUG` to `1`, `true`, or `yes` to enable diagnostic output describing the
+effective configuration, candidate grouping, duplicate detection, and output
+rendering.
+
+## License
+
+BSD-3-Clause. See [LICENSE](LICENSES/BSD-3-Clause.txt) for details.
diff --git a/duplicate_finder/__init__.py b/duplicate_finder/__init__.py
new file mode 100644
index 0000000..b99c0ca
--- /dev/null
+++ b/duplicate_finder/__init__.py
@@ -0,0 +1,330 @@
+# SPDX-FileCopyrightText: 2026 Dennis Fink <me+coding@dennisfink.me>
+#
+# SPDX-License-Identifier: BSD-3-Clause
+
+###############################################################################
+# DESCRIPTION
+#     This script scans one or more paths and identifies duplicate files.
+#     Candidates are grouped by size and file extension before their contents
+#     are hashed. The output can be rendered as human-readable text, plain text,
+#     a table, or structured JSON.
+#
+# NOTES
+#     This script respects the NO_COLOR standard (https://no-color.org/).
+#
+# AUTHOR
+#     Dennis Fink <me+coding@dennisfink.me>
+###############################################################################
+
+"""Provide the command-line interface for finding duplicate files.
+
+Files are discovered recursively and grouped into candidate sets by size and,
+by default, file extension. Paths in each candidate set are also grouped by
+filesystem identity so hard links can be handled efficiently. Candidate files
+are then hashed to identify matching content.
+"""
+
+import hashlib
+import os
+from pathlib import Path
+from typing import TextIO
+
+import click_extra as click
+
+from . import output
+from .cli import ByteSizeParamType, FlexibleColorOption, debug, msg
+from .hash import group_files_by_hash
+from .scanner import group_file_candidates, iter_files_from_paths
+
+VERSION = "1.0.0"
+DESCRIPTION = "Find duplicate files using metadata grouping and content hashes."
+DATE_OF_CREATION = "2017-04-23"
+DATE_OF_REVISION = "2026-09-20"
+AUTHOR = "Dennis Fink <me+coding@dennisfink.me>"
+LICENSE = "BSD-3-Clause"
+
+
+def print_version(
+    ctx: click.Context, param: click.Parameter | None, value: bool
+) -> None:
+    """Print script metadata and exit.
+
+    :param ctx: Click context associated with the currently running command.
+    :param param: Click parameter that triggered the callback, if available.
+    :param value: Whether the version option was supplied.
+    """
+    if not value or ctx.resilient_parsing:
+        return
+
+    click.echo(click.style("Scriptname:", fg="red", bold=True) + f" {ctx.info_name}")
+    click.echo(click.style("Version:", fg="green", bold=True) + f" {VERSION}")
+    click.echo(click.style("Description:", fg="yellow", bold=True) + f" {DESCRIPTION}")
+    click.echo(click.style("Author:", fg="blue", bold=True) + f" {AUTHOR}")
+    click.echo(
+        click.style("Date of creation:", fg="magenta", bold=True)
+        + f" {DATE_OF_CREATION}"
+    )
+    click.echo(
+        click.style("Date of revision:", fg="cyan", bold=True) + f" {DATE_OF_REVISION}"
+    )
+    click.echo(click.style("License:", fg="red", bold=True) + f" {LICENSE}")
+
+    click.echo("""Copyright (c) 2026 Dennis Fink <me+coding@dennisfink.me>.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+list of conditions and the following disclaimer.
+
+2. 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.
+
+3. Neither the name of the copyright holder 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 THE COPYRIGHT HOLDER OR CONTRIBUTORS 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.""")
+
+    ctx.exit()
+
+
+@click.command(
+    context_settings={"help_option_names": ("-h", "--help", "-?")}, params=[]
+)
+@click.option(
+    "--read-from",
+    type=click.File("r", encoding="utf-8"),
+    metavar="FILE",
+    help=(
+        "Read files and directories to scan from FILE, one path per line. "
+        "Use '-' for standard input. When set, positional paths are ignored."
+    ),
+)
+@click.option(
+    "--follow-symlinks/--no-follow-symlinks",
+    "follow_symlinks_flag",
+    default=False,
+    help="Follow symlinks when scanning directories.",
+)
+@click.option(
+    "-H",
+    "--include-hardlinks/--exclude-hardlinks",
+    "hardlinks_flag",
+    default=False,
+    help=(
+        "Include hard links in duplicate results, so multiple paths to the same "
+        "underlying file may be listed as duplicates."
+    ),
+)
+@click.option(
+    "-G",
+    "--minsize",
+    type=ByteSizeParamType(),
+    help="Consider only files >= SIZE bytes (supports suffixes like 10M, 1G, 500K).",
+)
+@click.option(
+    "-L",
+    "--maxsize",
+    type=ByteSizeParamType(),
+    help="Consider only files <= SIZE bytes (supports suffixes like 10M, 1G, 500K).",
+)
+@click.option(
+    "--include-empty/--exclude-empty",
+    "include_empty_flag",
+    default=False,
+    help="Include files that are 0 bytes in size.",
+)
+@click.option(
+    "--include-file-extension/--exclude-file-extension",
+    "include_file_extension_flag",
+    default=True,
+    help=(
+        "Include file extensions when grouping duplicate candidates. "
+        "Enabled by default; excluding extensions groups candidates by size only."
+    ),
+)
+@click.option(
+    "--hash",
+    "hash_func_name",
+    default="xxh128",
+    help="Select which hash function to use. Default xxh128.",
+    type=click.Choice(
+        sorted(["xxh32", "xxh64", "xxh128"] + list(hashlib.algorithms_available))
+    ),
+)
+@click.option(
+    "-j",
+    "--jobs",
+    default=0,
+    help="Maximum number of worker threads (0 = use default).",
+    type=click.IntRange(min=0),
+)
+@click.option(
+    "-o",
+    "--output-format",
+    default="human",
+    help=(
+        "Select the output format for duplicate groups. "
+        "'human' shows a readable text list, "
+        "'plain' prints each duplicate group as a space-separated line, "
+        "'table' prints a column-aligned overview, "
+        "and 'json' outputs machine-readable structured data."
+    ),
+    type=click.Choice(output.OUTPUTS.keys(), case_sensitive=False),
+)
+@click.option(
+    "-S",
+    "--size",
+    "show_size_flag",
+    is_flag=True,
+    default=False,
+    help="Show size of duplicate files (human/plain/table output only).",
+)
+@click.option(
+    "--human-readable/--no-human-readable", "human_readable_flag", default=False
+)
+@click.option(
+    "-q",
+    "--quiet",
+    "quiet_flag",
+    is_flag=True,
+    default=False,
+    help="Suppress all non-error output.",
+)
+@click.option(
+    "-v",
+    "--verbose",
+    "verbose_flag",
+    is_flag=True,
+    default=False,
+    help="Enable verbose output.",
+)
+@click.option("--color", cls=FlexibleColorOption)
+@click.no_color_option()
+@click.option(
+    "--version",
+    callback=print_version,
+    default=False,
+    expose_value=False,
+    help="Show the version and exit.",
+    is_eager=True,
+    is_flag=True,
+)
+@click.argument(
+    "paths",
+    type=click.Path(
+        exists=True, file_okay=True, dir_okay=True, readable=True, path_type=Path
+    ),
+    nargs=-1,
+)
+@click.pass_context
+def duplicate_finder(
+    ctx: click.Context,
+    paths: tuple[Path] | None = None,
+    read_from: TextIO | None = None,
+    follow_symlinks_flag: bool = False,
+    hardlinks_flag: bool = False,
+    minsize: int | None = None,
+    maxsize: int | None = None,
+    include_empty_flag: bool = False,
+    include_file_extension_flag: bool = True,
+    hash_func_name: str = "xxh128",
+    jobs: int = 0,
+    output_format: str = "human",
+    show_size_flag: bool = False,
+    human_readable_flag: bool = False,
+    quiet_flag: bool = False,
+    verbose_flag: bool = False,
+) -> None:
+    """Scan paths and list duplicate files.
+
+    Files are first grouped into candidate sets by size and, by default,
+    case-insensitive file extension. ``--exclude-file-extension`` groups
+    candidates by size only. Candidate files are then hashed to identify
+    matching content.
+    """
+    ctx.ensure_object(dict)
+    ctx.obj["debug"] = os.environ.get("DEBUG", "").lower() in ("1", "true", "yes")
+    ctx.obj["quiet"] = quiet_flag
+    ctx.obj["verbose"] = verbose_flag
+
+    debug("Effective configuration:", err=True)
+    debug("  paths:", ", ".join(str(p) for p in paths) if paths else ".", err=True)
+    debug(
+        "  read_from:",
+        str(read_from.name) if read_from is not None else str(read_from),
+        err=True,
+    )
+    debug("  follow_symlinks:", str(follow_symlinks_flag), err=True)
+    debug("  hardlinks:", str(hardlinks_flag), err=True)
+    debug("  minsize:", str(minsize), err=True)
+    debug("  maxsize:", str(maxsize), err=True)
+    debug("  include_empty:", str(include_empty_flag), err=True)
+    debug("  include_file_extension:", str(include_file_extension_flag), err=True)
+    debug("  hash:", str(hash_func_name), err=True)
+    debug("  jobs:", "default" if jobs == 0 else str(jobs), err=True)
+    debug("  output_format:", str(output_format), err=True)
+    debug("  size:", str(show_size_flag), err=True)
+    debug("  human_readable:", str(human_readable_flag), err=True)
+    debug("  quiet:", str(quiet_flag), err=True)
+    debug("  verbose:", str(verbose_flag), err=True)
+
+    if read_from is not None:
+        input_paths = (
+            Path(path) for line in read_from if (path := line.rstrip("\r\n"))
+        )
+    else:
+        input_paths = iter(paths or (Path("."),))
+
+    candidate_files = group_file_candidates(
+        iter_files_from_paths(input_paths, follow_symlinks=follow_symlinks_flag),
+        minsize=minsize,
+        maxsize=maxsize,
+        include_empty=include_empty_flag,
+        include_file_extension=include_file_extension_flag,
+        include_hardlinks=hardlinks_flag,
+    )
+    debug(
+        "Candidate grouping complete:",
+        f"{len(candidate_files)} candidate groups remain for hashing.",
+        err=True,
+    )
+
+    hash_groups = group_files_by_hash(
+        candidate_files,
+        include_hardlinks=hardlinks_flag,
+        hash_name=hash_func_name,
+        jobs=jobs,
+    )
+
+    if ctx.obj["debug"]:
+        duplicate_paths = sum(len(files) for files in hash_groups.values())
+        debug(
+            "Duplicate detection complete:",
+            f"{len(hash_groups)} groups containing {duplicate_paths} paths.",
+            err=True,
+        )
+
+    if not hash_groups and output_format != "json":
+        msg("No duplicates found!", err=True)
+        ctx.exit(2)
+
+    debug(f"Rendering results using {output_format!r} output.", err=True)
+    output.OUTPUTS[output_format](hash_groups, show_size_flag, human_readable_flag)
+
+    ctx.exit()
+
+
+if __name__ == "__main__":
+    duplicate_finder()
diff --git a/duplicate_finder/__main__.py b/duplicate_finder/__main__.py
new file mode 100644
index 0000000..bb3027a
--- /dev/null
+++ b/duplicate_finder/__main__.py
@@ -0,0 +1,9 @@
+# SPDX-FileCopyrightText: 2026 Dennis Fink <me+coding@dennisfink.me>
+#
+# SPDX-License-Identifier: BSD-3-Clause
+
+"""Run the duplicate-file finder when the package is executed as a module."""
+
+from . import duplicate_finder
+
+duplicate_finder()
diff --git a/duplicate_finder/cli.py b/duplicate_finder/cli.py
new file mode 100644
index 0000000..e1bc4f9
--- /dev/null
+++ b/duplicate_finder/cli.py
@@ -0,0 +1,234 @@
+# SPDX-FileCopyrightText: 2026 Dennis Fink <me+coding@dennisfink.me>
+#
+# SPDX-License-Identifier: BSD-3-Clause
+
+"""Define Click parameter types and styled terminal message helpers."""
+
+import re
+from collections.abc import Callable
+from functools import update_wrapper
+from typing import Any, Concatenate
+
+import click_extra as click
+from click_extra.color import ColorOption
+
+_SIZE_RE = re.compile(
+    r"^\s*(?P<value>\d+\.?\d*)\s*((?P<unit>[kmgtpe]i?)?)b?\s*$", re.IGNORECASE
+)
+_SIZE_MULTIPLIERS = {
+    "": 1,
+    "k": 1000,
+    "ki": 1024,
+    "m": 1000**2,
+    "mi": 1024**2,
+    "g": 1000**3,
+    "gi": 1024**3,
+    "t": 1000**4,
+    "ti": 1024**4,
+    "p": 1000**5,
+    "pi": 1024**5,
+    "e": 1000**6,
+    "ei": 1024**6,
+}
+
+
+class ByteSizeParamType(click.ParamType):
+    """Parse byte sizes with optional decimal or binary unit suffixes."""
+
+    name = "size"
+
+    def convert(
+        self, value: Any, param: click.Parameter | None, ctx: click.Context | None
+    ) -> int:
+        """Convert a Click parameter value to a size in bytes.
+
+        :param value: Value supplied by Click.
+        :param param: Parameter currently being converted, if available.
+        :param ctx: Active Click context, if available.
+        :returns: The parsed size in bytes.
+        :raises click.BadParameter: If the value is negative, has an unsupported type,
+            or cannot be parsed as a byte size.
+        """
+        if isinstance(value, int):
+            if value < 0:
+                self.fail("Size must be non-negative.", param, ctx)
+            return value
+
+        if not isinstance(value, str):
+            self.fail("Size must be a string like '10M' or an integer.", param, ctx)
+
+        if (match := _SIZE_RE.match(value)) is not None:
+            groups = match.groupdict()
+            return round(
+                float(groups["value"]) * _SIZE_MULTIPLIERS[groups["unit"].lower()]
+            )
+        else:
+            self.fail(f"Invalid size: {value!r}", param, ctx)
+
+
+class FlexibleColorOption(ColorOption):
+    """Allow the color option value to be passed with or without ``=``."""
+
+    _gnu_optional_value = False
+
+
+def pass_obj_silent[T, **P, R](
+    f: Callable[Concatenate[T | None, P], R],
+) -> Callable[P, R]:
+    """Pass the current context object to a callback, if available.
+
+    The current Click context is retrieved silently. If no context exists or
+    its object is not a dictionary, ``None`` is passed instead.
+
+    The context object is inserted as the first positional argument to *f*.
+    """
+
+    def new_func(*args: P.args, **kwargs: P.kwargs) -> R:
+        ctx = click.get_current_context(silent=True)
+        obj = ctx.obj if ctx is not None else None
+        return f(obj, *args, **kwargs)
+
+    return update_wrapper(new_func, f)
+
+
+def emit(
+    prefix: str, color: str, *message: str, enabled: bool = True, err: bool = False
+) -> None:
+    """Render a styled prefix and message to stdout.
+
+    This helper is used by :func:`error`, :func:`msg`, :func:`warn`,
+    :func:`verbose`, and :func:`debug`. The first message argument is rendered in
+    bold and subsequent arguments are appended unstyled.
+
+    :param prefix: Prefix displayed before the message.
+    :param color: Click-compatible color name applied to the prefix.
+    :param message: One or more message parts to display.
+    :param enabled: Whether the message should be emitted.
+    :param err: Write to `stderr` instead of `stdout`.
+    :raises TypeError: If no message arguments are provided.
+    """
+    if not message:
+        raise TypeError("emit() missing 1 required positional argument: 'message'")
+
+    if not enabled:
+        return
+
+    click.echo(
+        " ".join(
+            [
+                click.style(prefix, fg=color, bold=True),
+                click.style(message[0], bold=True),
+                *message[1:],
+            ]
+        ),
+        err=err,
+    )
+
+
+def error(*message: str) -> None:
+    """Print a formatted error message to stdout in red.
+
+    The first argument is rendered in bold and subsequent arguments are appended
+    unstyled. Error messages are always printed regardless of quiet or verbose
+    flags.
+
+    :param message: One or more message parts to display.
+    """
+    emit("==> ERROR:", "red", *message, err=True)
+
+
+@pass_obj_silent
+def msg(obj: dict[str, Any] | None, *message: str, err: bool = False) -> None:
+    """Print a formatted informational message to stdout in green.
+
+    The message is suppressed when the quiet flag is set. When called outside a
+    Click context, the message is emitted normally. The first argument is rendered
+    in bold and subsequent arguments are appended unstyled.
+
+    :param message: One or more message parts to display.
+    """
+    emit(
+        "==>",
+        "green",
+        *message,
+        enabled=obj is None or not obj.get("quiet", False),
+        err=err,
+    )
+
+
+@pass_obj_silent
+def warn(obj: dict[str, Any] | None, *message: str, err: bool = False) -> None:
+    """Print a formatted warning message to stdout in yellow.
+
+    The message is suppressed when the quiet flag is set. When called outside a
+    Click context, the message is emitted normally. The first argument is rendered
+    in bold and subsequent arguments are appended unstyled.
+
+    :param message: One or more message parts to display.
+    """
+    emit(
+        "==>",
+        "yellow",
+        *message,
+        enabled=obj is None or not obj.get("quiet", False),
+        err=err,
+    )
+
+
+@pass_obj_silent
+def verbose(obj: dict[str, Any] | None, *message: str, err: bool = False) -> None:
+    """Print a formatted verbose message to stdout in blue.
+
+    The message is printed only when called from a Click context with the verbose
+    flag set and the quiet flag unset. Calls made outside a Click context are a
+    no-op.
+
+    :param message: One or more message parts to display.
+    """
+    emit(
+        "==>",
+        "blue",
+        *message,
+        enabled=(
+            obj is not None
+            and obj.get("verbose", False)
+            and not obj.get("quiet", False)
+        ),
+        err=err,
+    )
+
+
+@pass_obj_silent
+def debug(obj: dict[str, Any] | None, *message: str, err: bool = False) -> None:
+    """Print a formatted debug message to stdout in magenta.
+
+    The message is printed only when called from a Click context with the debug
+    flag enabled. Calls made outside a Click context are a no-op.
+
+    :param message: One or more message parts to display.
+    """
+    emit(
+        "==>",
+        "magenta",
+        *message,
+        enabled=obj is not None and obj.get("debug", False),
+        err=err,
+    )
+
+
+@pass_obj_silent
+def is_debug_enabled(obj: dict[str, Any] | None) -> bool:
+    """Return whether debug output is enabled for the active Click context.
+
+    :returns: ``True`` when a Click context exists and its debug flag is enabled.
+    """
+    return obj is not None and obj.get("debug", False)
+
+
+@pass_obj_silent
+def is_quiet_enabled(obj: dict[str, Any] | None) -> bool:
+    """Return whether quiet output is enabled for the active Click context.
+
+    :returns: ``True`` when a Click context exists and its quiet flag is enabled.
+    """
+    return obj is not None and obj.get("quiet", False)
diff --git a/duplicate_finder/hash.py b/duplicate_finder/hash.py
new file mode 100644
index 0000000..473ee98
--- /dev/null
+++ b/duplicate_finder/hash.py
@@ -0,0 +1,174 @@
+# SPDX-FileCopyrightText: 2026 Dennis Fink <me+coding@dennisfink.me>
+#
+# SPDX-License-Identifier: BSD-3-Clause
+
+"""Hash candidate files and group paths with identical content."""
+
+import concurrent.futures
+import hashlib
+import sys
+from collections import defaultdict
+from collections.abc import Callable
+from functools import partial
+from pathlib import Path
+from typing import Any
+
+import xxhash
+from tqdm import tqdm
+
+from duplicate_finder.cli import debug, is_debug_enabled, is_quiet_enabled
+
+from .types import FileInfo, FilesByCandidateGroup, FilesByHash, FileSet
+
+
+def compute_hash(path: Path, digest: str | Callable[[], Any]) -> str:
+    """Compute a content hash using the supplied digest.
+
+    The file is opened in binary mode and streamed through
+    :func:`hashlib.file_digest`. For extendable-output algorithms whose
+    ``hexdigest`` method requires an explicit output length, a 32-byte digest
+    is requested.
+
+    :param path: Path to the file whose contents should be hashed.
+    :param digest: Hash algorithm name or callable that creates a hash object.
+    :returns: The hexadecimal digest of the file contents.
+    """
+    with path.open("rb") as f:
+        digested = hashlib.file_digest(f, digest)
+
+    try:
+        return digested.hexdigest()
+    except TypeError:
+        return digested.hexdigest(length=32)
+
+
+def select_representative_files(
+    files_by_candidate_group: FilesByCandidateGroup, *, include_hardlinks: bool
+) -> dict[FileInfo, FileSet]:
+    """Select one file to hash for each filesystem identity.
+
+    Candidate groups have already been reduced to groups that can contain
+    duplicates. Each filesystem identity contributes one representative file.
+    When hard links are included, that representative stands for every scanned
+    path belonging to the identity; otherwise it represents only itself.
+
+    :param files_by_candidate_group: Files grouped into duplicate-candidate sets
+        and then by filesystem identity.
+    :param include_hardlinks: Whether different paths referring to the same inode
+        should be treated as duplicate files.
+    :returns: Representative files mapped to the paths they represent.
+    """
+    representative_files: dict[FileInfo, FileSet] = {}
+
+    for files_by_identity in files_by_candidate_group.values():
+        for files in files_by_identity.values():
+            representative = next(iter(files))
+            representative_files[representative] = (
+                files if include_hardlinks else {representative}
+            )
+
+    return representative_files
+
+
+def select_hash_function(name: str) -> Callable[[Path], str]:
+    """Return the file-hashing callable for a named digest algorithm.
+
+    :param name: Name of an xxHash variant or an algorithm available through
+        :mod:`hashlib`.
+    :returns: A callable that accepts a file path and returns its hexadecimal digest.
+    :raises KeyError: If ``name`` is not a supported hash algorithm.
+    """
+    hash_funcs = {
+        "xxh32": partial(compute_hash, digest=xxhash.xxh32),
+        "xxh64": partial(compute_hash, digest=xxhash.xxh64),
+        "xxh128": partial(compute_hash, digest=xxhash.xxh128),
+    }
+    for digest in hashlib.algorithms_available:
+        hash_funcs[digest] = partial(compute_hash, digest=digest)
+
+    return hash_funcs[name]
+
+
+def group_files_by_hash(
+    files_by_candidate_group: FilesByCandidateGroup,
+    *,
+    include_hardlinks: bool = False,
+    hash_name: str = "xxh128",
+    jobs: int = 0,
+) -> FilesByHash:
+    """Group duplicate candidates by content hash.
+
+    Only one representative of each filesystem identity is hashed. Hash
+    computation is parallelized using :class:`ThreadPoolExecutor`, and hash
+    groups containing only one represented path are discarded before returning.
+
+    :param files_by_candidate_group: Files grouped into duplicate-candidate sets
+        and then by filesystem identity. Candidate sets are normally based on
+        file size and extension, or file size alone when extension grouping is
+        disabled.
+    :param include_hardlinks: Whether multiple paths referring to the same inode
+        should be included as separate duplicate paths.
+    :param hash_name: Name of the hash algorithm to use. This may be an xxHash
+        variant or any algorithm exposed by :mod:`hashlib`.
+    :param jobs: Maximum number of worker threads to use for hash computation.
+        If set to ``0``, the default chosen by :class:`ThreadPoolExecutor` is used.
+    :returns: A mapping from digest strings to sets of files sharing the same
+        content hash. Singleton hash groups are omitted.
+    """
+    representative_files = select_representative_files(
+        files_by_candidate_group, include_hardlinks=include_hardlinks
+    )
+
+    if is_debug_enabled():
+        represented_paths = sum(len(files) for files in representative_files.values())
+        debug(
+            "Hash candidate selection:",
+            f"{len(representative_files)} representative files for "
+            f"{represented_paths} paths.",
+            err=True,
+        )
+
+    if not representative_files:
+        return {}
+
+    hash_function = select_hash_function(hash_name)
+    max_workers = None if jobs == 0 else jobs
+    hash_groups: defaultdict[str, FileSet] = defaultdict(set)
+
+    with concurrent.futures.ThreadPoolExecutor(max_workers=max_workers) as executor:
+        future_to_file = {
+            executor.submit(hash_function, file.path): file
+            for file in representative_files
+        }
+        for future in tqdm(
+            concurrent.futures.as_completed(future_to_file),
+            total=len(future_to_file),
+            desc="Hashing files",
+            unit="file",
+            dynamic_ncols=True,
+            disable=is_quiet_enabled() or not sys.stderr.isatty(),
+        ):
+            file = future_to_file[future]
+            try:
+                hashsum = future.result()
+            except FileNotFoundError:
+                debug(f"Skipping disappeared file: {file.path.absolute()}", err=True)
+                continue
+            except PermissionError:
+                debug(f"Skipping inaccessible file: {file.path.absolute()}", err=True)
+                continue
+
+            hash_groups[hashsum].update(representative_files[file])
+
+    duplicate_groups = {
+        hashsum: files for hashsum, files in hash_groups.items() if len(files) > 1
+    }
+
+    debug(
+        "Hashing complete:",
+        f"{len(representative_files)} files produced "
+        f"{len(duplicate_groups)} duplicate hash groups.",
+        err=True,
+    )
+
+    return duplicate_groups
diff --git a/duplicate_finder/output.py b/duplicate_finder/output.py
new file mode 100644
index 0000000..c3b6307
--- /dev/null
+++ b/duplicate_finder/output.py
@@ -0,0 +1,136 @@
+# SPDX-FileCopyrightText: 2026 Dennis Fink <me+coding@dennisfink.me>
+#
+# SPDX-License-Identifier: BSD-3-Clause
+
+"""Render duplicate-file groups in terminal-friendly output formats."""
+
+import shlex
+from json import dumps as json_dumps
+
+import click_extra as click
+import humanize
+from tabulate import tabulate
+
+from .types import FilesByHash
+
+OUTPUTS = {}
+
+
+def register_output(f):
+    OUTPUTS[f.__name__] = f
+    return f
+
+
+@register_output
+def human(
+    duplicates: FilesByHash, show_size: bool = False, human_readable: bool = False
+) -> None:
+    """Print duplicate groups in a human-readable format.
+
+    :param duplicates: Hash digests mapped to files sharing each digest.
+    :param show_size: Whether to display the size of each duplicate group.
+    :param human_readable: Whether displayed sizes should use human-readable units.
+    """
+    for hash_digest, files in duplicates.items():
+        click.secho("Duplicate set ", fg="green", bold=True, nl=False)
+        click.secho("[", fg="magenta", bold=True, nl=False)
+        click.secho(hash_digest, fg="cyan", bold=True, nl=False)
+        click.secho("]", fg="magenta", bold=True, nl=False)
+
+        if show_size:
+            size = next(iter(files)).size
+            click.secho(" [", fg="magenta", bold=True, nl=False)
+            click.secho(
+                humanize.naturalsize(size) if human_readable else size,
+                fg="cyan",
+                bold=True,
+                nl=False,
+            )
+            click.secho("]", fg="magenta", bold=True, nl=False)
+
+        click.secho(":", fg="green", bold=True)
+
+        for file in files:
+            click.echo(f"  {file.path}")
+
+
+@register_output
+def plain(
+    duplicates: FilesByHash, show_size: bool = False, human_readable: bool = False
+) -> None:
+    """Print duplicate groups as shell-quoted, space-separated fields.
+
+    Each duplicate group is written on a separate line. The hash digest is the
+    first field, followed by the duplicate paths. If requested, the file size is
+    appended as the final field.
+
+    :param duplicates: Hash digests mapped to files sharing each digest.
+    :param show_size: Whether to append the size of each duplicate group.
+    :param human_readable: Whether displayed sizes should use human-readable units.
+    """
+    for hash_digest, files in duplicates.items():
+        fields = [hash_digest]
+        fields.extend(str(file.path) for file in files)
+
+        if show_size:
+            size = next(iter(files)).size
+            fields.append(humanize.naturalsize(size) if human_readable else str(size))
+
+        click.echo(shlex.join(fields))
+
+
+@register_output
+def table(
+    duplicates: FilesByHash, show_size: bool = False, human_readable: bool = False
+) -> None:
+    """Print duplicate groups as a column-aligned table.
+
+    :param duplicates: Hash digests mapped to files sharing each digest.
+    :param show_size: Whether to display the size of each duplicate group.
+    :param human_readable: Whether displayed sizes should use human-readable units.
+    """
+    rows = []
+    for hash_digest, files in duplicates.items():
+        for file in files:
+            if show_size:
+                rows.append(
+                    (
+                        click.style(hash_digest, fg="cyan"),
+                        file.path,
+                        humanize.naturalsize(file.size)
+                        if human_readable
+                        else file.size,
+                    )
+                )
+            else:
+                rows.append((click.style(hash_digest, fg="cyan"), file.path))
+
+    click.echo(tabulate(rows, tablefmt="plain"))
+
+
+@register_output
+def json(
+    duplicates: FilesByHash, show_size: bool = False, human_readable: bool = False
+) -> None:
+    """Print duplicate groups as JSON.
+
+    File paths are serialized as absolute strings. ``show_size`` is accepted for
+    the common output-function interface but does not change the JSON structure.
+
+    :param duplicates: Hash digests mapped to files sharing each digest.
+    :param show_size: Unused; accepted for consistency with other output formats.
+    :param human_readable: Whether the JSON should be pretty-printed.
+    """
+    json_config = {"separators": (",", ":"), "indent": 0, "sort_keys": False}
+
+    if human_readable:
+        json_config["separators"] = (",", ": ")
+        json_config["indent"] = 2
+        json_config["sort_keys"] = True
+
+    serialized_duplicates = {
+        hash_digest: [str(file.path.absolute()) for file in files]
+        for hash_digest, files in duplicates.items()
+    }
+
+    click.echo(json_dumps(serialized_duplicates, **json_config))
diff --git a/duplicate_finder/scanner.py b/duplicate_finder/scanner.py
new file mode 100644
index 0000000..29f7aef
--- /dev/null
+++ b/duplicate_finder/scanner.py
@@ -0,0 +1,239 @@
+# SPDX-FileCopyrightText: 2026 Dennis Fink <me+coding@dennisfink.me>
+#
+# SPDX-License-Identifier: BSD-3-Clause
+
+"""Discover files and group duplicate candidates by metadata and identity."""
+
+import sys
+from collections import defaultdict
+from collections.abc import Iterator
+from pathlib import Path
+
+from tqdm import tqdm
+
+from .cli import debug, error, is_debug_enabled, is_quiet_enabled
+from .types import FileIdentity, FileInfo, FilesByCandidateGroup
+
+
+def should_follow(path: Path, follow_symlinks: bool = False) -> bool:
+    """Return whether a filesystem entry should be followed.
+
+    Broken symbolic links are skipped and reported when symbolic-link following
+    is enabled.
+
+    :param path: Filesystem path to inspect.
+    :param follow_symlinks: Whether symbolic links should be followed.
+    :returns: ``True`` if the entry should be processed, otherwise ``False``.
+    """
+    if not path.is_symlink():
+        return True
+
+    if not follow_symlinks:
+        return False
+
+    if not path.exists():
+        error(f"{path.absolute()} is a broken symbolic link. Skipping.")
+        return False
+
+    return True
+
+
+def already_visited(path: Path, visited_paths: set[FileIdentity]) -> bool:
+    """Return whether a filesystem path has already been visited.
+
+    The path is identified by its device and inode so symbolic links to an
+    already visited directory are recognized as the same filesystem object.
+
+    :param path: Filesystem path to inspect.
+    :param visited_paths: Filesystem identities that have already been visited.
+    :returns: ``True`` if the path was already visited, otherwise ``False``.
+    """
+    stat = path.stat()
+    identity = (stat.st_dev, stat.st_ino)
+
+    if identity in visited_paths:
+        return True
+
+    visited_paths.add(identity)
+    return False
+
+
+def iter_files_recursively(
+    paths: Iterator[Path],
+    *,
+    follow_symlinks: bool = False,
+    visited_paths: set[FileIdentity],
+) -> Iterator[FileInfo]:
+    """Yield regular files and their metadata below the supplied paths.
+
+    Metadata required by later stages is collected when each regular file is
+    discovered and carried forward with the path so candidate grouping and
+    hashing do not need to inspect the file again.
+
+    :param paths: File and directory paths to inspect.
+    :param follow_symlinks: Whether symbolic links to files and directories should
+        be followed.
+    :param visited_paths: Filesystem identities of directories already traversed.
+    :yields: Regular files discovered while scanning the supplied paths, together
+        with the metadata needed by later stages.
+    """
+    for path in paths:
+        try:
+            if not should_follow(path, follow_symlinks):
+                continue
+
+            if path.is_dir():
+                if follow_symlinks and already_visited(path, visited_paths):
+                    debug(
+                        f"Skipping already visited directory: {path.absolute()}",
+                        err=True,
+                    )
+                    continue
+
+                try:
+                    yield from iter_files_recursively(
+                        path.iterdir(),
+                        follow_symlinks=follow_symlinks,
+                        visited_paths=visited_paths,
+                    )
+                except PermissionError:
+                    debug(
+                        f"Skipping inaccessible directory: {path.absolute()}", err=True
+                    )
+                    continue
+            elif path.is_file():
+                path_stat = path.stat()
+                yield FileInfo(
+                    path=path,
+                    size=path_stat.st_size,
+                    identity=(path_stat.st_dev, path_stat.st_ino),
+                )
+            else:
+                error(f"{path} is not a file or directory. Skipping!")
+        except FileNotFoundError:
+            debug(f"Skipping disappeared path: {path.absolute()}", err=True)
+            continue
+        except PermissionError:
+            debug(f"Skipping inaccessible path: {path.absolute()}", err=True)
+            continue
+
+
+def iter_files_from_paths(
+    paths: Iterator[Path], *, follow_symlinks: bool = False
+) -> Iterator[FileInfo]:
+    """Yield regular files and their metadata below the supplied paths.
+
+    Directories are traversed recursively in depth-first order. Permission
+    errors are ignored so scanning can continue with the remaining paths. When
+    symbolic links are followed, directories already visited through another
+    path are skipped to avoid recursion cycles.
+
+    :param paths: File and directory paths to inspect.
+    :param follow_symlinks: Whether symbolic links to files and directories
+        should be followed.
+    :yields: Regular files discovered while scanning the supplied paths, together
+        with the metadata needed by later stages.
+    """
+    visited_paths: set[FileIdentity] = set()
+
+    yield from iter_files_recursively(
+        paths, follow_symlinks=follow_symlinks, visited_paths=visited_paths
+    )
+
+
+def group_file_candidates(
+    files: Iterator[FileInfo],
+    *,
+    minsize: int | None = None,
+    maxsize: int | None = None,
+    include_empty: bool = True,
+    include_file_extension: bool = True,
+    include_hardlinks: bool = False,
+) -> FilesByCandidateGroup:
+    """Group files into candidate sets for duplicate detection.
+
+    Files are grouped by size and, by default, case-insensitive file extension.
+    Within each candidate group, files are grouped by filesystem identity so
+    hard links can share a single hash computation. Groups that cannot contain
+    duplicates are removed before hashing.
+
+    :param files: Files and metadata collected during discovery.
+    :param minsize: Minimum file size in bytes, or ``None`` for no lower limit.
+    :param maxsize: Maximum file size in bytes, or ``None`` for no upper limit.
+    :param include_empty: Whether zero-byte files should be included.
+    :param include_file_extension: Whether file extensions should be included
+        in the candidate-group key in addition to file size.
+    :param include_hardlinks: Whether different paths referring to the same inode
+        should count as separate duplicate candidates.
+    :returns: Files grouped into duplicate-candidate sets and then by filesystem
+        identity. Every returned candidate set can contain at least one duplicate.
+    """
+    files_by_candidate_group = defaultdict(lambda: defaultdict(set))
+    accepted = 0
+    filtered_by_size = 0
+
+    for file in tqdm(
+        files,
+        desc="Scanning files",
+        unit="file",
+        dynamic_ncols=True,
+        disable=is_quiet_enabled() or not sys.stderr.isatty(),
+    ):
+        if (
+            (not include_empty and file.size == 0)
+            or (minsize is not None and file.size < minsize)
+            or (maxsize is not None and file.size > maxsize)
+        ):
+            filtered_by_size += 1
+            continue
+
+        group_key = (
+            (file.size, file.path.suffix.casefold())
+            if include_file_extension
+            else file.size
+        )
+        files_by_candidate_group[group_key][file.identity].add(file)
+        accepted += 1
+
+    candidate_groups: FilesByCandidateGroup = {}
+    candidate_paths = 0
+
+    for group_key, files_by_identity in files_by_candidate_group.items():
+        candidate_count = (
+            sum(len(files) for files in files_by_identity.values())
+            if include_hardlinks
+            else len(files_by_identity)
+        )
+        if candidate_count < 2:
+            continue
+
+        candidate_groups[group_key] = files_by_identity
+        candidate_paths += sum(len(files) for files in files_by_identity.values())
+
+    debug(
+        "File scan summary:",
+        f"{accepted} accepted, {filtered_by_size} filtered by size; "
+        f"{candidate_paths} paths remain in {len(candidate_groups)} candidate groups.",
+        err=True,
+    )
+
+    if is_debug_enabled():
+        hardlinked_identity_count = 0
+        hardlinked_path_count = 0
+
+        for files_by_identity in candidate_groups.values():
+            for files in files_by_identity.values():
+                if len(files) < 2:
+                    continue
+                hardlinked_identity_count += 1
+                hardlinked_path_count += len(files)
+
+        debug(
+            "Hardlink summary:",
+            f"{hardlinked_path_count} paths across "
+            f"{hardlinked_identity_count} multiply referenced identities "
+            "in candidate groups.",
+            err=True,
+        )
+
+    return candidate_groups
diff --git a/duplicate_finder/types.py b/duplicate_finder/types.py
new file mode 100644
index 0000000..f2438d8
--- /dev/null
+++ b/duplicate_finder/types.py
@@ -0,0 +1,36 @@
+# SPDX-FileCopyrightText: 2026 Dennis Fink <me+coding@dennisfink.me>
+#
+# SPDX-License-Identifier: BSD-3-Clause
+
+"""Types used throughout the duplicate-file finder."""
+
+from collections import defaultdict
+from dataclasses import dataclass
+from pathlib import Path
+
+type FileIdentity = tuple[int, int]
+type FileSize = int
+type FileHash = str
+type FileExtension = str
+
+
+@dataclass(frozen=True, slots=True)
+class FileInfo:
+    """Store filesystem metadata collected while discovering a file.
+
+    :param path: Path through which the file was discovered.
+    :param size: File size in bytes.
+    :param identity: Filesystem identity as ``(device, inode)``.
+    """
+
+    path: Path
+    size: FileSize
+    identity: FileIdentity
+
+
+type FileSet = set[FileInfo]
+type FilesByIdentity = defaultdict[FileIdentity, FileSet]
+
+type CandidateGroupKey = FileSize | tuple[FileSize, FileExtension]
+type FilesByCandidateGroup = dict[CandidateGroupKey, FilesByIdentity]
+type FilesByHash = dict[FileHash, FileSet]
diff --git a/pyproject.toml b/pyproject.toml
new file mode 100644
index 0000000..f98785b
--- /dev/null
+++ b/pyproject.toml
@@ -0,0 +1,61 @@
+# SPDX-FileCopyrightText: 2026 Dennis Fink <me+coding@dennisfink.me>
+#
+# SPDX-License-Identifier: BSD-3-Clause
+
+[project]
+name = "duplicate-finder"
+dynamic = ["version"]
+description = "Find duplicate files by size and hash."
+license = "BSD-3-Clause"
+license-files = ["LICENSES/BSD-3-Clause.txt"]
+authors = [
+    { name = "Dennis Fink", email = "me+coding@dennisfink.me" }
+]
+readme = "README.md"
+requires-python = ">=3.14"
+dependencies = [
+    "click-extra>=9.1.0",
+    "humanize>=4.16.0",
+    "tabulate>=0.10.0",
+    "tqdm>=4.70.0",
+    "xxhash>=4.0.1",
+]
+classifiers = [
+  "Development Status :: 5 - Production/Stable",
+  "Programming Language :: Python",
+  "Programming Language :: Python :: 3.14",
+  "Environment :: Console",
+]
+
+[project.scripts]
+duplicate-finder = "duplicate_finder:duplicate_finder"
+
+[dependency-groups]
+dev = [
+    "pyright>=1.1.411",
+    "ruff>=0.16.6",
+]
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.version]
+path = "duplicate_finder/__init__.py"
+
+[tool.hatch.build.targets.wheel]
+packages = ["duplicate_finder"]
+
+[tool.hatch.build.targets.sdist]
+include = [
+  "duplicate_finder/",
+  "LICENSES/",
+  "README.md",
+  "pyproject.toml"
+]
+
+[tool.uv]
+default-groups = ["dev"]
+
+[tool.ruff.format]
+skip-magic-trailing-comma = true
diff --git a/uv.lock b/uv.lock
new file mode 100644
index 0000000..ed69f4a
--- /dev/null
+++ b/uv.lock
@@ -0,0 +1,328 @@
+version = 1
+revision = 3
+requires-python = ">=3.14"
+
+[[package]]
+name = "boltons"
+version = "26.2.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/71/56/14c4a4931910a81ddeccfbe227925ea738e3c445d3e2af960f0bcbba1616/boltons-26.2.0.tar.gz", hash = "sha256:d39cfd15c1a1c3bd4d705c82252fa9edb8e4f5e8cc039f8e39afac7b1b47e92c", size = 242047, upload-time = "2026-09-07T10:48:17.711Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/d2/ac/1f8e4f4855e382a67392ca3bba329cb93aba1e3039289c52a86bf337f7a2/boltons-26.2.0-py3-none-any.whl", hash = "sha256:41942cbce440211bbcf2487ccdc356964ad674f95a01068b8a0dd7a1d1fed036", size = 199536, upload-time = "2026-09-07T10:48:16.319Z" },
+]
+
+[[package]]
+name = "bracex"
+version = "3.0.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/ac/01/5f394b8bcd6e5b92f73130990960423bbb19711f906bd9fe9ea5557c667c/bracex-3.0.1.tar.gz", hash = "sha256:4e38e32392e4a4780fe15d644bfc7c8514057cfc3861e060b11814ce829c25e4", size = 44019, upload-time = "2026-07-20T13:43:00.335Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/b8/8f/6f7273a7adb8d73fc8d21ede4376a3e475e52f98435c6007f69100dec8ca/bracex-3.0.1-py3-none-any.whl", hash = "sha256:6523ad83aeb5098a4ee597cff0f964442ff74e460bd3fafaffab6a013ff2288c", size = 11940, upload-time = "2026-07-20T13:42:59.268Z" },
+]
+
+[[package]]
+name = "click"
+version = "8.5.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/c7/0e/7fa0ef50764b67090eca4114772a2abf8b6148198475e54c660b97caeee6/click-8.5.0.tar.gz", hash = "sha256:ba0d2089de75ea0310e2dde03160e6ca10009947fb95a182f9b54021bb272e34", size = 382235, upload-time = "2026-08-26T13:33:14.56Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/58/50/6c0d534c5f134586a8e1ba4e330569e32f057e33372ae556463212fb4cd3/click-8.5.0-py3-none-any.whl", hash = "sha256:255bc9599cf7748b4b1a446ccc735421bd08a2ae529a8b88597d3de5664ee360", size = 125251, upload-time = "2026-08-26T13:33:12.928Z" },
+]
+
+[[package]]
+name = "click-extra"
+version = "9.2.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "boltons" },
+    { name = "click" },
+    { name = "cloup" },
+    { name = "deepmerge" },
+    { name = "extra-platforms" },
+    { name = "tabulate", extra = ["widechars"] },
+    { name = "wcmatch" },
+    { name = "wcwidth" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/f9/a0/2a928545b870c3944ed53c836a7973db03ad31552df50987a42756869670/click_extra-9.2.0.tar.gz", hash = "sha256:33f253a1cb739cb4ee5ef31a25682f12d5905f5d4debfde4f81fcc4199a35fb5", size = 1644000, upload-time = "2026-09-15T04:13:23.045Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/12/3e/a2211558933530861bef3ad86a28f031dfcee09a21d9ff42e21156046450/click_extra-9.2.0-py3-none-any.whl", hash = "sha256:d1596d472be55b5153686617d0d905c66e7cb1e432ff16da92e89fd6483a9fae", size = 626100, upload-time = "2026-09-15T04:13:21.221Z" },
+]
+
+[[package]]
+name = "cloup"
+version = "4.0.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "click" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/05/e2/d41446c6195eff0db3b671ddb202e39f42f9ea7c0dd15cd43fbf5cf0d7f7/cloup-4.0.0.tar.gz", hash = "sha256:83b0870ee863bcc85129e40e1b208bcfdebe4cd2142e9ce1d0daf7d276cab038", size = 252135, upload-time = "2026-09-12T03:23:39.698Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/2c/34/20224fd9d52e8ce7e3b319b5d6b7126da25e89d00cd1a5692b4b46ed2d26/cloup-4.0.0-py3-none-any.whl", hash = "sha256:0678744a3a2753e1d78dd3ea5c6e4cbbc3b41561fd7a7a7d075dbc8dad74f74f", size = 55776, upload-time = "2026-09-12T03:23:38.564Z" },
+]
+
+[[package]]
+name = "colorama"
+version = "0.4.6"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/d8/53/6f443c9a4a8358a93a6792e2acffb9d9d5cb0a5cfd8802644b7b1c9a02e4/colorama-0.4.6.tar.gz", hash = "sha256:08695f5cb7ed6e0531a20572697297273c47b8cae5a63ffc6d6ed5c201be6e44", size = 27697, upload-time = "2022-10-25T02:36:22.414Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/d1/d6/3965ed04c63042e047cb6a3e6ed1a63a35087b6a609aa3a15ed8ac56c221/colorama-0.4.6-py2.py3-none-any.whl", hash = "sha256:4f1d9991f5acc0ca119f9d443620b77f9d6b33703e51011c16baf57afb285fc6", size = 25335, upload-time = "2022-10-25T02:36:20.889Z" },
+]
+
+[[package]]
+name = "deepmerge"
+version = "3.0.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/38/6e/5cb3548b4d3112fea529375e55e6f3cdc52b8054e3a66f203b1f888ba885/deepmerge-3.0.1.tar.gz", hash = "sha256:35b39a4cb92cf328d6eca61cbbf65f68a37c2ceb3085f0f853cbb2e52a59fc23", size = 22328, upload-time = "2026-09-01T14:09:44.383Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/20/91/600003aaad107e27553fbc9cbfc57e96fa37e0223d2ef9d7d3a0e8d8d070/deepmerge-3.0.1-py3-none-any.whl", hash = "sha256:35c96f6a68fcf90719a5b31d9f8042ecef6c00fb56836660d33455d0f5cfda65", size = 14909, upload-time = "2026-09-01T14:09:43.364Z" },
+]
+
+[[package]]
+name = "duplicate-finder"
+source = { editable = "." }
+dependencies = [
+    { name = "click-extra" },
+    { name = "humanize" },
+    { name = "tabulate" },
+    { name = "tqdm" },
+    { name = "xxhash" },
+]
+
+[package.dev-dependencies]
+dev = [
+    { name = "pyright" },
+    { name = "ruff" },
+]
+
+[package.metadata]
+requires-dist = [
+    { name = "click-extra", specifier = ">=9.1.0" },
+    { name = "humanize", specifier = ">=4.16.0" },
+    { name = "tabulate", specifier = ">=0.10.0" },
+    { name = "tqdm", specifier = ">=4.70.0" },
+    { name = "xxhash", specifier = ">=4.0.1" },
+]
+
+[package.metadata.requires-dev]
+dev = [
+    { name = "pyright", specifier = ">=1.1.411" },
+    { name = "ruff", specifier = ">=0.16.6" },
+]
+
+[[package]]
+name = "extra-platforms"
+version = "13.9.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/b5/12/6b1174fdc301af0b920d53dbb8fcc247f8d0d8349ea227801db012221c08/extra_platforms-13.9.0.tar.gz", hash = "sha256:971d373715cdcf5f4e5bdec5cd733b058fb589d7365ba964f654617bc35fcedc", size = 481559, upload-time = "2026-09-07T19:02:53.715Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/f0/d8/712f0b3717c37398d74ba60740484e93ddcdc48b1d7b3d6043e09ca81467/extra_platforms-13.9.0-py3-none-any.whl", hash = "sha256:51f5499104c2c3d4ad5dafee0a0d74a9c4c22f506ee6a53cbf4ac6e982d556ff", size = 103612, upload-time = "2026-09-07T19:02:52.133Z" },
+]
+
+[[package]]
+name = "humanize"
+version = "4.16.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/0a/ea/13a1ef3c12d12662905801495283530251918b70d62d368f1d2e0272c70d/humanize-4.16.0.tar.gz", hash = "sha256:7dc2244a2f84a4bfb1d36c37bac80cd78e35cdc5c119206d87b018e1445f3a3f", size = 89515, upload-time = "2026-06-30T16:17:29.859Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/b0/aa/0b7365d30fed43e7a3449aba1fe20a0a7174d9cf13e282af4e69ac825441/humanize-4.16.0-py3-none-any.whl", hash = "sha256:353eb2f34c09d098b2880eee8bef21832eae6d174f48c5762fff7e5fcb74d01d", size = 137209, upload-time = "2026-06-30T16:17:28.36Z" },
+]
+
+[[package]]
+name = "nodeenv"
+version = "1.10.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/24/bf/d1bda4f6168e0b2e9e5958945e01910052158313224ada5ce1fb2e1113b8/nodeenv-1.10.0.tar.gz", hash = "sha256:996c191ad80897d076bdfba80a41994c2b47c68e224c542b48feba42ba00f8bb", size = 55611, upload-time = "2025-12-20T14:08:54.006Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/88/b2/d0896bdcdc8d28a7fc5717c305f1a861c26e18c05047949fb371034d98bd/nodeenv-1.10.0-py2.py3-none-any.whl", hash = "sha256:5bb13e3eed2923615535339b3c620e76779af4cb4c6a90deccc9e36b274d3827", size = 23438, upload-time = "2025-12-20T14:08:52.782Z" },
+]
+
+[[package]]
+name = "pyright"
+version = "1.1.414"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "nodeenv" },
+    { name = "typing-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/e1/1b/244c7b710031ada80f27e579ec20d28a2285dfc318fed0339866b1047f12/pyright-1.1.414.tar.gz", hash = "sha256:523c0a97c60da6333234955c277730c9cf4f5bd6d5399e7b7d2b0fc5d3599524", size = 4154638, upload-time = "2026-09-10T12:26:53.181Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/d7/ba/18b6e682ead424ad24bcc134339ae5d1b931cd9ae260540592a058a91279/pyright-1.1.414-py3-none-any.whl", hash = "sha256:2a6b4b3298c9eec174c5ed83bd338de6eee82df2992f3e1930e6199d381be36f", size = 6225049, upload-time = "2026-09-10T12:26:51.427Z" },
+]
+
+[[package]]
+name = "ruff"
+version = "0.16.7"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/82/bb/5a449b9162e49b139d72f61672bd3ac1d790221f796d3304e2241fff4c58/ruff-0.16.7.tar.gz", hash = "sha256:5f71d004ac1263b22fa39462ac5ae618a4b77d58981af2cc79bf79a29c12b1a6", size = 4924184, upload-time = "2026-09-10T18:04:06.336Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/e3/b2/c80aeeb7f9e469c0d63a85d2f1ab6e1ebfbe10ea7a8d2438b7e09e3ff09e/ruff-0.16.7-py3-none-linux_armv6l.whl", hash = "sha256:727307773e7c7f9181d3ed3a2484186e56c1fa1874255911c74585eb2c7c19f9", size = 10048917, upload-time = "2026-09-10T18:03:30.28Z" },
+    { url = "https://files.pythonhosted.org/packages/7b/96/20bb7bcae008004df52afcb7ac83432d4a467f2c17b672fe46d26be231c5/ruff-0.16.7-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:9d61c258deabf58f34c67bd4bb4d939c7f2e6b5f0e59c1cdd1cf771b11cde929", size = 10242929, upload-time = "2026-09-10T18:03:32.706Z" },
+    { url = "https://files.pythonhosted.org/packages/90/b2/f184b0d5abec02db69cfd7e49b688ae0237554528ca777136c613bf36bee/ruff-0.16.7-py3-none-macosx_11_0_arm64.whl", hash = "sha256:7ab81118df8945e0193d0240712aa4496573595b75185c3636ed825592a0f728", size = 9847245, upload-time = "2026-09-10T18:03:34.509Z" },
+    { url = "https://files.pythonhosted.org/packages/eb/2d/db1633a641866ed801e34cc6b60ef236c5e16f9b2124ab1d49cc24a5fe4f/ruff-0.16.7-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4c196c968874fc8019da8e7163de7a1a370f111e2309b4b7dfea0fce950198d0", size = 9961780, upload-time = "2026-09-10T18:03:36.618Z" },
+    { url = "https://files.pythonhosted.org/packages/4d/98/edea21e1a3e38dbbc3bf6bb068b863b3b06184cf8533a4c7dbbe208a89d5/ruff-0.16.7-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:ac8c3bd0a7e10ad31e6ce51e7a99f3cb772e69aecdd6b9ea7e99b362f62a62c0", size = 9866337, upload-time = "2026-09-10T18:03:38.805Z" },
+    { url = "https://files.pythonhosted.org/packages/0b/11/a15e60d4c87b214646f116ca9d204475bf993ee1047459bc9a360fd4d6d1/ruff-0.16.7-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:398d3988edde000b5c75dc1b3f584708da9bc990de069c18909142580fec1af9", size = 10562512, upload-time = "2026-09-10T18:03:40.71Z" },
+    { url = "https://files.pythonhosted.org/packages/29/42/eaff4c9b6d0c7cdf56df313a17e89ae854f5bbc0b0c8f9cce19be0ab7a8f/ruff-0.16.7-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:ce05b62b770a8217c4646a9c4139fca00efe8fe5d71f87df2b243ff20d4584d1", size = 11302938, upload-time = "2026-09-10T18:03:42.607Z" },
+    { url = "https://files.pythonhosted.org/packages/5d/43/c75aa59a4ec181fe2ec06cab30e198c1c6d107229a9f008ae3a7c16cabd8/ruff-0.16.7-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:af1b576fddb9d9ef2ececfb5fadcd6a624b25070ed85e3cfcfe449fc3ff6a7b9", size = 10840857, upload-time = "2026-09-10T18:03:44.604Z" },
+    { url = "https://files.pythonhosted.org/packages/21/33/81f3da371942ea031105ba679d8d6e28ec1660ccd690a45f42d381161356/ruff-0.16.7-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9ce7f8f22df67c93ed96c717f9128eadb797144ac2bad475cf536f31d6100c55", size = 10370001, upload-time = "2026-09-10T18:03:46.706Z" },
+    { url = "https://files.pythonhosted.org/packages/fa/0b/6345fb4dbf6dd0ed1cfe5d18391dc9c3f59cc81622a7b0a65b84b3e730ba/ruff-0.16.7-py3-none-manylinux_2_31_riscv64.whl", hash = "sha256:06d0e93d04f392996435ebd600c153f65b47d73fbec2415aa99c5ee5756b3a5f", size = 10548735, upload-time = "2026-09-10T18:03:48.658Z" },
+    { url = "https://files.pythonhosted.org/packages/3f/4d/c5576adf511f92a328e5569dda190ecdd430da51f1a649f3a4a2fd73e21e/ruff-0.16.7-py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:142151a5e7b93c1b11111337142f89dd2fbfee92161225c99a97222f22e32656", size = 10108496, upload-time = "2026-09-10T18:03:50.563Z" },
+    { url = "https://files.pythonhosted.org/packages/ff/8c/667d83c16199a17a56adc6b0bd4c3beb5b767a2babcd16a56f76f9be7fd6/ruff-0.16.7-py3-none-musllinux_1_2_armv7l.whl", hash = "sha256:e6651f97a342d8b35d54d8991544ca22169b86dc54111cb604666940c431b750", size = 9860136, upload-time = "2026-09-10T18:03:52.621Z" },
+    { url = "https://files.pythonhosted.org/packages/99/75/78d401106731999a1dd20cc5a6961e37e1eb9397a3b589f73f3a5ce146a3/ruff-0.16.7-py3-none-musllinux_1_2_i686.whl", hash = "sha256:ef140c6eb935fa9a84c9c607dfb2cb1b85843c192e79265b0c54f35f557ea8e5", size = 10286290, upload-time = "2026-09-10T18:03:55.207Z" },
+    { url = "https://files.pythonhosted.org/packages/68/49/56f9c3a8b755df93a0ad318b2147bf4ef5dae9a7e5ec61c460109c67957f/ruff-0.16.7-py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:53e39506a730fadeee0d998ed5946f30671f0db240c6c7c73bdabbe33604bb6f", size = 10745048, upload-time = "2026-09-10T18:03:57.299Z" },
+    { url = "https://files.pythonhosted.org/packages/5f/ea/7f9b938a63ece4bec677ad7f9f7fa02df3383db1949ed93a382441c09a87/ruff-0.16.7-py3-none-win32.whl", hash = "sha256:2ea3470fcebcbc5df2fb0c6f3b90333fa9084c534e0111c038fa4a6ab9f1c4b7", size = 10059082, upload-time = "2026-09-10T18:03:59.632Z" },
+    { url = "https://files.pythonhosted.org/packages/39/11/480a6973a927aa653e1cead6a6416008640e03a99d05b34c0434b8c6c366/ruff-0.16.7-py3-none-win_amd64.whl", hash = "sha256:7ac26aca826e9e21d0f1cb25b54ac660760a9fdd094d3e4df9848232be98cfc6", size = 10593368, upload-time = "2026-09-10T18:04:01.999Z" },
+    { url = "https://files.pythonhosted.org/packages/8b/4b/51327018d056f0dad2c2238f26d1fb0f53707a9d91b75dea6d1b3039f136/ruff-0.16.7-py3-none-win_arm64.whl", hash = "sha256:aab7f39e2c9df6c596216070f98eef1207b94f8516cca20c808826974971855b", size = 10412401, upload-time = "2026-09-10T18:04:04.098Z" },
+]
+
+[[package]]
+name = "tabulate"
+version = "0.10.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/46/58/8c37dea7bbf769b20d58e7ace7e5edfe65b849442b00ffcdd56be88697c6/tabulate-0.10.0.tar.gz", hash = "sha256:e2cfde8f79420f6deeffdeda9aaec3b6bc5abce947655d17ac662b126e48a60d", size = 91754, upload-time = "2026-03-04T18:55:34.402Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/99/55/db07de81b5c630da5cbf5c7df646580ca26dfaefa593667fc6f2fe016d2e/tabulate-0.10.0-py3-none-any.whl", hash = "sha256:f0b0622e567335c8fabaaa659f1b33bcb6ddfe2e496071b743aa113f8774f2d3", size = 39814, upload-time = "2026-03-04T18:55:31.284Z" },
+]
+
+[package.optional-dependencies]
+widechars = [
+    { name = "wcwidth" },
+]
+
+[[package]]
+name = "tqdm"
+version = "4.70.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "colorama", marker = "sys_platform == 'win32'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/0d/ea/b2a5bd54b28a324dae8211928b2d730b6547500342c7e6c6dea08bd0a485/tqdm-4.70.1.tar.gz", hash = "sha256:cefd0eca11b2a37a3aee776544d4f4ae913f02688135b5556b8788dfa474afc4", size = 171846, upload-time = "2026-09-11T07:25:16.601Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/a7/03/921a3d3c75785aca9ebfbfcabfbc3a1be12e2ab5265deb026d55a5a3f83e/tqdm-4.70.1-py3-none-any.whl", hash = "sha256:c293e525e6fef9c20e8728fd4612df02a0aa31bb5fe91ecd93e123b1b7bffa73", size = 80199, upload-time = "2026-09-11T07:25:14.599Z" },
+]
+
+[[package]]
+name = "typing-extensions"
+version = "4.16.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/f6/cc/6253133b5bb138fc3306cebfbda2c520f545d36b5be2c7255cc528bb45d6/typing_extensions-4.16.0.tar.gz", hash = "sha256:dc983d19a509c94dba722ee6abd33940f7c05a89e243c47e907eb4db6f1a43e5", size = 113555, upload-time = "2026-07-02T08:40:05.92Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/49/d3/b8441a820a491ddfc024b0b0cf0393375b75ea13866d9c66727e54c2fc80/typing_extensions-4.16.0-py3-none-any.whl", hash = "sha256:481caa481374e813c1b176ada14e97f1f67a4539ce9cfeb3f350d78d6370c2e8", size = 45571, upload-time = "2026-07-02T08:40:04.659Z" },
+]
+
+[[package]]
+name = "wcmatch"
+version = "11.0.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "bracex" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/57/43/30e407989e313677dbb9d5f045f966549a7254834571e342eaa4b55cc67b/wcmatch-11.0.1.tar.gz", hash = "sha256:1ea2b4fa678b8ca268253798d5963935df39132d47c3e241c0a0732224005e7d", size = 144662, upload-time = "2026-08-14T15:20:40.477Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/ce/77/7a02b0f05b3ffcdbef9719ce3ee0b508d6a29b58e95299f1580055671db3/wcmatch-11.0.1-py3-none-any.whl", hash = "sha256:fd149ecddb9f0a88ea780017d6dde17c994e494e7f7303d4e3c9d6251f978f4b", size = 43449, upload-time = "2026-08-14T15:20:39.379Z" },
+]
+
+[[package]]
+name = "wcwidth"
+version = "0.8.3"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/36/57/ed58088fafdf4c55a0ad6bde846502567645424d7ebf325230b9237f4085/wcwidth-0.8.3.tar.gz", hash = "sha256:d128512515fbf4612e0ff21fd6380399210318b7b54a9af59dff8454cf9730eb", size = 1458450, upload-time = "2026-08-28T18:10:06.875Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/c4/0e/57f6bb3024a597b2e8ec4aee710ffe62ddc95af2e2bb1ee7a7abdc22c68c/wcwidth-0.8.3-py3-none-any.whl", hash = "sha256:d5b73dba6158a595ec9370350e7f2637bcac8d6c5e4fde34f30fcffb6103a5e4", size = 331669, upload-time = "2026-08-28T18:10:04.909Z" },
+]
+
+[[package]]
+name = "xxhash"
+version = "4.0.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/f6/a5/1386f35da1475fcaeef42581deae73417c6d2a6a0b2d2e8914de18844dcd/xxhash-4.0.1.tar.gz", hash = "sha256:d55bf4ef10eb09b8b6866790e083d26d087d84caa3cc0946ba87c3ca7ecaf7b7", size = 101513, upload-time = "2026-08-17T08:24:08.557Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/81/0e/ea406a02b561d3275232ccfdb3e29df80f7a65414940e3a15721c7bea40f/xxhash-4.0.1-cp314-cp314-android_24_arm64_v8a.whl", hash = "sha256:af05a3f650220a6c59fa0ad2410249f2d2470a05225807c378fb67458693f8df", size = 43747, upload-time = "2026-08-17T08:22:31.37Z" },
+    { url = "https://files.pythonhosted.org/packages/f9/f0/b0c94d61ccf6b5d1f8847b58ef8f923125ac4919ed5bd0eb082750ca7cbd/xxhash-4.0.1-cp314-cp314-android_24_x86_64.whl", hash = "sha256:a6e3653df1a70b8ac4191216324242e4be2bca18c9a7c10934e1bd56dc7ca15e", size = 40749, upload-time = "2026-08-17T08:22:29.431Z" },
+    { url = "https://files.pythonhosted.org/packages/2f/c5/8085881a538983be0fd1c865d5df236242fea496044e2c8ca32b9f2ba39c/xxhash-4.0.1-cp314-cp314-ios_13_0_arm64_iphoneos.whl", hash = "sha256:4528cf80ebbbf57d40edfb31521ae265daa6dd636d615b1cf0ac86209579e59d", size = 34734, upload-time = "2026-08-17T08:35:33.68Z" },
+    { url = "https://files.pythonhosted.org/packages/d3/94/8803d13c968fc75ca434eea991d29ac5fd8a36b4afc9a6a9803c53933db4/xxhash-4.0.1-cp314-cp314-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:90cb2a1c9cc503a054a19612b48ff6e8e47805f618bdb3224a07568aad03a37e", size = 35671, upload-time = "2026-08-17T08:21:48.322Z" },
+    { url = "https://files.pythonhosted.org/packages/85/d5/ad91d7f0fd294190d37c08236fe661f5c4e3f83dcd1a121877a2e64681ce/xxhash-4.0.1-cp314-cp314-ios_13_0_x86_64_iphonesimulator.whl", hash = "sha256:a949b072ea59c6eca0811ccd9e95133cc50d2afda8d464b5b077c78f78efa269", size = 38094, upload-time = "2026-08-17T08:22:39.763Z" },
+    { url = "https://files.pythonhosted.org/packages/89/f4/2b7ebdc1869caca5f02c4cba8379b631050d3c3d4adb9187e4dc1a6b8d3c/xxhash-4.0.1-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:79a3203aadf39637869dfea1185227d8452844d78b837e54fb1117b4d34ba5c3", size = 38244, upload-time = "2026-08-17T08:35:38.081Z" },
+    { url = "https://files.pythonhosted.org/packages/90/9d/f66cf6935f528e575f1ae4d6560d376e7587569747186f4fae8777cadc1b/xxhash-4.0.1-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:d9f3848ffaf010bdbabdbf4c25641fa258b6227ff27bc74a4d06edef521a4873", size = 35904, upload-time = "2026-08-17T08:21:37.358Z" },
+    { url = "https://files.pythonhosted.org/packages/07/29/34569d7b482f0dc060074faafd163c588f915cbc3e3e218f1ffd8a3ad340/xxhash-4.0.1-cp314-cp314-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:9283d9dd6b44acad35118e2976fc763a065509e4118debdb61916ec322ed17b9", size = 259595, upload-time = "2026-08-17T08:22:38.153Z" },
+    { url = "https://files.pythonhosted.org/packages/ce/d2/a2370acfcd48732cf5c2b87f06cfbf7fa51c0ce0dd736bde42939eb9ebf7/xxhash-4.0.1-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1c7c642a0f79c3e3cf2965475507574d3d1a50ec71060039d60cb87358667cb2", size = 284279, upload-time = "2026-08-17T08:22:36.396Z" },
+    { url = "https://files.pythonhosted.org/packages/08/15/17d33c24e6c4a1c0b9ddc5584f0c25d51d48b34bacde1416a2235a19db4b/xxhash-4.0.1-cp314-cp314-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:96dedccfb09a73a25751053a183159b88f4ee75f388df8166040c152ac0531c6", size = 303973, upload-time = "2026-08-17T08:35:39.22Z" },
+    { url = "https://files.pythonhosted.org/packages/ec/e0/4ec0d69ad5738729098a61e631b7ed2df22a922b0e03014b597c72bd863d/xxhash-4.0.1-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:81664268dba92e037b740ecf37fa02f1cab4a391f93f28e35792b3341c60648f", size = 287535, upload-time = "2026-08-17T08:21:52.158Z" },
+    { url = "https://files.pythonhosted.org/packages/0f/8b/4f9b17e7a9eb71c65548ecddd9c18b84e3c18ca41c4d436ad2a3000d3f7b/xxhash-4.0.1-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:839f58c5bd9989875be0fd28446dbf32cace2c2cd8bf2f6762acdc38a95cd1aa", size = 519257, upload-time = "2026-08-17T08:22:43.272Z" },
+    { url = "https://files.pythonhosted.org/packages/68/35/3276b3e743b8ddbed9c3f71c76d9dd6a75d72aa4e678b1447b635cfd92e0/xxhash-4.0.1-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ffa44b4c7c5d0ffa31356b4428659516c0e47647825c74079a296b3857b6d99d", size = 268190, upload-time = "2026-08-17T08:35:44.985Z" },
+    { url = "https://files.pythonhosted.org/packages/08/d4/f1555de3c96721320930dbb7988c8482d82b85970076aba1a8d40e83ad43/xxhash-4.0.1-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:e681a6fc7e4f715252b9b5acfb30536ec7dd1f75033a32dc617e6fa95af1a3fd", size = 345553, upload-time = "2026-08-17T08:21:41.025Z" },
+    { url = "https://files.pythonhosted.org/packages/ac/98/c28908f27007087b61139d290f908dd827ffd40b88af0c43f9e1a1a7ffd5/xxhash-4.0.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:c6301d92545c591ad31c3e050aa40a5f8a4c16413f1f9e6f9322c6f0f9d2b736", size = 280499, upload-time = "2026-08-17T08:22:52.236Z" },
+    { url = "https://files.pythonhosted.org/packages/a9/76/3ef57622c65816348f8196273485baab4752aae064959901e85cd867e067/xxhash-4.0.1-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:6efb8f21cc136c79b3e5bb747c8682d37916fb202cdbbc32182de5c4e47f821f", size = 307211, upload-time = "2026-08-17T08:22:40.815Z" },
+    { url = "https://files.pythonhosted.org/packages/8a/4c/5804504bbc808968e57d6a50286dd8f8cc06e0ddd6e4ab4b1dc89ae42f35/xxhash-4.0.1-cp314-cp314-musllinux_1_2_i686.whl", hash = "sha256:760de77279e9cf9c81d012ce0705cba13afccee9b09c480f17d778c8c5cefae8", size = 265865, upload-time = "2026-08-17T08:35:42.727Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/ee/8572fdfd70e7aaaf150af899871c2cc0bb88c3295ca82172a31e04ca5168/xxhash-4.0.1-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:a16a3fa6936e36bb1414d16a6bd012c9033e5161b68b426805b61d895392437d", size = 284545, upload-time = "2026-08-17T08:21:56.965Z" },
+    { url = "https://files.pythonhosted.org/packages/c1/f8/6eadcca0904660c848b466524e82a233d16c9d2d5258433aaf3546142d86/xxhash-4.0.1-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:9c3c4b9aa9a27196b921197f7daf9e6c1412739df06a99cfa6e923879362eff6", size = 336022, upload-time = "2026-08-17T08:22:46.346Z" },
+    { url = "https://files.pythonhosted.org/packages/27/df/4aa107b81602d6d6d09ab5a607c530d2d3a6b28e2e9a59b01875bd877c54/xxhash-4.0.1-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:863f3d3b44110f7243e86cf994aa5c5d88f2348b6e84ab4402fadadfbf9f7da7", size = 486671, upload-time = "2026-08-17T08:35:49.016Z" },
+    { url = "https://files.pythonhosted.org/packages/45/b7/b2bf9b5301e9cd5f2e335fea8da0f5cf209a6594cb1fe77754774ad4a6fd/xxhash-4.0.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:63aa52659bc32bb9bd7cb5caf523b4d14429a477762cfac886132d687c1f80fc", size = 263744, upload-time = "2026-08-17T08:21:56.165Z" },
+    { url = "https://files.pythonhosted.org/packages/0b/96/35b1c02177ae26234892c2310fb4822ba62411acccbf425ab8f9fd99354a/xxhash-4.0.1-cp314-cp314-pyemscripten_2026_0_wasm32.whl", hash = "sha256:67e57b834e07ed973cee7b6da1548ff28a56458d77696fd2a5f397f340694848", size = 20563, upload-time = "2026-08-17T08:35:11.924Z" },
+    { url = "https://files.pythonhosted.org/packages/51/c2/a06300b165fbd6b0cb4a9742987f2e997a9f447ce3bf7c6ac97b862ce62a/xxhash-4.0.1-cp314-cp314-win32.whl", hash = "sha256:b6c1f9c59bbe593f88a0aad30be4150f15bd57bd64efb95feeabcb8e563f1ecd", size = 35151, upload-time = "2026-08-17T08:22:44.283Z" },
+    { url = "https://files.pythonhosted.org/packages/06/96/c5b37296b78f80fc97124c0fee0c7bbd1bdb6f3b18bcd8748bb113b2d8fc/xxhash-4.0.1-cp314-cp314-win_amd64.whl", hash = "sha256:da544672efd9ad76077928a3e6c5d894e52ce82d3bf14002db4a1bf17d1a36a2", size = 37156, upload-time = "2026-08-17T08:35:46.551Z" },
+    { url = "https://files.pythonhosted.org/packages/ce/5e/248f9cd169c2fb62236bedfba246d213bce728f74901e99047e3f3c55875/xxhash-4.0.1-cp314-cp314-win_arm64.whl", hash = "sha256:d0d24a4f3fb63852cd09af46ae4b7a4d00cc8b8615a046dca543786e728d1056", size = 34379, upload-time = "2026-08-17T08:21:59.446Z" },
+    { url = "https://files.pythonhosted.org/packages/58/c8/db1d37c0da0324d0298f6abd931ca1d4736e049d9f2081230a8421da74d2/xxhash-4.0.1-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:349775ac30372b344d2338b2a168c0a1312a644194da25b8bec476d55761a128", size = 38656, upload-time = "2026-08-17T08:22:49.119Z" },
+    { url = "https://files.pythonhosted.org/packages/c5/8e/e18998ec465fb977bc74272e5bf3c2e886c13b014cbef916cd607802c709/xxhash-4.0.1-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:43e5f9169e73d0f0db33b5f6b8554bcce69ac278c966daf83d5eb4eb2f13829f", size = 36306, upload-time = "2026-08-17T08:35:52.853Z" },
+    { url = "https://files.pythonhosted.org/packages/ef/1a/b83f86f8a987a3cbcb7e005a6824ff64aecae35abc1395a0d44ee16c3319/xxhash-4.0.1-cp314-cp314t-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:4a252fb862b0ae2590587e625f47a0e03da05cf0205e8830b67b6596c06038b1", size = 273729, upload-time = "2026-08-17T08:21:58.833Z" },
+    { url = "https://files.pythonhosted.org/packages/02/4e/2db15aa8508e0cd5b632927a53b98234f24039ea65377e6cf996c06d2d4f/xxhash-4.0.1-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:2df3ca8757dc381e75e90a4d7995a6324f58a923c7145220a7b2c0231f66fddc", size = 301083, upload-time = "2026-08-17T08:35:14.113Z" },
+    { url = "https://files.pythonhosted.org/packages/26/94/ed759787ffe802bd8e31cfcdad3755cbeca2dcdafd2f790cd6f25d195199/xxhash-4.0.1-cp314-cp314t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:bfed61996d618eb90d6eaae0178002e3466a28b06bfc557a7a3a7266378d8c5a", size = 312745, upload-time = "2026-08-17T08:22:52.232Z" },
+    { url = "https://files.pythonhosted.org/packages/45/7a/f64b4a4cc8b51e950709207f55f7f56ae9c5af6631dd31d7fb443312418c/xxhash-4.0.1-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:9761ff4a0ffa583fe850731ad24fe82c88cccb7a2294727db0955f3279a4cb3f", size = 301419, upload-time = "2026-08-17T08:35:50.143Z" },
+    { url = "https://files.pythonhosted.org/packages/a0/71/bac313b8de073569b8db3152044a7cfcce87a3fa9698c18fe9f914dee6b1/xxhash-4.0.1-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:edccc2ec58435a580f96a48a3ccae8cd0a480824119165dd90108718ad81ae6e", size = 534485, upload-time = "2026-08-17T08:22:11.515Z" },
+    { url = "https://files.pythonhosted.org/packages/b9/0c/16b5e419f24e59507ee05626d2bb0deafdb03f9f27783bc0785a9849602e/xxhash-4.0.1-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:4741d42d59e4e5fa1a86c17ab9c27dc8ea459c700d91b6742fdb9138d9a516cb", size = 279605, upload-time = "2026-08-17T08:22:52.934Z" },
+    { url = "https://files.pythonhosted.org/packages/5f/55/5787dd6e2d8d5b61256a5039f6b18c2193c7c1de4a2fd2413288d0d9c604/xxhash-4.0.1-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:440c401e146ce64bdb3beb8ff0c84677b6f21307c28a34779071cecee5d4d70c", size = 358924, upload-time = "2026-08-17T08:35:58.164Z" },
+    { url = "https://files.pythonhosted.org/packages/f3/68/89be41991f3b0a2e91f940bdf3128852c3ed571cf560d98ad0f67024afe4/xxhash-4.0.1-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:5b7979f71d06ae45a769de0699900a246d8cb632db1e8bfdc79ec019063a503c", size = 295305, upload-time = "2026-08-17T08:22:13.683Z" },
+    { url = "https://files.pythonhosted.org/packages/e6/5a/52ff0a0cc361aad393ff9a46ffe3aabbcf9c03d6c8f2612da7d553048276/xxhash-4.0.1-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:62198213fc3e0c56e567894b318ba45834e007d065f84ba6dc9165d21546fc56", size = 320228, upload-time = "2026-08-17T08:35:18.946Z" },
+    { url = "https://files.pythonhosted.org/packages/0f/b5/91c60ff22c7f6cd5f6d7a5bad5a2cdcb4c33987dfa50bf13f0d856279b2e/xxhash-4.0.1-cp314-cp314t-musllinux_1_2_i686.whl", hash = "sha256:b3bece52127ac20044311ee73567f9f0893b5de64f9028aecc90cc740cfd525a", size = 279414, upload-time = "2026-08-17T08:23:03.212Z" },
+    { url = "https://files.pythonhosted.org/packages/b9/94/9685954804d47d0390871a64bec606a0d536406382d71a784df3a5883fb4/xxhash-4.0.1-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:a865d2d470220e659220fdb59d5b6c4422802d8d6098e1324bc4d12444798914", size = 297594, upload-time = "2026-08-17T08:35:57.881Z" },
+    { url = "https://files.pythonhosted.org/packages/89/62/b67ac9412907b7a07a2a0c08c3440b9e4480231a7b3de0767e87011e4564/xxhash-4.0.1-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:8580aab306888224074c7edeec734de0c3c5ccde65b2da4e6c9a5e28f7c0a1bd", size = 348526, upload-time = "2026-08-17T08:22:18.571Z" },
+    { url = "https://files.pythonhosted.org/packages/37/ed/6723cc49a9f567d52d01fd7c1741b0f2e3a13e71d15f7ac49d753a20c115/xxhash-4.0.1-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:2d52dc7c33c1b83082b707f6b7814dc76d2faaa2ea62bd9c5fab4b36f83c087f", size = 499307, upload-time = "2026-08-17T08:22:56.52Z" },
+    { url = "https://files.pythonhosted.org/packages/fd/2e/7b10e101ab988d93b791023be7191d7661271d6ab31ac082276b9091042a/xxhash-4.0.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:6a9f98af872355e0c02439e48583958eee00e60b928bb20476460d9d40cb7b4e", size = 274989, upload-time = "2026-08-17T08:36:01.834Z" },
+    { url = "https://files.pythonhosted.org/packages/9b/8d/7eabcc8d29cce40621443cff24c07d7306ef574b8956c47ac59f21098005/xxhash-4.0.1-cp314-cp314t-win32.whl", hash = "sha256:a14578102a6081465aec9cf73c76c3cd3f79f0709bdb3b8ae7ab0b54c9d8b089", size = 35482, upload-time = "2026-08-17T08:22:32.336Z" },
+    { url = "https://files.pythonhosted.org/packages/ca/89/2a4268e1971f63038b79fb75e3b9c8de942cd77acabbb0c5625352a31940/xxhash-4.0.1-cp314-cp314t-win_amd64.whl", hash = "sha256:c57963970d359a72262f7fe6be88f945e2334d4bc41462b7f08c37b0abf35ca6", size = 37490, upload-time = "2026-08-17T08:35:22.475Z" },
+    { url = "https://files.pythonhosted.org/packages/90/7b/950ecab1fe4cf421d0a6211ddd9a0ac82e39e55c45a111ceb90953dc6c9a/xxhash-4.0.1-cp314-cp314t-win_arm64.whl", hash = "sha256:b659fad79c99b0238c7ad7e9d7dbf4eebfea9097c2dba65fa0a4d18a25b29a2f", size = 34596, upload-time = "2026-08-17T08:23:10.001Z" },
+    { url = "https://files.pythonhosted.org/packages/c4/03/7dc3b85fac10751613bfedb0e120734e0e8710054abad3f931e9d3843a14/xxhash-4.0.1-cp315-cp315-android_24_arm64_v8a.whl", hash = "sha256:5adf927dca8c47fde7e683fe69efdd81bc865c4db1fb6bb00b391e2b6185207b", size = 43749, upload-time = "2026-08-17T08:36:00.47Z" },
+    { url = "https://files.pythonhosted.org/packages/a5/55/bfac071c5b1c6d6a3d48ab1ab96a15e958a1d7061f4afc97804292d87264/xxhash-4.0.1-cp315-cp315-android_24_x86_64.whl", hash = "sha256:c30dd1af66a820820398b26e0d74e7a9aa43cae705924f23ed828cd8e5c26c3d", size = 40758, upload-time = "2026-08-17T08:22:30.209Z" },
+    { url = "https://files.pythonhosted.org/packages/79/87/49a260e685d1a74c56a69432a8ee0527ddcbd684a3c51f87edc3b75639c5/xxhash-4.0.1-cp315-cp315-ios_13_0_arm64_iphoneos.whl", hash = "sha256:1bc591533fc975614f7e13594daee76af96b8e1fbcf8de76c8773858fa9e7cea", size = 34788, upload-time = "2026-08-17T08:23:09.014Z" },
+    { url = "https://files.pythonhosted.org/packages/6c/ef/50d72ed2170dae872e1c0fe333d0908e0a2afbffe74c5c9037d5406a4b89/xxhash-4.0.1-cp315-cp315-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:567cbc630302a46a8ecfd943b309ccf5372bb3718f1f3762d452df30f033bcf0", size = 35746, upload-time = "2026-08-17T08:36:05.557Z" },
+    { url = "https://files.pythonhosted.org/packages/66/f0/969deaa2bab3bfd5ad5b023442124d2255b9961eef6f797ec74eb8683bdf/xxhash-4.0.1-cp315-cp315-ios_13_0_x86_64_iphonesimulator.whl", hash = "sha256:e998cb3685b92101ec5de0fb4d9485cf01e50bc418211955c55d98064664cf4c", size = 38098, upload-time = "2026-08-17T08:22:36.906Z" },
+    { url = "https://files.pythonhosted.org/packages/86/aa/45ed7d7b8d7b66202a47bf8ff3b77cea28d2ea54dfcdd202b4cfe043e3dc/xxhash-4.0.1-cp315-cp315-macosx_10_15_x86_64.whl", hash = "sha256:c3074db513c81f764053e3da079312ecf85a50d8350c71f4cc0105d9662a9e6c", size = 38251, upload-time = "2026-08-17T08:35:25.774Z" },
+    { url = "https://files.pythonhosted.org/packages/f1/9d/45e7520a7856e13800a5dc8cd038d34c6372429465b163af0c5722f16918/xxhash-4.0.1-cp315-cp315-macosx_11_0_arm64.whl", hash = "sha256:3088dadbffa33c29e0518578430a7dff2e901a212e487aefa5faaa0dc06dad34", size = 35986, upload-time = "2026-08-17T08:23:25.854Z" },
+    { url = "https://files.pythonhosted.org/packages/9e/0e/5ad466e5fea18c9f9bdc5828c0506f62190061b4a1b0e688aa54969d0a9e/xxhash-4.0.1-cp315-cp315-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:1b50223d92df94d54e1a31469335a2c74b16692e6c1cb726f1e6949514458706", size = 264609, upload-time = "2026-08-17T08:36:04.229Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/cf/8f269f85217e3dbd45e31e25e46cc26f3aff0e159ef05d228b4b982c778c/xxhash-4.0.1-cp315-cp315-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:427b62d62d4f967fbb10b82a3813e4875c2a6e7e7634739f17265b650c7f65a6", size = 285910, upload-time = "2026-08-17T08:22:38.589Z" },
+    { url = "https://files.pythonhosted.org/packages/ca/30/2fc1a16ee0f9501d074b798ebfae52e24fa602c7117f5c4b81de71eada72/xxhash-4.0.1-cp315-cp315-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:c6370189e8e66b7e608f533b939a9de092ddca6cce084ca0d3d414d2ed5b5d59", size = 306566, upload-time = "2026-08-17T08:23:16.895Z" },
+    { url = "https://files.pythonhosted.org/packages/e0/a7/08375cf2b997e1903663fe7525c5973b1987a4f8ad2b8d47463e9143f2ee/xxhash-4.0.1-cp315-cp315-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:ec1a470c6db94ac4589c203921e89ac1bc13e796a8b1784d8135e1893559cd3b", size = 287978, upload-time = "2026-08-17T08:36:09.296Z" },
+    { url = "https://files.pythonhosted.org/packages/b2/e5/90a7b404c11add9e53a497d06236152852490c3b2f21e468d97a58f26afe/xxhash-4.0.1-cp315-cp315-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:37f667dee0f867c42894b34e2a6fe26bf195c0ea4683d9d2b713db023f242c3a", size = 520098, upload-time = "2026-08-17T08:22:41.565Z" },
+    { url = "https://files.pythonhosted.org/packages/11/02/7fba10b1b17eb46308f09cc0a4ed513d74dff16b1e22a1c439f011c77129/xxhash-4.0.1-cp315-cp315-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:f18732adcc271741bd651c3e56fa519d8a237d2cccda01fe3afb226bf87f783b", size = 268273, upload-time = "2026-08-17T08:35:29.043Z" },
+    { url = "https://files.pythonhosted.org/packages/54/49/c21b228877357a3be43eeeaa22182ad1685796f415390ada475922c084e4/xxhash-4.0.1-cp315-cp315-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:0b42a5a26607e4b2409fea174773a66f2dff9dfdbf2c1a851bb7b804e2c97535", size = 350164, upload-time = "2026-08-17T08:23:29.494Z" },
+    { url = "https://files.pythonhosted.org/packages/00/3c/c15bb4aa33d94b78a5553b52e7fa1070565f0199925aeadec3871de20ce9/xxhash-4.0.1-cp315-cp315-musllinux_1_2_aarch64.whl", hash = "sha256:99166cc98637e8bf550cda2aab07f4f1d5f899c45fbd721801aeabcc9d404824", size = 281975, upload-time = "2026-08-17T08:36:08.139Z" },
+    { url = "https://files.pythonhosted.org/packages/18/7a/b1d0388315fe7752b7725b68a912667526a1dd48ed492fcc031ac03f4b52/xxhash-4.0.1-cp315-cp315-musllinux_1_2_armv7l.whl", hash = "sha256:6cf633df84d80a1668fcf61e330791dae46825e395549e7d34f376411e75088a", size = 307872, upload-time = "2026-08-17T08:22:42.206Z" },
+    { url = "https://files.pythonhosted.org/packages/b4/a1/037cb2dd8cf725c9565dfe3712b2915c0e0276a9154913dbfcbcecbeb672/xxhash-4.0.1-cp315-cp315-musllinux_1_2_i686.whl", hash = "sha256:e259bb7e1e2d8de6b35f430f5c7220b1c0ebf3962d1ba7ec7545980d5931edb8", size = 268241, upload-time = "2026-08-17T08:23:23.997Z" },
+    { url = "https://files.pythonhosted.org/packages/c6/a9/67c44422d0ee082169b238ce24bd2796b82d7c21ed953471365df8c508d8/xxhash-4.0.1-cp315-cp315-musllinux_1_2_ppc64le.whl", hash = "sha256:704381264b36a18b9c62ecbabe2e71d0fc58c77c129c15355c989b10bf05b6b0", size = 284970, upload-time = "2026-08-17T08:36:13.476Z" },
+    { url = "https://files.pythonhosted.org/packages/7f/d0/254a5f51c4014cacc77a26f321372338b924f54e89efb730164ee336d850/xxhash-4.0.1-cp315-cp315-musllinux_1_2_riscv64.whl", hash = "sha256:e90b4bcf1d9eb1010fdaee7c9209fb667e74c0684f3ba17f9032bd7319da90c9", size = 338074, upload-time = "2026-08-17T08:22:51.166Z" },
+    { url = "https://files.pythonhosted.org/packages/64/03/f21c4830118d72ef3a958ce8bf2152f49e0d4cf200907616c9be6caf372a/xxhash-4.0.1-cp315-cp315-musllinux_1_2_s390x.whl", hash = "sha256:a65785e653573fcd1e33062760ab4c3c3440e8e910765018e4b6ed4ad07b54a0", size = 487626, upload-time = "2026-08-17T08:35:32.768Z" },
+    { url = "https://files.pythonhosted.org/packages/45/1f/268a689d741d7da649317eb4ce41760140beb4179aaf43a7216fdbe8100c/xxhash-4.0.1-cp315-cp315-musllinux_1_2_x86_64.whl", hash = "sha256:e3996ff9b6f99180357024336bf5749a8ad6476a9a2523e535c5212b995b12a2", size = 263852, upload-time = "2026-08-17T08:23:41.871Z" },
+    { url = "https://files.pythonhosted.org/packages/a7/f5/adaf8101cd7f143191a0b390600294d83924b32cb13770fde8803dce27a2/xxhash-4.0.1-cp315-cp315-pyemscripten_2026_5_wasm32.whl", hash = "sha256:99054b838b74d8d3995ea0d410976ae967c46207ae22d6ddfc535e809197dab9", size = 20569, upload-time = "2026-08-17T08:36:11.952Z" },
+    { url = "https://files.pythonhosted.org/packages/ee/2c/56a5eb8c993420fc07114c08f447a2b66ee996510b4764cb368b9b44c9f0/xxhash-4.0.1-cp315-cp315-win32.whl", hash = "sha256:6c45258a37fc22721395c09927cb982d3e7a83607cab15be7e2416501bd3a330", size = 35145, upload-time = "2026-08-17T08:22:50.038Z" },
+    { url = "https://files.pythonhosted.org/packages/67/c7/65f210db43e62157d0fef3b4d4d7b394821e7733c8bb4ece49f91410a725/xxhash-4.0.1-cp315-cp315-win_amd64.whl", hash = "sha256:0ab851b45c70d4992be7cdeeee16f97a0b677408c758c4b1efb1cfe8030bfd37", size = 37161, upload-time = "2026-08-17T08:23:32.438Z" },
+    { url = "https://files.pythonhosted.org/packages/33/ae/1a641d1d60ba219756d9ebe907ff0ecf4445adcf4fa96f6e3da57b91d439/xxhash-4.0.1-cp315-cp315-win_arm64.whl", hash = "sha256:a5b21b42a01a343096a1c018d35e9b7aec9c7065dda53ae8da071e37478b2cea", size = 34378, upload-time = "2026-08-17T08:36:15.912Z" },
+    { url = "https://files.pythonhosted.org/packages/48/7f/7698b320b251806d1249e513922a626f19027e104c829a611272250350eb/xxhash-4.0.1-cp315-cp315t-macosx_10_15_x86_64.whl", hash = "sha256:44ab12e8cd17d4f001769f00ad465208b4bcb897ed29e65f058f74466b57a98f", size = 38610, upload-time = "2026-08-17T08:22:55.203Z" },
+    { url = "https://files.pythonhosted.org/packages/c0/3d/436497e775b647b3b3e9a4ffe8c76c59fa4aa7a9fab6447cb59acf1b50ea/xxhash-4.0.1-cp315-cp315t-macosx_11_0_arm64.whl", hash = "sha256:45e88111ebe331de478ef8d4293efbe88f3cf8b863386c9a2357136b838e1af0", size = 36378, upload-time = "2026-08-17T08:35:36.18Z" },
+    { url = "https://files.pythonhosted.org/packages/e3/d8/17a4f8182b9257898aa2a77c2a45f70233eb8e50681a280e8e09d2ee76e9/xxhash-4.0.1-cp315-cp315t-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:bf430c587f447a554c53768ad76b9846fe7c5632180ef6f69c4fce8b0552fbd0", size = 273559, upload-time = "2026-08-17T08:23:51.075Z" },
+    { url = "https://files.pythonhosted.org/packages/83/28/121bd5a5c5adb88e0da772c7bef61964cf9da92956a7a237c7d24c4351b8/xxhash-4.0.1-cp315-cp315t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:adbd48b30e3f82c89fb2b3e6a87cdd28d113b190a5ed0ee2dee286323ee9a621", size = 299133, upload-time = "2026-08-17T08:36:14.731Z" },
+    { url = "https://files.pythonhosted.org/packages/11/8f/57c7b6e04642ed738a0d08a31bed7fc63fdacb661d665f98739cc9751b62/xxhash-4.0.1-cp315-cp315t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:e71b34978e77868cbf2d18c5206a4603f9c644dd7181bec5643bd40141d3b8c5", size = 314527, upload-time = "2026-08-17T08:22:54.224Z" },
+    { url = "https://files.pythonhosted.org/packages/8e/18/42793917dbab0ea1ff71458aea4875e17a7263f2797b798af048dc81e867/xxhash-4.0.1-cp315-cp315t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:488ca5c5e28ef56ec4bbb12f835b3f1cbecc5f3510062e70117bc6594851932a", size = 299199, upload-time = "2026-08-17T08:23:36.864Z" },
+    { url = "https://files.pythonhosted.org/packages/37/60/51dc92443923d8e908d5614f1145d8d696450f9d6c8f1abe243c6f2a0222/xxhash-4.0.1-cp315-cp315t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:421b94f3ba7067958d02e38960d987756347aa150df06df11aa68ae1af78c619", size = 531967, upload-time = "2026-08-17T08:36:18.66Z" },
+    { url = "https://files.pythonhosted.org/packages/88/c5/d0de77de09661fac71742c4155b1cd65e274f7cc277819d702b6c8ff2db5/xxhash-4.0.1-cp315-cp315t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:f33cf0baa91eccd2cb7b62bf00f10c2264ef578b71dd33a12962e71a36eb4d32", size = 278764, upload-time = "2026-08-17T08:22:58.15Z" },
+    { url = "https://files.pythonhosted.org/packages/08/9a/589929c655aba1bfb2c41ee03e50eec1547c39c3042a66bda9c173a9614b/xxhash-4.0.1-cp315-cp315t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:23a4376b4a3183cb50d4d2a3179f887a7773cc695eb2c908e551bec3221b8c60", size = 359876, upload-time = "2026-08-17T08:35:40.35Z" },
+    { url = "https://files.pythonhosted.org/packages/3e/a8/c1d8c94d54d91db2215565f4b4151c1593af3e6d27ac4c00fd1e8d714a02/xxhash-4.0.1-cp315-cp315t-musllinux_1_2_aarch64.whl", hash = "sha256:38c3d22129a6958846a3098d68bc8e661704461c0be4793ae28836e4690c8478", size = 293548, upload-time = "2026-08-17T08:23:54.951Z" },
+    { url = "https://files.pythonhosted.org/packages/8b/67/85d8abca94508a4dd10561d9dea3e6e68843c6986dd6d9c1b3729c8622e4/xxhash-4.0.1-cp315-cp315t-musllinux_1_2_armv7l.whl", hash = "sha256:87cbdec1a7dd930079671a60b249f3ca4e773e6fbd0676e21e36fdc9dd0f3b00", size = 318780, upload-time = "2026-08-17T08:36:17.623Z" },
+    { url = "https://files.pythonhosted.org/packages/1b/16/2b920ed456b9cdcfc99ddc20c3afe42f9f807ee5850773c12fd891f3c08d/xxhash-4.0.1-cp315-cp315t-musllinux_1_2_i686.whl", hash = "sha256:6cbf4e21ef0890804b5bb9ad25c48f9c127758d7f6c66bef374efcacc63c738a", size = 277582, upload-time = "2026-08-17T08:22:57.156Z" },
+    { url = "https://files.pythonhosted.org/packages/fa/cc/5811b5997aebb8452047f5800d32fc50eaa29d0ba08d4e426f84450b9c2f/xxhash-4.0.1-cp315-cp315t-musllinux_1_2_ppc64le.whl", hash = "sha256:c101180495cb4ba3617b279a944345c53a5e73b0c150053d1fa8d8af32de9579", size = 295116, upload-time = "2026-08-17T08:23:40.868Z" },
+    { url = "https://files.pythonhosted.org/packages/2d/dc/c2f3f9c2f4d6aadb79f17a9f1c9a7ee82638cc873680da044cf29537d2ee/xxhash-4.0.1-cp315-cp315t-musllinux_1_2_riscv64.whl", hash = "sha256:c0e6ccc2b19ec8a726b2e26062ac71ea63e15500d6bf85910e42481844fdffc1", size = 347065, upload-time = "2026-08-17T08:36:21.618Z" },
+    { url = "https://files.pythonhosted.org/packages/a2/4c/750cc642c92252e10772ec09e1a1d995581ba4c3ceb24f6e2d57c7ce47ca/xxhash-4.0.1-cp315-cp315t-musllinux_1_2_s390x.whl", hash = "sha256:8bcba9456242ebf180a04d9443812fd85ffe6bd12bda464dd116fcece8886ff3", size = 497208, upload-time = "2026-08-17T08:23:17.88Z" },
+    { url = "https://files.pythonhosted.org/packages/6c/2d/58693cb13d6395f39b6b9bb40c5e0db53a5df7c9fce805aa7e792f64a1a5/xxhash-4.0.1-cp315-cp315t-musllinux_1_2_x86_64.whl", hash = "sha256:83b8c2013edb5dc1f9e7268b6496130705bc48d79c86bb8817b3d210b81a5513", size = 274338, upload-time = "2026-08-17T08:35:44.062Z" },
+    { url = "https://files.pythonhosted.org/packages/4a/08/9aa9787586d9b3e92d63343ce7dc24f0f445fd9e74ff5d6e85dd82233df5/xxhash-4.0.1-cp315-cp315t-win32.whl", hash = "sha256:aa6ccc7f31018484d652cf52db020003433f3c9fa83189c028bd807d2adde503", size = 35471, upload-time = "2026-08-17T08:24:05.795Z" },
+    { url = "https://files.pythonhosted.org/packages/f0/ab/4615789c333bee331ac417885c50105715eeb8244bfc68d2bc37dcfd63ca/xxhash-4.0.1-cp315-cp315t-win_amd64.whl", hash = "sha256:daade8936c4deaaf7b01561324ce438ba4f885d717e9adc62b4d67212ad7d7bd", size = 37488, upload-time = "2026-08-17T08:36:19.929Z" },
+    { url = "https://files.pythonhosted.org/packages/fb/81/49f718beb0c55d0411bc4bd90b50a3fbe5863a0e97a2f4d11682ba13d298/xxhash-4.0.1-cp315-cp315t-win_arm64.whl", hash = "sha256:f00330ac7e24769e2032203f2b01794d670916b0c1799fd261340f1af9499875", size = 34590, upload-time = "2026-08-17T08:23:19.597Z" },
+]
diff --git a/uv.lock.license b/uv.lock.license
new file mode 100644
index 0000000..5a44073
--- /dev/null
+++ b/uv.lock.license
@@ -0,0 +1,3 @@
+SPDX-FileCopyrightText: 2026 Dennis Fink <me+coding@dennisfink.me>
+
+SPDX-License-Identifier: BSD-3-Clause
author	Dennis Fink	2026-09-20 20:04:13 +0200
committer	Dennis Fink	2026-09-20 20:04:13 +0200
commit	b751174b4ed7c23786ae54a1bbaf332f653faa81 (patch)
tree	c1951961b7bdd171aa4903d9e2d5ad4f2a063b51
download	duplicate-finder-1.0.0.tar.gz duplicate-finder-1.0.0.zip