dupefind 0.2.0__py3-none-any.whl

dupefind/__init__.py

@@ -0,0 +1,52 @@
+"""Find duplicate files by staged hashing: group by size, then partial hash, then full hash.
+
+Scanning only ever reads files. Clean-up is a separate, explicit step:
+``plan_actions`` decides, ``apply_actions`` acts, and only with ``dry_run=False``.
+"""
+
+from __future__ import annotations
+
+from ._actions import apply_actions, choose_keeper, plan_actions
+from ._find import find_duplicates, iter_duplicates, iter_groups, scan
+from ._json import SCHEMA_VERSION, report_to_dict, report_to_json
+from ._options import ScanOptions
+from ._types import (
+    Action,
+    ActionResult,
+    DuplicateFile,
+    DuplicateGroup,
+    IssueKind,
+    KeepPolicy,
+    PlannedAction,
+    Progress,
+    ScanIssue,
+    ScanReport,
+    ScanStats,
+)
+
+__version__ = "0.2.0"
+
+__all__ = [
+    "SCHEMA_VERSION",
+    "Action",
+    "ActionResult",
+    "DuplicateFile",
+    "DuplicateGroup",
+    "IssueKind",
+    "KeepPolicy",
+    "PlannedAction",
+    "Progress",
+    "ScanIssue",
+    "ScanOptions",
+    "ScanReport",
+    "ScanStats",
+    "apply_actions",
+    "choose_keeper",
+    "find_duplicates",
+    "iter_duplicates",
+    "iter_groups",
+    "plan_actions",
+    "report_to_dict",
+    "report_to_json",
+    "scan",
+]

dupefind/__main__.py

@@ -0,0 +1,7 @@
+"""Allow ``python -m dupefind``."""
+
+import sys
+
+from ._cli import main
+
+sys.exit(main())

dupefind/_act.py

@@ -0,0 +1,108 @@
+"""Carry out one verified action so that the data always exists under some name.
+
+The target is first renamed aside to a random name next to it and checked to be
+the file that was compared. Only then is it removed (delete), or a hard link to
+the kept file is created at the freed name (hardlink) before the aside copy is
+removed. While this happens the kept file is held open, which on Windows stops
+anyone deleting or renaming it. Anything unexpected puts the target back.
+"""
+
+from __future__ import annotations
+
+import os
+import secrets
+import stat
+from pathlib import Path
+
+from ._apply import pin, unchanged
+from ._types import ActionResult, PlannedAction
+
+
+def run(item: PlannedAction, kept: os.stat_result, target: os.stat_result) -> ActionResult:
+    """Act on a checked item after last identity checks. Never raises ``OSError``."""
+    try:
+        hold = open(item.keep, "rb")  # noqa: SIM115 - held across the whole act
+    except OSError as exc:
+        return ActionResult(item, "skipped", f"cannot open the kept copy: {exc}")
+    with hold:
+        reason = unchanged(item, kept, target)
+        if reason:
+            return ActionResult(item, "skipped", reason)
+        aside = _aside_name(item.target)
+        try:
+            os.rename(item.target, aside)
+        except OSError as exc:
+            return ActionResult(item, "failed", str(exc))
+        reason = _still_the_same(item, aside, kept, target)
+        if reason:
+            return ActionResult(item, "skipped", reason + _restore(aside, item.target))
+        try:
+            if item.action == "hardlink":
+                _link_in_place(item.keep, item.target, kept)
+        except OSError as exc:
+            return ActionResult(item, "failed", str(exc) + _restore(aside, item.target))
+        try:
+            os.remove(aside)
+        except OSError as exc:
+            return ActionResult(item, "failed", f"{exc}; the old copy is still at {aside}")
+    return ActionResult(item, "done")
+
+
+def _aside_name(target: Path) -> Path:
+    return target.with_name(f".{target.name}.{secrets.token_hex(6)}.dupefind")
+
+
+def _still_the_same(
+    item: PlannedAction, aside: Path, kept: os.stat_result, target: os.stat_result
+) -> str:
+    try:
+        moved = os.lstat(aside)
+        now_kept = os.stat(item.keep)
+    except OSError as exc:
+        return f"changed while acting: {exc}"
+    if pin(moved) != pin(target):
+        return "target was replaced or modified before acting"
+    if pin(now_kept) != pin(kept):
+        return "the kept copy was replaced or modified before acting"
+    return ""
+
+
+def _link_in_place(keep: Path, target: Path, kept: os.stat_result) -> None:
+    """Create a hard link to the real kept file at the (now free) target name."""
+    os.link(os.path.realpath(keep), target)  # fails if anything appeared there
+    made = os.lstat(target)
+    if not stat.S_ISREG(made.st_mode) or not os.path.samestat(made, kept):
+        _drop_link(target, keep)
+        raise OSError(f"the new link at {target} is not the kept file")
+
+
+def _restore(aside: Path, target: Path) -> str:
+    """Put the aside copy back without overwriting anything; describe a failure."""
+    try:
+        if os.name == "nt":
+            os.rename(aside, target)  # never replaces an existing file on Windows
+        else:
+            os.link(aside, target)  # never replaces an existing file
+            os.remove(aside)
+    except OSError as exc:
+        return f"; could not put it back ({exc}), it is at {aside}"
+    return ""
+
+
+def _drop_link(link: Path, keep: Path) -> None:
+    """Remove a link to the kept file, even when the kept file is read-only.
+
+    The read-only flag belongs to the file, so it is cleared just long enough to
+    remove the extra name and then put back on the kept file.
+    """
+    try:
+        os.remove(link)
+    except PermissionError:
+        mode = os.lstat(link).st_mode
+        if mode & stat.S_IWUSR:
+            raise
+        os.chmod(link, mode | stat.S_IWUSR)
+        try:
+            os.remove(link)
+        finally:
+            os.chmod(keep, mode)

