quick-md5check 1.0.0__py3-none-any.whl

md5check/__init__.py

@@ -0,0 +1,21 @@
+"""md5check: Multi-threaded MD5 checksum generator and verifier."""
+
+__version__ = "1.0.0"
+
+from md5check.core import (
+    compute_md5,
+    generate_hashes,
+    generate_directory,
+    parse_md5_file,
+    verify_directory,
+    verify_hashes,
+)
+
+__all__ = [
+    "compute_md5",
+    "generate_hashes",
+    "generate_directory",
+    "parse_md5_file",
+    "verify_directory",
+    "verify_hashes",
+]

md5check/__main__.py

@@ -0,0 +1,5 @@
+"""Allow running as `python -m md5check`."""
+from md5check.cli import main
+
+if __name__ == "__main__":
+    main()

md5check/cli.py

@@ -0,0 +1,152 @@
+"""Command-line interface for md5check."""
+
+import argparse
+import os
+import sys
+from pathlib import Path
+from typing import List, Optional
+
+from md5check import __version__
+from md5check.core import generate_directory, verify_directory
+
+
+def _positive_int(value: str) -> int:
+    """Argument type validator for positive integers."""
+    try:
+        n = int(value)
+    except ValueError:
+        raise argparse.ArgumentTypeError(f"invalid integer: {value!r}")
+    if n < 1:
+        raise argparse.ArgumentTypeError(f"must be >= 1, got {n}")
+    return n
+
+
+def build_parser() -> argparse.ArgumentParser:
+    """Build the argument parser."""
+    parser = argparse.ArgumentParser(
+        prog="md5check",
+        description="Multi-threaded MD5 checksum generator and verifier.",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog=(
+            "Examples:\n"
+            "  md5check generate ./myfiles -j 4 -o checksums.md5\n"
+            "  md5check check checksums.md5 -j 4\n"
+        ),
+    )
+    parser.add_argument(
+        "--version",
+        action="version",
+        version=f"%(prog)s {__version__}",
+    )
+
+    sub = parser.add_subparsers(dest="command", required=True)
+
+    # --- generate ---
+    gen = sub.add_parser(
+        "generate",
+        aliases=["gen"],
+        help="Generate MD5 checksums for all files in a directory",
+        description=(
+            "Scan a directory and compute MD5 checksums for every file "
+            "using multiple threads."
+        ),
+    )
+    gen.add_argument(
+        "directory",
+        type=Path,
+        help="Directory to scan",
+    )
+    gen.add_argument(
+        "-o", "--output",
+        type=Path,
+        help="Output file (default: stdout)",
+    )
+    gen.add_argument(
+        "-j", "--jobs",
+        type=_positive_int,
+        default=os.cpu_count() or 1,
+        help=(
+            f"Number of worker threads (default: {os.cpu_count() or 1})"
+        ),
+    )
+    gen.add_argument(
+        "--no-recursive",
+        action="store_true",
+        help="Do not scan subdirectories",
+    )
+
+    # --- check ---
+    chk = sub.add_parser(
+        "check",
+        help="Verify MD5 checksums from a file",
+        description=(
+            "Read an md5sum-format file and verify every file's "
+            "checksum using multiple threads."
+        ),
+    )
+    chk.add_argument(
+        "md5file",
+        type=Path,
+        help="Path to the md5sum-format file",
+    )
+    chk.add_argument(
+        "-j", "--jobs",
+        type=_positive_int,
+        default=os.cpu_count() or 1,
+        help=(
+            f"Number of worker threads (default: {os.cpu_count() or 1})"
+        ),
+    )
+    chk.add_argument(
+        "-C", "--directory",
+        type=Path,
+        default=None,
+        help=(
+            "Base directory for relative paths in the md5 file. "
+            "Defaults to the md5 file's parent directory."
+        ),
+    )
+
+    return parser
+
+
+def main(argv: Optional[List[str]] = None) -> int:
+    """Entry point for the ``md5check`` console script."""
+    parser = build_parser()
+    args = parser.parse_args(argv)
+
+    if args.command in ("generate", "gen"):
+        directory = args.directory.resolve()
+        if not directory.is_dir():
+            print(f"Error: {directory} is not a directory or does not exist.", file=sys.stderr)
+            return 1
+        generate_directory(
+            directory=directory,
+            num_threads=args.jobs,
+            recursive=not args.no_recursive,
+            output=args.output,
+        )
+        return 0
+
+    elif args.command == "check":
+        md5file = args.md5file.resolve()
+        if not md5file.is_file():
+            print(f"Error: {md5file} is not a file or does not exist.", file=sys.stderr)
+            return 1
+        base_dir = (
+            args.directory.resolve()
+            if args.directory is not None
+            else md5file.parent.resolve()
+        )
+        verify_directory(
+            md5_file=md5file,
+            base_dir=base_dir,
+            num_threads=args.jobs,
+        )
+        return 0
+
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

