cdhit-reader 0.3.0__tar.gz → 0.5.0__tar.gz

{cdhit_reader-0.3.0/cdhit_reader.egg-info → cdhit_reader-0.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cdhit-reader
-Version: 0.3.0
+Version: 0.5.0
 Summary: CD-HIT cluster parser
 Home-page: https://github.com/telatin/cdhit-parser
 Download-URL: https://github.com/telatin/cdhit-parser
@@ -60,6 +60,24 @@ Load all clusters in to a list:
 clusters = read_cdhit(input).read_items()
 ```
 
+### Sequence to cluster lookup
+
+`Clustering` loads a whole .clstr file and provides a reverse index
+(`seqcluster`) mapping each sequence name to the name of its cluster:
+
+```python
+from cdhit_reader import Clustering
+
+clustering = Clustering.from_file(input)
+
+print(len(clustering))                      # number of clusters
+for cluster in clustering:                  # iterate over the clusters
+    print(cluster.name)
+
+# Which cluster does a sequence belong to?
+print(clustering.seqcluster["seq1.A"])      # e.g. "Cluster 0"
+```
+
 ## Read FASTA file
 
 ```python

{cdhit_reader-0.3.0 → cdhit_reader-0.5.0}/README.md

@@ -29,6 +29,24 @@ Load all clusters in to a list:
 clusters = read_cdhit(input).read_items()
 ```
 
+### Sequence to cluster lookup
+
+`Clustering` loads a whole .clstr file and provides a reverse index
+(`seqcluster`) mapping each sequence name to the name of its cluster:
+
+```python
+from cdhit_reader import Clustering
+
+clustering = Clustering.from_file(input)
+
+print(len(clustering))                      # number of clusters
+for cluster in clustering:                  # iterate over the clusters
+    print(cluster.name)
+
+# Which cluster does a sequence belong to?
+print(clustering.seqcluster["seq1.A"])      # e.g. "Cluster 0"
+```
+
 ## Read FASTA file
 
 ```python

{cdhit_reader-0.3.0 → cdhit_reader-0.5.0}/cdhit_reader/__init__.py

@@ -1,6 +1,6 @@
 from importlib import import_module
 
-from ._reader import ParsingError, ClusterSequence, Cluster, ClstrReader, read_cdhit, SeqType, Strand
+from ._reader import ParsingError, ClusterSequence, Cluster, Clustering, ClstrReader, read_cdhit, SeqType, Strand
 from ._fasta import FastaParsingError, Sequence, FastaReader, read_fasta
 from ._version import __version__
 
@@ -15,6 +15,7 @@ __all__ = [
     "FastaParsingError",
     "ClusterSequence",
     "Cluster",
+    "Clustering",
     "ClstrReader",
     "read_cdhit",
     "FastaReader",

{cdhit_reader-0.3.0 → cdhit_reader-0.5.0}/cdhit_reader/_cli.py

@@ -1,12 +1,9 @@
-
-import sys
 from statistics import mean
 
 import click
 
 from ._reader import read_cdhit
 from ._version import __version__
-#from ._writer import write_fasta
 
 
 @click.command(context_settings=dict(help_option_names=["-h", "--help"]))
@@ -22,31 +19,33 @@ def cli(clstr, stats: bool, hist: bool, all: bool):
     \b
     Warning
     -------
-    The commad line interface is in EXPERIMENTAL stage.  
+    The commad line interface is in EXPERIMENTAL stage.
     """
 
     nitems = 0
     nseqs = 0
     seq_lens = []
-    for item in read_cdhit(clstr):
-        seq_lens.append(len(item))
-        nitems += 1
-        nseqs  += len(item)
-        if all:
-            print(item)
-            for s in item.sequences:
-                print(f"   {s}")
+    with read_cdhit(clstr) as reader:
+        for item in reader:
+            seq_lens.append(len(item))
+            nitems += 1
+            nseqs += len(item)
+            if all:
+                print(item)
+                for s in item.sequences:
+                    print(f"   {s}")
     if stats:
         click.echo(f"Input file: {clstr}")
         click.echo(f"Number of clusters: {nitems}")
         click.echo(f"Total sequences: {nseqs}")
-        
-        msg = f"Cluster size: min {min(seq_lens)}, mean {mean(seq_lens):.2f}, max {max(seq_lens)}"
-        click.echo(msg)
+
+        if seq_lens:
+            msg = f"Cluster size: min {min(seq_lens)}, mean {mean(seq_lens):.2f}, max {max(seq_lens)}"
+            click.echo(msg)
 
     if hist:
         show_hist(seq_lens)
 
 
 def show_hist(seq_lens):
-    pass
+    pass

{cdhit_reader-0.3.0 → cdhit_reader-0.5.0}/cdhit_reader/_compare.py

@@ -1,26 +1,35 @@
-from email.policy import default
 import sys
-from statistics import mean
+import os
+import subprocess
+import tempfile
 
 import click
+from xopen import xopen
 
 from ._reader import read_cdhit
 from ._version import __version__
-from xopen import xopen
-import os
-import tempfile
-import subprocess
+
+TAG1 = "1:::"
+TAG2 = "2:::"
+
 
 def has_cdhit():
     cmd = ["cd-hit", "-h"]
-    # Run cmd and save stdout as "cdout" variable, ignore exit status
+    # Run cmd and inspect stdout, ignore exit status
     try:
         cdout = subprocess.run(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE).stdout.decode("utf-8")
-        if "CD-HIT" in cdout:
-            return True
+        return "CD-HIT" in cdout
     except Exception:
         return False
-  
+
+
+def strip_tag(name: str) -> str:
+    """
+    Remove the relabeling prefix (TAG1/TAG2, same length) from a sequence name.
+    """
+    return name[len(TAG1):]
+
+
 def read_fasta(path):
     name = None
     comment = ""
@@ -38,11 +47,13 @@ def read_fasta(path):
                 seq += line
     yield name, comment, seq
 
+
 def relabel_fasta(path, prefix, outpath):
     with xopen(outpath, "a") as out:
         for name, comment, seq in read_fasta(path):
             out.write(">{}{}{}{}\n{}\n".format(prefix, name, " " if len(comment) > 1 else "", comment, seq))
 
+
 def split_cluster(cluster, tag1, tag2):
     pool1, pool2 = [], []
     for sequence in cluster.sequences:
@@ -52,17 +63,19 @@ def split_cluster(cluster, tag1, tag2):
             pool2.append(sequence)
         else:
             raise ValueError("Sequence {} does not start with {} or {}".format(sequence.name, tag1, tag2))
+
+
 @click.command(context_settings=dict(help_option_names=["-h", "--help"]))
 @click.version_option(__version__)
 @click.argument("fasta1", type=click.Path(exists=True))
 @click.argument("fasta2", type=click.Path(exists=True))
-@click.option("--tag1",   help="Name of the first dataset")
-@click.option("--tag2",  help="Name of the second dataset")
+@click.option("--tag1", help="Name of the first dataset")
+@click.option("--tag2", help="Name of the second dataset")
 @click.option("--id", help="Identity threshold [default: 0.9]", default=0.95, type=float)
 @click.option("--type", type=click.STRING, help="Type of the sequences (nucl or prot)")
-@click.option("--tempdir",type=click.Path(exists=True), help="Temporary directory for intermediate files", default=tempfile.gettempdir())
+@click.option("--tempdir", type=click.Path(exists=True), help="Temporary directory for intermediate files", default=tempfile.gettempdir())
 @click.option("--verbose", default=False, is_flag=True, help="Show verbose information")
-def compare(fasta1, fasta2, tag1: str, tag2: str, tempdir, type: str, id: float,verbose: bool):
+def compare(fasta1, fasta2, tag1: str, tag2: str, tempdir, type: str, id: float, verbose: bool):
     """
     Compare FASTA files
 
@@ -75,12 +88,9 @@ def compare(fasta1, fasta2, tag1: str, tag2: str, tempdir, type: str, id: float,
         click.echo("cd-hit is not installed. Please install it and try again.")
         sys.exit(1)
     # Generate temporary directory inside "tempdir"
-    TAG1      = "1:::"
-    TAG2      = "2:::"
     # tmp is a temporary directory not to be deleted
     tmp = tempfile.mkdtemp(dir=tempdir, prefix="cdhit_")
 
-    #tmp = tempfile.TemporaryDirectory(dir=tempdir, prefix="cdhit_reader_", suffix=".tmp")
     if verbose:
         print("Temporary directory: {}".format(tmp), file=sys.stderr)
 
@@ -97,42 +107,41 @@ def compare(fasta1, fasta2, tag1: str, tag2: str, tempdir, type: str, id: float,
     if prefix1 == prefix2:
         print("Warning: prefixes are identical ({}): specify manual prefixes with --tag1 and --tag2".format(prefix1))
         exit(1)
-    
+
     # Delete fasta_file if present:
     if os.path.exists(fasta_file):
         os.remove(fasta_file)
-    
+
     if verbose:
         print("Relabeling {} to {}".format(fasta1, fasta_file), file=sys.stderr)
-    
+
     relabel_fasta(fasta1, TAG1, fasta_file)
 
     if verbose:
         print("Relabeling {} to {}".format(fasta2, fasta_file), file=sys.stderr)
-    
+
     relabel_fasta(fasta2, TAG2, fasta_file)
 
     tags = {
         TAG1: prefix1,
         TAG2: prefix2
-    } 
+    }
     if verbose:
         print("Relabeling {} to {} (prefix: {})".format(fasta1, fasta_file, prefix1), file=sys.stderr)
         print("Relabeling {} to {} (prefix: {})".format(fasta2, fasta_file, prefix2), file=sys.stderr)
-        
-    cmd = ["cd-hit" if type=="prot" else "cd-hit-est", "-i", fasta_file, "-o", clstr_file, "-c", str(id), "-d", "1000"]
+
+    cmd = ["cd-hit" if type == "prot" else "cd-hit-est", "-i", fasta_file, "-o", clstr_file, "-c", str(id), "-d", "1000"]
     if verbose:
         print("Running {}".format(" ".join(cmd)), file=sys.stderr)
     subprocess.run(cmd, check=True, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
 
-
-    stats = {TAG1: [], TAG2: [], "both": [], "multi": [], "dupl_" + TAG1: [],  "dupl_" + TAG2: []}
+    stats = {TAG1: [], TAG2: [], "both": [], "multi": [], "dupl_" + TAG1: [], "dupl_" + TAG2: []}
     for cluster in read_cdhit(clstr_file + ".clstr"):
-        
-        pool = (cluster.refname)[0:len(TAG1)]
+
+        pool = cluster.refname[:len(TAG1)]
         if pool != TAG1 and pool != TAG2:
             raise ValueError("Cluster {} does not start with {} or {}".format(cluster.refname, TAG1, TAG2))
-        seqname = cluster.refname[len(pool) + 1:]
+        seqname = strip_tag(cluster.refname)
         if len(cluster) == 1:
             # Singleton
             stats[pool].append(seqname)
@@ -141,31 +150,28 @@ def compare(fasta1, fasta2, tag1: str, tag2: str, tempdir, type: str, id: float,
             pair = []
             check = False
             for seq in cluster.sequences:
-                sub_pool = (seq.name)[0:len(TAG1)]
-                sub_seqname = (seq.name)[len(pool) + 1:]
+                sub_pool = seq.name[:len(TAG1)]
+                sub_seqname = strip_tag(seq.name)
                 pair.append(sub_seqname)
                 if sub_pool != pool:
                     check = True
-            if check == True:    
+            if check:
                 stats["both"].append(":".join(pair))
             else:
-                stats["dupl_" + pool ].append(":".join(pair))
+                stats["dupl_" + pool].append(":".join(pair))
         else:
-            
+
             stats["multi"].append(",".join(i.name for i in cluster.sequences))
-    
 
-    for key, list in stats.items():
-        print("{} {}".format(key, len(list)), file=sys.stderr)
-        for seqnames in list:
+    for key, seqnames_list in stats.items():
+        print("{} {}".format(key, len(seqnames_list)), file=sys.stderr)
+        for seqnames in seqnames_list:
             key = tags[key] if key in tags else key
-            key = "dupl_" + tags[key[-1*len(TAG1):]] if key[-1*len(TAG1):] in tags else key
+            key = "dupl_" + tags[key[-1 * len(TAG1):]] if key[-1 * len(TAG1):] in tags else key
             seqnames = seqnames.replace(TAG1, tags[TAG1] + "#").replace(TAG2, tags[TAG2] + "#")
-            
+
             print(key, seqnames, sep="\t")
 
-    #if not verbose:
-    #    os.remove(tmp)
 
 def show_hist(seq_lens):
     pass

cdhit_reader-0.5.0/cdhit_reader/_compare_otus.py

@@ -0,0 +1,332 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Dict, Iterable, List
+import csv
+import os
+import shutil
+import subprocess
+import tempfile
+
+import click
+
+from ._fasta import Sequence, read_fasta
+from ._reader import Cluster, read_cdhit
+from ._version import __version__
+
+COMPRESSED_SUFFIXES = (".gz", ".bz2", ".xz", ".zst")
+
+
+@dataclass(frozen=True)
+class RenamedSequence:
+    source_label: str
+    renamed_name: str
+    original: Sequence
+
+
+@dataclass
+class CategorySummary:
+    label: str
+    description: str
+    output_path: Path
+    clusters: int = 0
+    output_records: int = 0
+    source1_members: int = 0
+    source2_members: int = 0
+
+
+def has_cdhit_est() -> bool:
+    return shutil.which("cd-hit-est") is not None
+
+
+def input_prefix(path: Path) -> str:
+    """
+    Return a safe prefix derived from the input filename.
+    """
+    name = path.name
+    for suffix in COMPRESSED_SUFFIXES:
+        if name.endswith(suffix):
+            name = name[: -len(suffix)]
+            break
+
+    stem = Path(name).stem
+    return stem.replace("___", "__")
+
+
+def _record_name(prefix: str, seq_name: str) -> str:
+    return f"{prefix}___{seq_name}"
+
+
+def write_relabeled_fasta(input_path: Path, prefix: str, output_path: Path, append: bool) -> Dict[str, RenamedSequence]:
+    """
+    Relabel a FASTA file and append it to the concatenated input used for CD-HIT-EST.
+    """
+    mode = "a" if append else "w"
+    renamed: Dict[str, RenamedSequence] = {}
+
+    with output_path.open(mode, encoding="utf-8") as handle:
+        for seq in read_fasta(input_path):
+            renamed_name = _record_name(prefix, seq.name)
+            if renamed_name in renamed:
+                raise click.ClickException(
+                    f"Duplicate sequence identifier after relabeling: {renamed_name}"
+                )
+
+            renamed[renamed_name] = RenamedSequence(prefix, renamed_name, seq)
+            handle.write(f">{renamed_name}\n{seq.sequence}\n")
+
+    return renamed
+
+
+def classify_cluster(cluster: Cluster, prefix1: str, prefix2: str) -> tuple[str, int, int]:
+    prefix1_marker = f"{prefix1}___"
+    prefix2_marker = f"{prefix2}___"
+    count1 = 0
+    count2 = 0
+
+    for member in cluster.sequences:
+        if member.name.startswith(prefix1_marker):
+            count1 += 1
+        elif member.name.startswith(prefix2_marker):
+            count2 += 1
+        else:
+            raise click.ClickException(
+                f"Cluster member {member.name!r} does not belong to either input dataset."
+            )
+
+    if count1 == 1 and count2 == 1 and len(cluster) == 2:
+        return "one_to_one_matches", count1, count2
+    if count1 > 0 and count2 > 0:
+        return "shared_multi", count1, count2
+    if count1 > 0:
+        return "only_file1", count1, count2
+    return "only_file2", count1, count2
+
+
+def sequences_for_cluster(
+    cluster: Cluster,
+    renamed_sequences: Dict[str, RenamedSequence],
+    all_members: bool,
+) -> List[Sequence]:
+    if all_members:
+        sequence_names = [member.name for member in cluster.sequences]
+    else:
+        if cluster.refname is None:
+            raise click.ClickException(f"Cluster {cluster.name!r} does not define a representative sequence.")
+        sequence_names = [cluster.refname]
+
+    sequences: List[Sequence] = []
+    for renamed_name in sequence_names:
+        try:
+            sequences.append(renamed_sequences[renamed_name].original)
+        except KeyError as exc:
+            raise click.ClickException(
+                f"Could not restore original sequence for renamed identifier {renamed_name!r}."
+            ) from exc
+    return sequences
+
+
+def write_fasta_output(path: Path, sequences: Iterable[Sequence]) -> int:
+    count = 0
+    with path.open("w", encoding="utf-8") as handle:
+        for sequence in sequences:
+            handle.write(f"{sequence}\n")
+            count += 1
+    return count
+
+
+def write_stats(path: Path, summaries: Iterable[CategorySummary]) -> None:
+    with path.open("w", encoding="utf-8", newline="") as handle:
+        writer = csv.writer(handle, delimiter="\t")
+        writer.writerow(
+            [
+                "category",
+                "description",
+                "clusters",
+                "output_records",
+                "source1_members",
+                "source2_members",
+                "output_fasta",
+            ]
+        )
+        for summary in summaries:
+            writer.writerow(
+                [
+                    summary.label,
+                    summary.description,
+                    summary.clusters,
+                    summary.output_records,
+                    summary.source1_members,
+                    summary.source2_members,
+                    summary.output_path.name,
+                ]
+            )
+
+
+def write_log(path: Path, lines: Iterable[str]) -> None:
+    with path.open("w", encoding="utf-8") as handle:
+        for line in lines:
+            handle.write(f"{line}\n")
+
+
+@click.command(context_settings=dict(help_option_names=["-h", "--help"]))
+@click.version_option(__version__)
+@click.option("-1", "--fasta-one", "fasta_one", required=True, type=click.Path(exists=True, dir_okay=False, path_type=Path), help="First FASTA file.")
+@click.option("-2", "--fasta-two", "fasta_two", required=True, type=click.Path(exists=True, dir_okay=False, path_type=Path), help="Second FASTA file.")
+@click.option("-o", "--outdir", required=True, type=click.Path(file_okay=False, path_type=Path), help="Output directory.")
+@click.option("-c", "--perc-identity", default=0.99, show_default=True, type=click.FloatRange(min=0.0, max=1.0, min_open=True), help="CD-HIT-EST sequence identity threshold.")
+@click.option("--coverage", default=0.90, show_default=True, type=click.FloatRange(min=0.0, max=1.0, min_open=True), help="Coverage threshold applied to both -aS and -aL.")
+@click.option("-d", "--description-length", default=0, show_default=True, type=int, help="Value passed to cd-hit-est -d.")
+@click.option("--temp-dir", type=click.Path(exists=True, file_okay=False, path_type=Path), help="Override the temporary directory base.")
+@click.option("--keep-temp-dir", is_flag=True, default=False, help="Keep the temporary working directory.")
+@click.option("--all-members", is_flag=True, default=False, help="Write all members of matching clusters instead of only the representative sequence.")
+def compare_otus(
+    fasta_one: Path,
+    fasta_two: Path,
+    outdir: Path,
+    perc_identity: float,
+    coverage: float,
+    description_length: int,
+    temp_dir: Path | None,
+    keep_temp_dir: bool,
+    all_members: bool,
+) -> None:
+    """
+    Compare two OTU FASTA files with cd-hit-est.
+    """
+    if not has_cdhit_est():
+        raise click.ClickException(
+            "cd-hit-est is not available in PATH. Please install CD-HIT and try again."
+        )
+
+    outdir.mkdir(parents=True, exist_ok=True)
+    prefix1 = input_prefix(fasta_one)
+    prefix2 = input_prefix(fasta_two)
+    if prefix1 == prefix2:
+        raise click.ClickException(
+            "Input basenames resolve to the same prefix. Rename the inputs or adjust their filenames."
+        )
+
+    temp_base = temp_dir or Path(os.environ.get("TMP", "/tmp"))
+    workdir = Path(tempfile.mkdtemp(prefix="cdhit_compare_otus_", dir=temp_base))
+    concatenated_fasta = workdir / "concatenated.fasta"
+    output_prefix = workdir / "cdhit_compare_otus"
+    log_lines = [
+        "cdhit-compare-otus run",
+        f"fasta_one\t{fasta_one}",
+        f"fasta_two\t{fasta_two}",
+        f"outdir\t{outdir}",
+        f"temp_dir\t{workdir}",
+        f"prefix_one\t{prefix1}",
+        f"prefix_two\t{prefix2}",
+        f"perc_identity\t{perc_identity}",
+        f"coverage\t{coverage}",
+        f"description_length\t{description_length}",
+        f"all_members\t{all_members}",
+    ]
+
+    stats_path = outdir / "compare_otus_stats.tsv"
+    log_path = outdir / "compare_otus.log"
+
+    summaries = {
+        "one_to_one_matches": CategorySummary(
+            label="one_to_one_matches",
+            description="Exactly one member from each input file.",
+            output_path=outdir / "one_to_one_matches.fasta",
+        ),
+        "shared_multi": CategorySummary(
+            label="shared_multi",
+            description="At least one member from both inputs and multiple members in at least one input.",
+            output_path=outdir / "shared_multi.fasta",
+        ),
+        "only_file1": CategorySummary(
+            label="only_file1",
+            description=f"Clusters containing only sequences from {prefix1}.",
+            output_path=outdir / f"only_{prefix1}.fasta",
+        ),
+        "only_file2": CategorySummary(
+            label="only_file2",
+            description=f"Clusters containing only sequences from {prefix2}.",
+            output_path=outdir / f"only_{prefix2}.fasta",
+        ),
+    }
+
+    output_sequences = {key: [] for key in summaries}
+
+    try:
+        renamed_sequences: Dict[str, RenamedSequence] = {}
+        renamed_sequences.update(
+            write_relabeled_fasta(fasta_one, prefix1, concatenated_fasta, append=False)
+        )
+        second_sequences = write_relabeled_fasta(
+            fasta_two, prefix2, concatenated_fasta, append=True
+        )
+        overlap = set(renamed_sequences).intersection(second_sequences)
+        if overlap:
+            duplicated = ", ".join(sorted(overlap))
+            raise click.ClickException(f"Duplicate renamed identifiers across inputs: {duplicated}")
+        renamed_sequences.update(second_sequences)
+
+        command = [
+            "cd-hit-est",
+            "-i",
+            str(concatenated_fasta),
+            "-o",
+            str(output_prefix),
+            "-c",
+            str(perc_identity),
+            "-aS",
+            str(coverage),
+            "-aL",
+            str(coverage),
+            "-d",
+            str(description_length),
+        ]
+        log_lines.append(f"command\t{' '.join(command)}")
+
+        result = subprocess.run(command, check=True, capture_output=True, text=True)
+        if result.stdout.strip():
+            log_lines.append("cd-hit-est stdout:")
+            log_lines.extend(result.stdout.strip().splitlines())
+        if result.stderr.strip():
+            log_lines.append("cd-hit-est stderr:")
+            log_lines.extend(result.stderr.strip().splitlines())
+
+        for cluster in read_cdhit(f"{output_prefix}.clstr"):
+            category, count1, count2 = classify_cluster(cluster, prefix1, prefix2)
+            sequences = sequences_for_cluster(cluster, renamed_sequences, all_members=all_members)
+            output_sequences[category].extend(sequences)
+            summaries[category].clusters += 1
+            summaries[category].output_records += len(sequences)
+            summaries[category].source1_members += count1
+            summaries[category].source2_members += count2
+
+        for summary in summaries.values():
+            written = write_fasta_output(summary.output_path, output_sequences[summary.label])
+            if written != summary.output_records:
+                raise click.ClickException(
+                    f"Expected to write {summary.output_records} sequences to {summary.output_path.name}, wrote {written}."
+                )
+            log_lines.append(
+                f"output\t{summary.label}\t{summary.output_path}\tclusters={summary.clusters}\tsequences={summary.output_records}"
+            )
+
+        write_stats(stats_path, summaries.values())
+        log_lines.append(f"stats\t{stats_path}")
+        log_lines.append(f"log\t{log_path}")
+        click.echo(f"Results written to {outdir}")
+    except subprocess.CalledProcessError as exc:
+        if exc.stdout:
+            log_lines.append("cd-hit-est stdout:")
+            log_lines.extend(exc.stdout.strip().splitlines())
+        if exc.stderr:
+            log_lines.append("cd-hit-est stderr:")
+            log_lines.extend(exc.stderr.strip().splitlines())
+        raise click.ClickException("cd-hit-est failed; see compare_otus.log for details.") from exc
+    finally:
+        write_log(log_path, log_lines)
+        if not keep_temp_dir:
+            shutil.rmtree(workdir, ignore_errors=True)
+        else:
+            click.echo(f"Temporary directory kept at {workdir}")