dupefind/_actions.py

@@ -0,0 +1,99 @@
+"""Plan and apply clean-up actions on duplicate groups. Dry run unless told otherwise."""
+
+from __future__ import annotations
+
+import os
+from collections.abc import Iterable
+from pathlib import Path
+
+from ._act import run
+from ._apply import check
+from ._types import (
+    Action,
+    ActionResult,
+    DuplicateFile,
+    DuplicateGroup,
+    KeepPolicy,
+    PlannedAction,
+)
+
+ACTIONS: tuple[Action, ...] = ("delete", "hardlink")
+KEEP_POLICIES: tuple[KeepPolicy, ...] = ("first", "oldest", "newest", "shortest")
+
+
+def choose_keeper(group: DuplicateGroup, keep: KeepPolicy = "oldest") -> DuplicateFile:
+    """Return the file of ``group`` that ``keep`` says should survive.
+
+    A regular file is always preferred over a symlink (seen with
+    ``follow_symlinks``), so the real data is what survives. Ties are broken by
+    path, so the choice is deterministic.
+    """
+    real = [f for f in group.files if not os.path.islink(f.path)]
+    files = real or list(group.files)
+    if keep == "first":
+        return min(files, key=lambda f: str(f.path))
+    if keep == "oldest":
+        return min(files, key=lambda f: (f.mtime_ns, str(f.path)))
+    if keep == "newest":
+        return min(files, key=lambda f: (-f.mtime_ns, str(f.path)))
+    if keep == "shortest":
+        return min(files, key=lambda f: (len(str(f.path)), str(f.path)))
+    raise ValueError(f"unknown keep policy {keep!r}; choose one of {', '.join(KEEP_POLICIES)}")
+
+
+def plan_actions(
+    groups: Iterable[DuplicateGroup],
+    *,
+    action: Action = "delete",
+    keep: KeepPolicy = "oldest",
+) -> list[PlannedAction]:
+    """Plan ``action`` for every copy of every group except the one ``keep`` selects.
+
+    Exactly one file per group is kept, together with its hard-link aliases. Every
+    other file, and every alias of it, gets one planned action, so a delete really
+    frees the space. Planning touches nothing on disk.
+    """
+    if action not in ACTIONS:
+        raise ValueError(f"unknown action {action!r}; choose one of {', '.join(ACTIONS)}")
+    plan: list[PlannedAction] = []
+    for group in groups:
+        keeper = choose_keeper(group, keep)
+        for item in group.files:
+            if item is keeper:
+                continue
+            for target in (item.path, *item.aliases):
+                plan.append(PlannedAction(action, target, keeper.path, group.size, group.digest))
+    return plan
+
+
+def apply_actions(plan: Iterable[PlannedAction], *, dry_run: bool = True) -> list[ActionResult]:
+    """Carry out a plan. With the default ``dry_run=True`` nothing is changed.
+
+    Each action is verified right before it runs (and in a dry run). The target
+    must be a regular, writable file of its own (not a link, junction or read-only
+    file); the kept copy must exist; the two must not be the same file, must still
+    have the planned size and must be equal byte for byte. Just before the delete or
+    the replace, both are stat'ed once more and must still be the very files that
+    were compared. A target that is also a kept file in the plan is never touched.
+    Anything that fails a check is ``skipped`` with a reason; an OS error while
+    acting is ``failed``. Nothing is raised and the next action still runs.
+    """
+    actions = list(plan)
+    keepers = {_norm(item.keep) for item in actions}
+    results: list[ActionResult] = []
+    for item in actions:
+        if _norm(item.target) in keepers:
+            results.append(ActionResult(item, "skipped", "target is a kept file"))
+            continue
+        reason, pinned = check(item)
+        if pinned is None:
+            results.append(ActionResult(item, "skipped", reason))
+        elif dry_run:
+            results.append(ActionResult(item, "dry-run"))
+        else:
+            results.append(run(item, *pinned))
+    return results
+
+
+def _norm(path: Path) -> str:
+    return os.path.normcase(os.path.abspath(path))