md5check/core.py

@@ -0,0 +1,253 @@
+"""Core MD5 computation logic with multi-threading support."""
+
+import hashlib
+import os
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Iterator, List, Optional, Tuple
+
+from tqdm import tqdm
+
+CHUNK_SIZE = 64 * 1024  # 64 KB
+
+
+def compute_md5(file_path: Path) -> str:
+    """Compute MD5 hex digest of a single file.
+
+    Reads the file in 64 KB chunks to handle large files efficiently.
+    """
+    h = hashlib.md5()
+    with open(file_path, "rb") as f:
+        while True:
+            chunk = f.read(CHUNK_SIZE)
+            if not chunk:
+                break
+            h.update(chunk)
+    return h.hexdigest()
+
+
+def _collect_files(directory: Path, recursive: bool = True) -> List[Path]:
+    """Recursively or non-recursively collect all regular files in a directory."""
+    if not directory.is_dir():
+        raise NotADirectoryError(f"{directory} is not a directory")
+
+    if recursive:
+        # sorted for deterministic output ordering
+        files = sorted(
+            p for p in directory.rglob("*") if p.is_file()
+        )
+    else:
+        files = sorted(
+            p for p in directory.iterdir() if p.is_file()
+        )
+    return files
+
+
+@dataclass
+class Md5Entry:
+    """Represents a single line in an md5sum-format file."""
+    expected_hash: str
+    filepath: str          # relative path as stored in the md5 file
+    full_path: Optional[Path] = None   # resolved after base dir is known
+
+    def __post_init__(self):
+        self.expected_hash = self.expected_hash.strip().lower()
+
+
+@dataclass
+class VerifyResult:
+    """Result of verifying a single file's MD5."""
+    filepath: str
+    status: str            # "OK" | "FAILED" | "MISSING"
+    expected: str
+    actual: str = ""
+
+
+def parse_md5_file(md5_path: Path, base_dir: Path) -> List[Md5Entry]:
+    """Parse a standard md5sum file.
+
+    Format per line:  <32-char-hex>  <filename>
+    Lines starting with '#' are comments; blank lines are skipped.
+    """
+    entries: List[Md5Entry] = []
+    with open(md5_path, "r", encoding="utf-8", errors="replace") as f:
+        for line in f:
+            line = line.strip()
+            if not line or line.startswith("#"):
+                continue
+            # md5sum format:  <hash>  <filename>
+            parts = line.split(None, 1)
+            if len(parts) != 2:
+                continue
+            hash_str, rel_path = parts
+            if len(hash_str) != 32:
+                continue
+            full = (base_dir / rel_path).resolve()
+            entries.append(Md5Entry(
+                expected_hash=hash_str,
+                filepath=rel_path,
+                full_path=full,
+            ))
+    return entries
+
+
+def generate_hashes(
+    paths: List[Path],
+    num_threads: int,
+    *,
+    desc: str = "Generating MD5",
+    unit: str = "file",
+) -> Iterator[Tuple[Path, str]]:
+    """Compute MD5 for each file path using a thread pool.
+
+    Yields ``(path, hex_digest)`` tuples as they complete.
+    """
+    with ThreadPoolExecutor(max_workers=num_threads) as executor:
+        fut_to_path = {
+            executor.submit(compute_md5, p): p
+            for p in paths
+        }
+        with tqdm(total=len(fut_to_path), desc=desc, unit=unit) as pbar:
+            for future in as_completed(fut_to_path):
+                path = fut_to_path[future]
+                try:
+                    digest = future.result()
+                except Exception as exc:
+                    digest = f"ERROR: {exc}"
+                yield path, digest
+                pbar.update(1)
+
+
+def generate_directory(
+    directory: Path,
+    num_threads: int,
+    *,
+    recursive: bool = True,
+    output: Optional[Path] = None,
+) -> None:
+    """Generate MD5 hashes for all files in a directory.
+
+    Writes to *output* if given, otherwise prints to stdout.
+    The format is standard md5sum: ``<hash>  <relpath>``
+
+    Results are sorted alphabetically by path before output so the
+    result is deterministic regardless of thread scheduling.
+    """
+    files = _collect_files(directory, recursive=recursive)
+    if not files:
+        print("No files found.")
+        return
+
+    results: List[Tuple[Path, str]] = []
+    for path, digest in generate_hashes(files, num_threads):
+        results.append((path, digest))
+
+    # sort by relative path for deterministic output
+    results.sort(key=lambda x: x[0])
+
+    lines: List[str] = []
+    for path, digest in results:
+        rel = path.relative_to(directory).as_posix()
+        lines.append(f"{digest}  {rel}")
+
+    output_lines = "\n".join(lines)
+    if output:
+        output.write_text(output_lines + "\n", encoding="utf-8")
+        print(f"MD5 checksums written to {output}")
+    else:
+        print(output_lines)
+
+
+def verify_hashes(
+    entries: List[Md5Entry],
+    num_threads: int,
+    *,
+    desc: str = "Verifying MD5",
+    unit: str = "file",
+) -> Iterator[VerifyResult]:
+    """Verify each Md5Entry against its file on disk.
+
+    Yields ``VerifyResult`` objects as each file completes.
+    """
+    def _verify_one(entry: Md5Entry) -> VerifyResult:
+        if entry.full_path is None or not entry.full_path.is_file():
+            return VerifyResult(
+                filepath=entry.filepath,
+                status="MISSING",
+                expected=entry.expected_hash,
+            )
+        try:
+            actual = compute_md5(entry.full_path)
+        except Exception as exc:
+            return VerifyResult(
+                filepath=entry.filepath,
+                status="FAILED",
+                expected=entry.expected_hash,
+                actual=str(exc),
+            )
+        status = "OK" if actual == entry.expected_hash else "FAILED"
+        return VerifyResult(
+            filepath=entry.filepath,
+            status=status,
+            expected=entry.expected_hash,
+            actual=actual,
+        )
+
+    with ThreadPoolExecutor(max_workers=num_threads) as executor:
+        futures = {executor.submit(_verify_one, e): e for e in entries}
+        with tqdm(total=len(futures), desc=desc, unit=unit) as pbar:
+            for future in as_completed(futures):
+                result = future.result()
+                yield result
+                pbar.update(1)
+
+
+def verify_directory(
+    md5_file: Path,
+    base_dir: Path,
+    num_threads: int,
+) -> None:
+    """Verify files listed in an md5sum file against their checksums.
+
+    Base directory for relative paths is *base_dir* (usually the
+    directory containing the md5 file).  Prints a summary: OK / FAILED
+    / MISSING counts, and details for non-OK results.
+    """
+    entries = parse_md5_file(md5_file, base_dir)
+    if not entries:
+        print("No valid MD5 entries found in", md5_file)
+        return
+
+    ok_count = 0
+    failed: List[VerifyResult] = []
+    missing: List[VerifyResult] = []
+
+    for result in verify_hashes(entries, num_threads):
+        if result.status == "OK":
+            ok_count += 1
+        elif result.status == "FAILED":
+            failed.append(result)
+        else:
+            missing.append(result)
+
+    # Print summary
+    total = len(entries)
+    print(f"\n{'='*50}")
+    print(f"Verification complete: {total} file(s)")
+    print(f"  OK:      {ok_count}")
+    print(f"  FAILED:  {len(failed)}")
+    print(f"  MISSING: {len(missing)}")
+    print(f"{'='*50}")
+
+    if failed:
+        print("\n--- FAILED ---")
+        for r in failed:
+            print(f"  {r.filepath}")
+            print(f"    expected: {r.expected}")
+            print(f"    actual:   {r.actual}")
+
+    if missing:
+        print("\n--- MISSING ---")
+        for r in missing:
+            print(f"  {r.filepath}")

quick_md5check-1.0.0.dist-info/METADATA

@@ -0,0 +1,134 @@
+Metadata-Version: 2.4
+Name: quick_md5check
+Version: 1.0.0
+Summary: Multi-threaded MD5 checksum generator and verifier
+Author: lg10is1
+License: MIT
+Project-URL: Homepage, https://github.com/lg10is1/quick_md5check
+Project-URL: Repository, https://github.com/lg10is1/quick_md5check
+Project-URL: BugTracker, https://github.com/lg10is1/quick_md5check/issues
+Keywords: md5,checksum,multi-threaded,parallel
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Utilities
+Classifier: Topic :: System :: Archiving :: Backup
+Classifier: Topic :: Security :: Cryptography
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: tqdm>=4.60.0
+Dynamic: license-file
+Dynamic: requires-python
+
+# Quick_md5check
+
+Multi-threaded MD5 checksum generator and verifier. Computes and verifies MD5 hashes for many files in parallel — significantly faster than single-threaded `md5sum` on multi-core systems.
+
+## Features
+
+- **Multi-threaded** — configurable thread count via `-j`/`--jobs`
+- **Generate mode** — scan a directory and compute MD5 for every file
+- **Check mode** — verify files against an `md5sum`-format file
+- **Cross-platform** — Windows, Linux, macOS
+- **Standard output format** — compatible with GNU `md5sum` and `md5sum -c`
+- **Progress bar** — real-time feedback via `tqdm`
+- **Recursive scan** — optionally disable with `--no-recursive`
+
+## Installation
+
+### pip
+```bash
+pip install quick_md5check
+```
+
+### conda
+```bash
+conda install -c your-channel quick_md5check
+```
+
+### From source
+```bash
+git clone https://github.com/lg10is1/quick_md5check.git
+cd md5check
+pip install -e .
+```
+
+## Usage
+
+### Generate checksums
+```bash
+# Use all available CPU cores
+md5check generate ./myfiles -o checksums.md5
+
+# Use 8 worker threads
+md5check generate ./myfiles -j 8 -o checksums.md5
+
+# Non-recursive (top-level files only)
+md5check generate ./myfiles --no-recursive -o checksums.md5
+
+# Print to stdout
+md5check generate ./myfiles
+```
+
+### Verify checksums
+```bash
+# Verify using checksum file, auto-detect base dir
+md5check check checksums.md5
+
+# Use 8 worker threads
+md5check check checksums.md5 -j 8
+
+# Specify base directory for relative paths
+md5check check checksums.md5 -C ./myfiles
+```
+
+### Compatible with GNU md5sum
+```bash
+# Generate (GNU md5sum format)
+md5sum myfiles/* > checksums.md5
+
+# Verify with md5check
+md5check check checksums.md5
+
+# Generate with md5check, verify with GNU md5sum
+md5check generate ./myfiles -o checksums.md5
+md5sum -c checksums.md5
+```
+
+## Output format
+
+Standard `md5sum` format — one entry per line:
+
+```
+d41d8cd98f00b204e9800998ecf8427e  path/to/empty.txt
+900150983cd24fb0d6963f7d28e17f72  path/to/hello.txt
+```
+
+## Development
+
+### Run from source
+```bash
+python -m md5check generate ./tests/data -j 4
+```
+
+### Build
+```bash
+# Install build dependencies
+pip install build
+
+# Build wheel and source distribution
+python -m build
+```
+
+## License
+
+MIT