dupefind/_apply.py

@@ -0,0 +1,75 @@
+"""Verify one planned action against the disk and carry it out. Refuse on any doubt."""
+
+from __future__ import annotations
+
+import os
+import stat
+
+from ._hash import same_content
+from ._streams import extra_streams
+from ._types import PlannedAction
+
+_MOUNT_POINT = 0xA0000003  # IO_REPARSE_TAG_MOUNT_POINT: a Windows junction
+
+
+def pin(info: os.stat_result) -> tuple[int, int, int, int, int]:
+    """The facts that must not change between the check and the act."""
+    return (info.st_dev, info.st_ino, info.st_size, info.st_mtime_ns, info.st_mode)
+
+
+def check(item: PlannedAction) -> tuple[str, tuple[os.stat_result, os.stat_result] | None]:
+    """Return ``("", (kept, target))`` when the action is safe, else a refusal reason.
+
+    ``target`` is stat'ed without following links: it must be a regular, writable
+    file of its own, so a link, a junction, a directory or a read-only file is never
+    removed or replaced.
+    """
+    try:
+        target = os.lstat(item.target)
+    except OSError as exc:
+        return f"cannot stat target: {exc}", None
+    if stat.S_ISLNK(target.st_mode) or getattr(target, "st_reparse_tag", 0) == _MOUNT_POINT:
+        return "target is a link; only regular files are acted on", None
+    if not stat.S_ISREG(target.st_mode):
+        return "target is not a regular file", None
+    if not target.st_mode & stat.S_IWUSR or not os.access(item.target, os.W_OK):
+        return "target is read-only", None
+    try:
+        kept = os.stat(item.keep)
+    except OSError as exc:
+        return f"cannot stat the kept copy: {exc}", None
+    if not stat.S_ISREG(kept.st_mode):
+        return "the kept copy is not a regular file", None
+    if os.path.samestat(kept, target):
+        return "already the same file as the kept copy", None
+    if kept.st_size != item.size or target.st_size != item.size:
+        return "size changed since the scan", None
+    if item.action == "hardlink" and kept.st_dev != target.st_dev:
+        return "on a different device than the kept copy", None
+    try:
+        equal = same_content(item.keep, item.target)
+    except OSError as exc:
+        return f"cannot compare: {exc}", None
+    if not equal:
+        return "content differs from the kept copy", None
+    try:
+        streams = extra_streams(item.target)
+    except OSError as exc:
+        return f"cannot list data streams: {exc}", None
+    if streams:
+        return f"target has extra data streams: {', '.join(streams)}", None
+    return "", (kept, target)
+
+
+def unchanged(item: PlannedAction, kept: os.stat_result, target: os.stat_result) -> str:
+    """Re-stat both files right before acting; return a reason if either moved on."""
+    try:
+        now_target = os.lstat(item.target)
+        now_kept = os.stat(item.keep)
+    except OSError as exc:
+        return f"changed before acting: {exc}"
+    if pin(now_target) != pin(target):
+        return "target was replaced or modified before acting"
+    if pin(now_kept) != pin(kept):
+        return "the kept copy was replaced or modified before acting"
+    return ""

dupefind/_cli.py

@@ -0,0 +1,133 @@
+"""Command line entry point: ``dupefind PATH...``."""
+
+from __future__ import annotations
+
+import argparse
+import os
+import sys
+from collections.abc import Sequence
+from typing import NoReturn, TextIO
+
+from . import __version__
+from ._actions import KEEP_POLICIES, apply_actions, plan_actions
+from ._cli_output import print_actions, print_groups, print_summary
+from ._find import scan
+from ._json import report_to_json
+from ._options import ScanOptions
+from ._types import Action, KeepPolicy
+
+_EXAMPLES = """\
+examples:
+  dupefind ~/Pictures                    list duplicate groups
+  dupefind a b --min-size 1M --json      scan two trees, files of 1 MiB or more, JSON out
+  dupefind . --exclude .git --exclude "*.tmp"
+  dupefind . --delete --keep oldest      show what would be deleted (dry run)
+  dupefind . --delete --keep oldest --apply   really delete the newer copies
+  dupefind . --hardlink --apply          replace copies with hard links to one file
+
+Nothing is changed unless --apply is given with --delete or --hardlink.
+With --delete or --hardlink, empty files are left alone unless --empty is given.
+Exit status: 0 on success, 1 on an error or a failed action.
+"""
+
+
+class _Parser(argparse.ArgumentParser):
+    def error(self, message: str) -> NoReturn:
+        self.print_usage(sys.stderr)
+        self.exit(1, f"{self.prog}: error: {message}\n")
+
+
+def parse_size(text: str) -> int:
+    """Parse a byte count with an optional K, M, G or T suffix (powers of 1024)."""
+    units = {"": 1, "K": 1 << 10, "M": 1 << 20, "G": 1 << 30, "T": 1 << 40}
+    raw = text.strip().upper().removesuffix("B").removesuffix("I")
+    suffix = raw[-1:] if raw[-1:] in units else ""
+    number = raw[: len(raw) - len(suffix)]
+    if not number.isdigit():
+        raise argparse.ArgumentTypeError(f"invalid size: {text!r}")
+    return int(number) * units[suffix]
+
+
+def build_parser() -> argparse.ArgumentParser:
+    """Return the argument parser used by ``main``."""
+    parser = _Parser(
+        prog="dupefind",
+        description="Find duplicate files by size, then partial hash, then full hash.",
+        epilog=_EXAMPLES,
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+    )
+    add = parser.add_argument
+    add("paths", nargs="+", metavar="PATH", help="directories or files to scan")
+    add("--version", action="version", version=f"%(prog)s {__version__}")
+    add("--json", action="store_true", help="print one JSON document instead of text")
+    add("--algorithm", default="sha256", help="hashlib algorithm (default: sha256)")
+    add("--partial-size", type=parse_size, default=4096, help="prefix bytes hashed first")
+    add("--min-size", type=parse_size, default=0, help="ignore smaller files (e.g. 10K)")
+    add("--max-size", type=parse_size, default=None, help="ignore larger files (e.g. 2G)")
+    add("--no-empty", action="store_true", help="ignore zero-length files")
+    add("--empty", action="store_true", help="let --delete/--hardlink act on empty files")
+    add("--include", action="append", default=[], metavar="GLOB", help="only these files")
+    add("--exclude", action="append", default=[], metavar="GLOB", help="skip files and dirs")
+    add("--follow-symlinks", action="store_true", help="follow symlinks and junctions")
+    add("--hardlinks", action="store_true", help="report hard links to one file as copies")
+    act = parser.add_mutually_exclusive_group()
+    act.add_argument("--delete", action="store_true", help="plan deleting all but one copy")
+    act.add_argument("--hardlink", action="store_true", help="plan linking copies to one")
+    add("--keep", choices=KEEP_POLICIES, default="oldest", help="copy to keep (default: oldest)")
+    add("--apply", action="store_true", help="carry out --delete or --hardlink")
+    add("-q", "--quiet", action="store_true", help="no summary or issues on stderr")
+    return parser
+
+
+def main(argv: Sequence[str] | None = None, *, stdout: TextIO | None = None) -> int:
+    """Run the command line tool and return its exit status."""
+    _tolerate_unencodable(sys.stderr)
+    out = stdout if stdout is not None else _tolerate_unencodable(sys.stdout)
+    parser = build_parser()
+    args = parser.parse_args(argv)
+    action: Action | None = "delete" if args.delete else "hardlink" if args.hardlink else None
+    if args.apply and action is None:
+        parser.error("--apply needs --delete or --hardlink")
+    if args.empty and (action is None or args.no_empty):
+        parser.error("--empty needs --delete or --hardlink and no --no-empty")
+    missing = [path for path in args.paths if not os.path.exists(path)]
+    if missing:
+        parser.error(f"no such file or directory: {missing[0]}")
+    try:
+        options = ScanOptions(
+            algorithm=args.algorithm,
+            partial_size=args.partial_size,
+            min_size=args.min_size,
+            max_size=args.max_size,
+            include_empty=not args.no_empty and (action is None or args.empty),
+            include=tuple(args.include),
+            exclude=tuple(args.exclude),
+            follow_symlinks=args.follow_symlinks,
+            hardlinks=args.hardlinks,
+        )
+    except ValueError as exc:
+        parser.error(str(exc))
+    report = scan(*args.paths, options=options)
+    results = None
+    if action is not None:
+        keep: KeepPolicy = args.keep
+        plan = plan_actions(report.groups, action=action, keep=keep)
+        results = apply_actions(plan, dry_run=not args.apply)
+    if args.json:
+        out.write(report_to_json(report, results) + "\n")
+    else:
+        print_groups(report, out)
+        if results is not None:
+            print_actions(results, out)
+    if not args.quiet:
+        print_summary(report, results, sys.stderr)
+    failed = results is not None and any(r.status == "failed" for r in results)
+    return 1 if failed else 0
+
+
+def _tolerate_unencodable(stream: TextIO) -> TextIO:
+    """Write paths the console encoding cannot show as escapes instead of failing."""
+    reconfigure = getattr(stream, "reconfigure", None)
+    if reconfigure is not None:
+        reconfigure(errors="backslashreplace")
+    return stream