quick_md5check-1.0.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+md5check/__init__.py,sha256=-gGBCmwAPe7cGVLGxRPawxAXI-yl0sa28bus7qozCL4,395
+md5check/__main__.py,sha256=lGYpT51iW7h_jaP6D3NYxGMlds5Rk9p_Blend1eE90U,114
+md5check/cli.py,sha256=5OwlbqJ_cO4aceFppsGq0OpBVc9u4M21Kx5uApRlNR4,4146
+md5check/core.py,sha256=0U7AVA8pOAITSE1NiDaebywgzcNAoIKilkYrdAHWfUo,7670
+quick_md5check-1.0.0.dist-info/licenses/LICENSE,sha256=A864Jj0HEiav2-1Ws-KacJr8rZMW5Nnk3k1HK3JJnoI,1078
+quick_md5check-1.0.0.dist-info/METADATA,sha256=co7ZNocN4_5adEoR3eHCSP9N1IN0PgHV9fodAVdOahQ,3442
+quick_md5check-1.0.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+quick_md5check-1.0.0.dist-info/entry_points.txt,sha256=9n-DRaHH_HkX_IfiulHB_Q2ZXO8oU6SNqEZaoXqseU8,47
+quick_md5check-1.0.0.dist-info/top_level.txt,sha256=JdxmmsLyWEyK7etIfTE9ErRwOciQNbedqqTC_Cbpl6c,9
+quick_md5check-1.0.0.dist-info/RECORD,,

quick_md5check-1.0.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

quick_md5check-1.0.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+md5check = md5check.cli:main

quick_md5check-1.0.0.dist-info/licenses/LICENSE

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

quick_md5check-1.0.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+md5check