dupefind/_cli_output.py

@@ -0,0 +1,50 @@
+"""Plain-text rendering for the command line tool."""
+
+from __future__ import annotations
+
+from collections.abc import Sequence
+from typing import TextIO
+
+from ._types import ActionResult, ScanReport
+
+
+def print_groups(report: ScanReport, out: TextIO) -> None:
+    """Print each group as a header line, its paths, then a blank line."""
+    for group in report.groups:
+        count = len(group.files)
+        header = f"# {group.size} bytes x {count} files, {group.algorithm}:{group.digest}"
+        out.write(header + "\n")
+        for item in group.files:
+            out.write(f"{item.path}\n")
+            for alias in item.aliases:
+                out.write(f"  = {alias}\n")
+        out.write("\n")
+
+
+def print_actions(results: Sequence[ActionResult], out: TextIO) -> None:
+    """Print one line per action: status, action, target and the kept copy."""
+    for result in results:
+        item = result.planned
+        line = f"[{result.status}] {item.action} {item.target} (keep {item.keep})"
+        if result.reason:
+            line += f": {result.reason}"
+        out.write(line + "\n")
+
+
+def print_summary(report: ScanReport, results: Sequence[ActionResult] | None, err: TextIO) -> None:
+    """Print skipped paths and a one-line summary to the error stream."""
+    for issue in report.issues:
+        err.write(f"dupefind: skipped {issue.path} ({issue.kind}): {issue.message}\n")
+    stats = report.stats
+    line = (
+        f"dupefind: {stats.groups} groups, {stats.duplicate_files} files, "
+        f"{stats.wasted_bytes} bytes reclaimable, {len(report.issues)} issues"
+    )
+    if results is not None:
+        counts: dict[str, int] = {}
+        for result in results:
+            counts[result.status] = counts.get(result.status, 0) + 1
+        line += "; actions: " + ", ".join(f"{n} {s}" for s, n in sorted(counts.items()))
+        if not results:
+            line += "none"
+    err.write(line + "\n")

dupefind/_find.py

@@ -0,0 +1,117 @@
+"""Staged duplicate detection: size, then a partial hash, then a full hash."""
+
+from __future__ import annotations
+
+import dataclasses
+import os
+from collections.abc import Callable, Iterator
+from pathlib import Path
+
+from ._options import ScanOptions
+from ._scan import Walker, group_by_size
+from ._stages import Stages
+from ._types import DuplicateGroup, Progress, ScanIssue, ScanReport, ScanStats
+
+PathLike = str | os.PathLike[str]
+ProgressCallback = Callable[[Progress], None]
+
+
+def iter_groups(
+    *roots: PathLike,
+    options: ScanOptions | None = None,
+    on_progress: ProgressCallback | None = None,
+    issues: list[ScanIssue] | None = None,
+    stats: ScanStats | None = None,
+) -> Iterator[DuplicateGroup]:
+    """Stream ``DuplicateGroup`` objects for files under ``roots`` as they are confirmed.
+
+    Each root may be a directory (walked recursively) or a single file. Roots that
+    are links are followed; links found inside them are not, unless
+    ``options.follow_symlinks`` is true. A file reached twice (overlapping roots, a
+    loop) is compared once. Files are only read, never changed.
+
+    The work is staged so that most files are never read in full:
+
+    1. walk and group by size; a unique size cannot have a duplicate;
+    2. merge names of the same file (hard links) unless ``options.hardlinks``;
+    3. hash the first ``options.partial_size`` bytes of same-size files;
+    4. hash in full only files that still match, and re-check that each file's size
+       and modification time did not change while it was being read.
+
+    Paths that cannot be used are appended to ``issues`` (when given) and left out.
+    ``stats`` (when given) is filled in while the generator runs. Groups of larger
+    files come first.
+    """
+    opts = options if options is not None else ScanOptions()
+    sink: list[ScanIssue] = issues if issues is not None else []
+    counters = stats if stats is not None else ScanStats()
+    walker = Walker(opts, sink, on_progress)
+    entries = walker.walk(roots)
+    counters.files_seen = len(entries)
+    stages = Stages(walker, counters)
+    by_size = group_by_size(entries)
+    candidates = [stages.identify(by_size[size]) for size in sorted(by_size, reverse=True)]
+    yield from stages.run([group for group in candidates if group])
+
+
+def scan(
+    *roots: PathLike,
+    options: ScanOptions | None = None,
+    on_progress: ProgressCallback | None = None,
+) -> ScanReport:
+    """Scan ``roots`` and return a ``ScanReport`` with groups, issues and counters.
+
+    This is ``iter_groups`` collected into one object. See it for the staging and
+    the link policies. Nothing on disk is modified.
+    """
+    report = ScanReport()
+    report.groups = list(
+        iter_groups(
+            *roots,
+            options=options,
+            on_progress=on_progress,
+            issues=report.issues,
+            stats=report.stats,
+        )
+    )
+    return report
+
+
+def iter_duplicates(
+    root: PathLike,
+    *,
+    follow_symlinks: bool = False,
+    options: ScanOptions | None = None,
+) -> Iterator[tuple[str, list[Path]]]:
+    """Yield ``(full hash, paths)`` for every set of two or more identical files.
+
+    The original ``0.1.0`` interface, kept for compatibility. ``options`` adds every
+    scan setting; ``follow_symlinks=True`` turns link following on in either case.
+    Paths are the first name reached for each file; hard links to the same file are
+    one file here (see ``ScanOptions.hardlinks``). Use ``iter_groups`` for typed
+    results and ``scan`` for the issues met.
+    """
+    opts = _with_follow(options, follow_symlinks)
+    for group in iter_groups(root, options=opts):
+        yield group.digest, group.paths
+
+
+def find_duplicates(
+    root: PathLike,
+    *,
+    follow_symlinks: bool = False,
+    options: ScanOptions | None = None,
+) -> dict[str, list[Path]]:
+    """Return duplicate files under ``root`` grouped by their full content hash.
+
+    Each value holds two or more paths with identical content; files with no
+    duplicate are left out. Nothing on disk is modified. See ``iter_duplicates``.
+    """
+    return dict(iter_duplicates(root, follow_symlinks=follow_symlinks, options=options))
+
+
+def _with_follow(options: ScanOptions | None, follow_symlinks: bool) -> ScanOptions:
+    opts = options if options is not None else ScanOptions()
+    if follow_symlinks and not opts.follow_symlinks:
+        opts = dataclasses.replace(opts, follow_symlinks=True)
+    return opts