seqcounter 1.0.0__py3-none-any.whl

seqcounter/__init__.py

@@ -0,0 +1,3 @@
+"""Count occurrences of reference sequences in sequencing reads or genome assemblies."""
+
+__version__ = '1.0.0'

seqcounter/__main__.py

@@ -0,0 +1,6 @@
+"""Allow running the command with "python -m seqcounter"."""
+
+from .cli import main
+
+if __name__ == '__main__':
+    main()

seqcounter/cli.py

@@ -0,0 +1,184 @@
+"""Command line entry point."""
+
+import logging
+import os
+import re
+import shlex
+import sys
+import time
+from argparse import ArgumentParser, ArgumentTypeError, RawDescriptionHelpFormatter
+from datetime import datetime
+from pathlib import Path
+
+from . import __version__
+from .counts import count_samples, print_table, run_info, write_reports
+from .errors import SeqCounterError
+from .references import load_references
+from .samples import find_samples, single_sample
+from .seal import DEFAULT_KMER_SIZE, DEFAULT_MISMATCHES, auto_memory, check_seal
+
+log = logging.getLogger('seqcounter')
+
+# Expected errors are reported without a traceback
+USER_ERRORS = (SeqCounterError, OSError)
+
+EPILOG = '''examples:
+  seqcounter -ref refs.fasta -r1 sample_R1.fastq.gz -r2 sample_R2.fastq.gz -o results/
+  seqcounter -ref refs.fasta -r1 sample.fastq.gz -o results/
+  seqcounter -ref refs.fasta -r1 assembly.fasta -o results/
+  seqcounter -ref refs.fasta -i folder_of_fastq_and_fasta/ -o results/
+
+documentation: https://github.com/duceppemo/seqcounter/wiki'''
+
+
+def setup_logging(verbose=False):
+    """Configure the package logger only, so importing seqcounter never alters the root logger."""
+    for handler in list(log.handlers):
+        log.removeHandler(handler)
+    handler = logging.StreamHandler(sys.stderr)
+    handler.setFormatter(logging.Formatter('%(asctime)s %(levelname)-7s %(message)s', datefmt='%H:%M:%S'))
+    log.addHandler(handler)
+    log.setLevel(logging.DEBUG if verbose else logging.INFO)
+
+
+def positive_int(value):
+    try:
+        value = int(value)
+    except ValueError:
+        raise ArgumentTypeError('"{}" is not an integer'.format(value)) from None
+    if value < 1:
+        raise ArgumentTypeError('must be >= 1')
+    return value
+
+
+def java_memory(value):
+    if not value[:-1].isdigit() or value[-1].lower() not in 'mg':
+        raise ArgumentTypeError('"{}" is not a Java memory size such as 500m or 2g'.format(value))
+    return value
+
+
+def available_cpus():
+    try:
+        return len(os.sched_getaffinity(0))  # Respects cgroup/taskset limits on Linux (e.g. SLURM jobs)
+    except AttributeError:
+        return os.cpu_count() or 1
+
+
+def format_elapsed(seconds):
+    """A readable duration, as the first version of seqcounter printed it: "1h2m3s"."""
+    minutes, seconds = divmod(int(round(seconds)), 60)
+    hours, minutes = divmod(minutes, 60)
+    days, hours = divmod(hours, 24)
+    periods = [('d', days), ('h', hours), ('m', minutes), ('s', seconds)]
+    return ''.join('{}{}'.format(value, name) for name, value in periods if value) or '0s'
+
+
+def build_parser():
+    max_cpu = available_cpus()
+    parser = ArgumentParser(prog='seqcounter', formatter_class=RawDescriptionHelpFormatter, epilog=EPILOG,
+                            description='Count the occurrences of reference sequences in sequencing reads (fastq)\n'
+                                        'or genome assemblies (fasta), with Seal from BBTools.')
+    inputs = parser.add_argument_group('input (one sample with -r1, or a folder of samples with -i)')
+    source = inputs.add_mutually_exclusive_group(required=True)
+    source.add_argument('-r1', '--r1', metavar='FILE',
+                        help='Reads (single-end or R1 of paired-end) or assembly. fastq or fasta, gzipped or not.')
+    source.add_argument('-i', '--input', metavar='FOLDER',
+                        help='Folder of fastq and fasta files, searched recursively. Each fasta file, single-end '
+                             'fastq file or pair of R1/R2 fastq files is a sample.')
+    inputs.add_argument('-r2', '--r2', metavar='FILE',
+                        help='R2 reads, for paired-end fastq files.')
+    inputs.add_argument('-ref', '--ref', metavar='FILE', required=True,
+                        help='Fasta file of the reference sequences to count, gzipped or not. One row per sequence '
+                             'is reported, named after the first word of its ">" line.')
+    inputs.add_argument('-s', '--sample', metavar='NAME',
+                        help='With -r1: sample name used in the reports. Default: the input file name, without '
+                             'extension and read suffix (_R1, _1, ...).')
+
+    output = parser.add_argument_group('output')
+    output.add_argument('-o', '--output', metavar='FOLDER', required=True,
+                        help='Folder to hold the reports. Created if needed.')
+
+    counting = parser.add_argument_group('counting')
+    counting.add_argument('-k', '--kmer-size', metavar='N', type=positive_int, default=DEFAULT_KMER_SIZE,
+                          help='K-mer size used to find the reference sequences. A reference shorter than k cannot '
+                               'be found. Default: {}.'.format(DEFAULT_KMER_SIZE))
+    counting.add_argument('-m', '--mismatch', metavar='N', type=int, default=DEFAULT_MISMATCHES,
+                          help='Mismatches allowed between a reference k-mer and the input (maximum Hamming '
+                               'distance). Default: {}.'.format(DEFAULT_MISMATCHES))
+
+    other = parser.add_argument_group('performance and other options')
+    other.add_argument('-t', '--threads', metavar='N', type=positive_int, default=max_cpu,
+                       help='Number of threads. Default: all available ({}).'.format(max_cpu))
+    other.add_argument('-p', '-j', '--parallel', '--jobs', metavar='N', type=positive_int, default=1, dest='parallel',
+                       help='With -i: number of samples counted at the same time, sharing the threads. Default: 1.')
+    other.add_argument('--memory', metavar='SIZE', type=java_memory,
+                       help='Memory for Seal (Java heap size), per job, e.g. 2g. Default: from the size of the '
+                            'reference sequences, within 85%% of the machine.')
+    other.add_argument('--verbose', action='store_true', help='Show debug messages, including the Seal command.')
+    other.add_argument('-v', '--version', action='version', version='%(prog)s ' + __version__)
+    return parser
+
+
+def check_arguments(parser, args):
+    if args.input and (args.r2 or args.sample):
+        parser.error('-r2 and --sample are only used with -r1')
+    if args.r1 and args.parallel > 1:
+        parser.error('--parallel is only used with -i')
+    if args.mismatch < 0:
+        parser.error('--mismatch cannot be negative')
+    if args.mismatch >= args.kmer_size:
+        parser.error('--mismatch ({}) must be smaller than --kmer-size ({})'.format(args.mismatch, args.kmer_size))
+    if args.sample is not None and (not args.sample.strip() or '/' in args.sample or args.sample in ('.', '..')):
+        parser.error('--sample must be a name, not a path: "{}"'.format(args.sample))
+    if args.sample is not None and re.search(r'[\t\r\n]', args.sample):
+        parser.error('--sample cannot contain tabs or line breaks (they would break the table)')
+
+
+def main(argv=None):
+    parser = build_parser()
+    args = parser.parse_args(argv)
+    check_arguments(parser, args)
+    setup_logging(args.verbose)
+    command = shlex.join([parser.prog, *(sys.argv[1:] if argv is None else argv)])
+    log.debug('seqcounter %s: %s', __version__, command)
+    started = datetime.now().astimezone()
+    start = time.monotonic()
+    output = Path(args.output).expanduser()
+    try:
+        check_seal()
+        references = load_references(args.ref, args.kmer_size)
+        if args.input:
+            samples = find_samples(args.input, exclude=[output])
+            log.info('%d sample(s) found in %s', len(samples), args.input)
+        else:
+            samples = [single_sample(args.r1, args.r2, name=args.sample)]
+        if any(s.file_type == 'fasta' for s in samples):
+            log.info('fasta input: the count of a reference sequence is the number of sequences (contigs) that '
+                     'contain it, not the number of copies it has in them.')
+        jobs = min(args.parallel, len(samples))
+        memory = args.memory or auto_memory(sum(r.length for r in references), jobs=jobs)
+        results = count_samples(samples, args.ref, jobs=jobs, threads=args.threads, kmer_size=args.kmer_size,
+                                mismatch=args.mismatch, memory=memory)
+        run = run_info(command, {'Reference': os.path.abspath(args.ref),
+                                 'Input': ' '.join(os.path.abspath(f) for f in (args.input, args.r1, args.r2) if f),
+                                 'Output folder': str(output.resolve()),
+                                 'K-mer size': args.kmer_size, 'Mismatches': args.mismatch,
+                                 'Threads': args.threads, 'Parallel samples': jobs, 'Seal memory': memory}, started)
+        rows, reports = write_reports(results, references, output, command=command, run=run)
+    except USER_ERRORS as e:
+        log.error('%s', e)
+        log.debug('Traceback:', exc_info=True)  # Shown with --verbose
+        sys.exit(1)
+    except KeyboardInterrupt:
+        log.error('Interrupted')
+        sys.exit(130)
+
+    # The counts go to stdout, the messages to stderr: "seqcounter ... > counts.tsv" works
+    print_table(rows)
+    for report in reports:
+        log.info('Report saved in %s', report)
+    log.info('Done in %s', format_elapsed(time.monotonic() - start))
+    failed = [r.sample for r in results if r.error]
+    if failed:
+        log.error('%d of %d sample(s) failed: %s', len(failed), len(results), ', '.join(failed))
+        sys.exit(1)

seqcounter/counts.py

@@ -0,0 +1,168 @@
+"""Count the reference sequences in each sample, and write the reports."""
+
+import json
+import logging
+import platform
+import sys
+from concurrent import futures
+from dataclasses import dataclass, field
+from datetime import datetime
+from pathlib import Path
+
+from . import __version__
+from .errors import SeqCounterError
+from .seal import DEFAULT_KMER_SIZE, DEFAULT_MISMATCHES, run_seal, versions
+
+log = logging.getLogger(__name__)
+
+COUNTS_FILE = 'refseqcounts.tsv'  # The name the first version of seqcounter wrote, and the same table
+SAMPLES_FILE = 'refseqcounts_samples.tsv'
+JSON_FILE = 'refseqcounts.json'
+
+
+@dataclass
+class Result:
+    """What one sample gave: a count per reference sequence, or an error."""
+    sample: str
+    file_type: str
+    files: list
+    counts: dict = field(default_factory=dict)
+    reads: int | None = None  # Reads, or contigs for a fasta file
+    bases: int | None = None
+    matched: int | None = None  # Reads matching at least one reference sequence
+    error: str | None = None
+
+    @property
+    def matched_percent(self):
+        if self.matched is None or not self.reads:
+            return None
+        return 100.0 * self.matched / self.reads
+
+
+def count_sample(sample, ref, kmer_size=DEFAULT_KMER_SIZE, mismatch=DEFAULT_MISMATCHES, threads=1, memory='1g'):
+    """
+    Count the reads (or contigs) of one sample matching each reference sequence.
+
+    An error on one sample is kept in its Result rather than raised, so that a run over a folder reports the
+    samples that worked.
+    """
+    log.info('Counting %s (%s, %d file(s))', sample.name, sample.file_type, len(sample.files))
+    try:
+        stats = run_seal(sample.files, ref, threads=threads, memory=memory, k=kmer_size, hdist=mismatch)
+    except SeqCounterError as e:
+        log.error('%s: %s', sample.name, e)
+        return Result(sample.name, sample.file_type, list(sample.files), error=str(e))
+    result = Result(sample.name, sample.file_type, list(sample.files), counts=stats.counts,
+                    reads=stats.reads, bases=stats.bases, matched=stats.matched)
+    log.info('%s: %s of %s read(s) matched', sample.name,
+             '{:,}'.format(stats.matched) if stats.matched is not None else '?',
+             '{:,}'.format(stats.reads) if stats.reads is not None else '?')
+    return result
+
+
+def count_samples(samples, ref, jobs=1, threads=1, **options):
+    """
+    Count the reference sequences in several samples, up to jobs samples at a time.
+
+    The threads are shared between the jobs, as Seal uses them within one sample.
+
+    :return: list of Result, in the order of samples
+    """
+    jobs = max(1, min(jobs, len(samples)))
+    per_job = max(1, threads // jobs)
+    if jobs > 1:
+        log.info('%d sample(s), %d at a time, %d thread(s) each', len(samples), jobs, per_job)
+    with futures.ThreadPoolExecutor(max_workers=jobs) as executor:
+        return list(executor.map(lambda s: count_sample(s, ref, threads=per_job, **options), samples))
+
+
+def counts_table(results, references):
+    """
+    The table written to refseqcounts.tsv and printed: one row per reference sequence, one column per sample.
+
+    Rows are sorted by reference name, as the first version of seqcounter sorted them. A sample that failed has
+    empty cells, so that the samples that worked are still readable as numbers.
+
+    :return: list of rows, the first one being the header
+    """
+    names = sorted({r.name for r in references} | {name for result in results for name in result.counts})
+    rows = [['Reference'] + [result.sample for result in results]]
+    for name in names:
+        row = [name]
+        for result in results:
+            row.append('' if result.error else str(result.counts.get(name, 0)))
+        rows.append(row)
+    return rows
+
+
+def write_counts(results, references, path, command=None):
+    """Write the counts table, keeping the "#command line" first line of the first version of seqcounter."""
+    rows = counts_table(results, references)
+    with open(path, 'w') as f:
+        if command:
+            f.write('#{}\n'.format(command))
+        for row in rows:
+            f.write('\t'.join(row) + '\n')
+    return rows
+
+
+SAMPLES_HEADER = ['Sample', 'Type', 'Reads', 'Bases', 'Matched', 'MatchedPct', 'Files', 'Error']
+
+
+def write_samples(results, path):
+    """One row per sample: how much was read, how much matched, and the error if it failed."""
+    with open(path, 'w') as f:
+        f.write('\t'.join(SAMPLES_HEADER) + '\n')
+        for r in results:
+            percent = r.matched_percent
+            f.write('\t'.join([r.sample, r.file_type,
+                               '' if r.reads is None else str(r.reads),
+                               '' if r.bases is None else str(r.bases),
+                               '' if r.matched is None else str(r.matched),
+                               '' if percent is None else '{:.4f}'.format(percent),
+                               ';'.join(r.files),
+                               (r.error or '').replace('\n', ' ')]) + '\n')
+
+
+def write_json(results, references, path, run=None):
+    """Everything the run produced, for a pipeline: parameters, versions, references and counts."""
+    report = {
+        'tool': 'seqcounter',
+        'version': __version__,
+        'references': [{'name': r.name, 'description': r.description, 'length': r.length} for r in references],
+        'samples': [{'sample': r.sample, 'type': r.file_type, 'files': r.files, 'reads': r.reads, 'bases': r.bases,
+                     'matched': r.matched, 'matched_percent': r.matched_percent, 'counts': r.counts,
+                     'error': r.error} for r in results],
+    }
+    report.update(run or {})
+    with open(path, 'w') as f:
+        json.dump(report, f, indent=2, sort_keys=False)
+        f.write('\n')
+
+
+def run_info(command, parameters, started, finished=None):
+    """The run metadata of the JSON report: what was run, with which versions and parameters."""
+    software = {'seqcounter': __version__, 'Python': platform.python_version()}
+    software.update(versions())
+    return {'command': command, 'started': started.isoformat(timespec='seconds'),
+            'finished': (finished or datetime.now().astimezone()).isoformat(timespec='seconds'),
+            'software': software, 'parameters': parameters}
+
+
+def print_table(rows, stream=None):
+    """Print the counts table, tab separated: "seqcounter ... > counts.tsv" works."""
+    stream = stream or sys.stdout
+    for row in rows:
+        print('\t'.join(row), file=stream)
+    stream.flush()
+
+
+def write_reports(results, references, output, command=None, run=None):
+    """Write the three reports in the output folder and return their paths, the counts table first."""
+    output = Path(output)
+    output.mkdir(parents=True, exist_ok=True)
+    counts, samples, report = output / COUNTS_FILE, output / SAMPLES_FILE, output / JSON_FILE
+    rows = write_counts(results, references, counts, command=command)
+    write_samples(results, samples)
+    write_json(results, references, report, run=run)
+    return rows, [counts, samples, report]

seqcounter/errors.py

@@ -0,0 +1,5 @@
+"""The error raised for anything the user can fix: reported without a traceback."""
+
+
+class SeqCounterError(Exception):
+    pass

seqcounter/references.py

@@ -0,0 +1,87 @@
+"""Read the reference sequences to count, and check that Seal can count them."""
+
+import gzip
+import logging
+import re
+from dataclasses import dataclass
+from pathlib import Path
+
+from .errors import SeqCounterError
+
+log = logging.getLogger(__name__)
+
+
+@dataclass
+class Reference:
+    name: str  # The name Seal reports: the first word of the fasta header
+    description: str  # The rest of the header, or ""
+    length: int
+
+
+def open_text(path):
+    """Open a text file, gzipped or not."""
+    with open(path, 'rb') as f:
+        gzipped = f.read(2) == b'\x1f\x8b'
+    return gzip.open(path, 'rt') if gzipped else open(path)
+
+
+def read_fasta(path):
+    """[(header, sequence length)] of a fasta file, gzipped or not, in file order."""
+    records, header, length = [], None, 0
+    with open_text(path) as f:
+        for line in f:
+            line = line.strip()
+            if line.startswith('>'):
+                if header is not None:
+                    records.append((header, length))
+                header, length = line[1:].strip(), 0
+            elif line and header is not None:
+                length += len(re.sub(r'\s', '', line))
+    if header is not None:
+        records.append((header, length))
+    return records
+
+
+def load_references(path, kmer_size):
+    """
+    The reference sequences of a fasta file, checked against how Seal counts them.
+
+    Rejected rather than counted wrongly: an empty file, a sequence shorter than the k-mer size (Seal cannot
+    find it at all), and two sequences whose first word is the same (their counts would collide in one row).
+
+    :return: list of Reference, in file order
+    """
+    if not Path(path).is_file():
+        raise SeqCounterError('Reference file not found: {}'.format(path))
+    try:
+        records = read_fasta(path)
+    except (OSError, EOFError, UnicodeDecodeError) as e:
+        raise SeqCounterError('Reference file {} cannot be read: {}'.format(path, e)) from None
+    if not records:
+        raise SeqCounterError('No sequence found in the reference file {}. It must be in fasta format, with a '
+                              '">name" line before each sequence.'.format(path))
+
+    references, seen, duplicates, short = [], {}, [], []
+    for header, length in records:
+        name, _, description = header.partition(' ')
+        name = re.sub(r'[\t\r\n]', '_', name) or 'unnamed'
+        if length == 0:
+            raise SeqCounterError('The reference sequence "{}" of {} is empty.'.format(name, path))
+        if length < kmer_size:
+            short.append('"{}" ({} bp)'.format(name, length))
+        if name in seen:
+            duplicates.append('"{}"'.format(name))
+        seen[name] = True
+        references.append(Reference(name, description.strip(), length))
+
+    if duplicates:
+        raise SeqCounterError('Several reference sequences of {} have the same name: {}. Seal reports one row per '
+                              'name, up to the first space, so their counts would be added together. Rename '
+                              'them.'.format(path, ', '.join(sorted(set(duplicates)))))
+    if short:
+        raise SeqCounterError('{} reference sequence(s) of {} are shorter than the k-mer size ({} bp): {}. Seal '
+                              'cannot find them: lower -k to at most the shortest reference, or remove '
+                              'them.'.format(len(short), path, kmer_size, ', '.join(short)))
+    log.info('%d reference sequence(s) read from %s (%d-%d bp)', len(references), path,
+             min(r.length for r in references), max(r.length for r in references))
+    return references

seqcounter/samples.py

@@ -0,0 +1,123 @@
+"""Find the samples in an input folder: fasta files, and single-end or paired-end fastq files."""
+
+import logging
+import os
+import re
+from dataclasses import dataclass
+from pathlib import Path
+
+from .errors import SeqCounterError
+
+log = logging.getLogger(__name__)
+
+FASTA_EXTENSIONS = ('.fasta', '.fa', '.fna', '.fas', '.fsa')
+FASTQ_EXTENSIONS = ('.fastq', '.fq')
+# Read suffixes of fastq file names, e.g. "S1_R1", "S1_S12_L001_R2_001", "SRR123_1". Group 1 is the mate number.
+READ_SUFFIX = re.compile(r'_R?([12])(?:_001)?$')
+
+
+@dataclass
+class Sample:
+    name: str
+    file_type: str  # "fasta" or "fastq"
+    files: list  # One file, or R1 and R2
+
+    @property
+    def paired(self):
+        return len(self.files) == 2
+
+
+def split_extension(filename):
+    """(stem, "fasta" or "fastq") for a sequence file, gzipped or not, or None for any other file."""
+    lower = filename.lower()
+    if lower.endswith('.gz'):
+        lower = lower[:-3]
+    for file_type, extensions in (('fasta', FASTA_EXTENSIONS), ('fastq', FASTQ_EXTENSIONS)):
+        for extension in extensions:
+            if lower.endswith(extension) and len(lower) > len(extension):
+                return filename[:len(lower) - len(extension)], file_type
+    return None
+
+
+def sample_name(path, file_type=None):
+    """
+    Sample name from a file name: the sequence extension is removed, and for fastq files the read suffix too.
+    "S1_R1.fastq.gz" -> "S1", "Iso_R10.fasta" -> "Iso_R10", "E.coli.v2.fasta" -> "E.coli.v2".
+    """
+    name = Path(path).name
+    parsed = split_extension(name)
+    if parsed is not None:
+        name, file_type = parsed[0], file_type or parsed[1]
+    if file_type == 'fastq':
+        name = READ_SUFFIX.sub('', name) or name
+    return re.sub(r'[\t\r\n]', '_', name)  # Tabs and line breaks would break the table
+
+
+def find_samples(folder, exclude=()):
+    """
+    Look for fasta and fastq files in a folder and its subfolders, and group R1 and R2 fastq files per sample.
+
+    Name collisions are errors rather than guesses: two files giving the same sample name would otherwise be
+    merged or overwritten silently.
+
+    :param exclude: folders to skip, e.g. the output folder when it is inside the input folder
+    :return: list of Sample, sorted by name
+    """
+    if not Path(folder).is_dir():
+        raise SeqCounterError('Input folder not found: {}'.format(folder))
+    exclude = {Path(p).resolve() for p in exclude}
+    found = {}  # {sample name: [(file type, mate number or None, path)]}
+    visited = set()  # Real paths of the folders searched: symbolic links to folders are followed, loops are not
+    for root, dirs, filenames in os.walk(folder, followlinks=True):
+        real = Path(root).resolve()
+        if real in visited:
+            dirs[:] = []
+            continue
+        visited.add(real)
+        dirs[:] = sorted(d for d in dirs if Path(root, d).resolve() not in exclude and not d.startswith('.'))
+        for filename in sorted(filenames):
+            parsed = split_extension(filename)
+            if parsed is None or filename.startswith('.'):
+                continue
+            stem, file_type = parsed
+            mate = None
+            if file_type == 'fastq':
+                match = READ_SUFFIX.search(stem)
+                if match and match.start() > 0:
+                    mate, stem = int(match.group(1)), stem[:match.start()]
+            stem = re.sub(r'[\t\r\n]', '_', stem)  # Tabs and line breaks would break the table
+            found.setdefault(stem, []).append((file_type, mate, os.path.join(root, filename)))
+
+    samples, errors = [], []
+    for name, files in sorted(found.items()):
+        paths = ', '.join(f[2] for f in files)
+        if len(files) == 1:
+            file_type, mate, path = files[0]
+            if mate == 2:
+                log.warning('%s: R2 file without R1, counted as single-end reads: %s', name, path)
+            samples.append(Sample(name, file_type, [path]))
+        elif len(files) == 2 and {(f[0], f[1]) for f in files} == {('fastq', 1), ('fastq', 2)}:
+            samples.append(Sample(name, 'fastq', [f[2] for f in sorted(files, key=lambda f: f[1])]))
+        else:
+            errors.append('"{}": {}'.format(name, paths))
+    if errors:
+        raise SeqCounterError('Several files give the same sample name. Rename, move or remove them:\n  '
+                              + '\n  '.join(errors))
+    if not samples:
+        raise SeqCounterError('No fasta or fastq file found in {}'.format(folder))
+    return samples
+
+
+def single_sample(r1, r2=None, name=None):
+    """The Sample for one input given on the command line, with an optional sample name."""
+    for path in (r1, r2):
+        if path is not None and not Path(path).is_file():
+            raise SeqCounterError('Input file not found: {}'.format(path))
+    parsed = split_extension(Path(r1).name)
+    file_type = parsed[1] if parsed else 'fastq'
+    if r2 is not None and file_type == 'fasta':
+        raise SeqCounterError('-r2 is for paired-end fastq files; "{}" is a fasta file.'.format(r1))
+    files = [os.path.abspath(r1)] + ([os.path.abspath(r2)] if r2 else [])
+    if len(files) == 2 and files[0] == files[1]:
+        raise SeqCounterError('-r1 and -r2 are the same file: {}'.format(files[0]))
+    return Sample(name or sample_name(r1), file_type, files)

seqcounter/seal.py

@@ -0,0 +1,283 @@
+"""Count the reads (or contigs) matching each reference sequence with Seal, from BBTools."""
+
+import gzip
+import logging
+import os
+import re
+import shlex
+import shutil
+import subprocess
+import sys
+import tempfile
+from dataclasses import dataclass, field
+from functools import cache
+from pathlib import Path
+
+from .errors import SeqCounterError
+
+log = logging.getLogger(__name__)
+
+DEFAULT_KMER_SIZE = 25  # A reference sequence shorter than k cannot be found
+DEFAULT_MISMATCHES = 1  # Maximum Hamming distance between a reference k-mer and the input
+
+
+class SealError(SeqCounterError):
+    pass
+
+
+@cache
+def executable():
+    """
+    Path of seal.sh: the one in the PATH, otherwise the one installed next to the running Python.
+    The fallback makes "/path/to/env/bin/seqcounter" work without activating the conda environment.
+
+    :return: path to seal.sh, or None if it cannot be found
+    """
+    found = shutil.which('seal.sh')
+    if found:
+        return found
+    # Do not resolve symlinks: a virtualenv's python is a symlink to the base interpreter
+    candidate = Path(sys.executable).parent / 'seal.sh'
+    if candidate.is_file() and os.access(candidate, os.X_OK):
+        return str(candidate)
+    return None
+
+
+def check_seal():
+    """Make sure seal.sh is installed and return its path."""
+    path = executable()
+    if path is None:
+        raise SealError('"seal.sh" was not found in your PATH or in "{}". Install BBTools in the environment '
+                        'with "conda install -c bioconda bbmap".'.format(Path(sys.executable).parent))
+    return path
+
+
+def seal_command(inputs, refs, stats_file, threads, memory, k=DEFAULT_KMER_SIZE, hdist=DEFAULT_MISMATCHES):
+    """
+    :param inputs: one fasta/fastq file, or two paired-end fastq files
+    :param refs: reference fasta file(s): a path or a list of paths
+    :param k: k-mer size. A reference sequence shorter than k cannot be found
+    :param hdist: number of mismatches allowed in a k-mer
+    """
+    refs = [refs] if isinstance(refs, (str, os.PathLike)) else list(refs)
+    cmd = [check_seal(), '-Xmx{}'.format(memory), 'in={}'.format(inputs[0])]
+    if len(inputs) > 1:
+        cmd.append('in2={}'.format(inputs[1]))
+    else:
+        cmd.append('int=f')  # Never guess that a single fastq file is interleaved: that would halve the counts
+    cmd += ['ref={}'.format(','.join(str(r) for r in refs)),
+            'k={}'.format(k),
+            'rcomp=t',  # Count a match on either strand
+            'hdist={}'.format(hdist),
+            'maskmiddle=f',  # Do not treat the middle base of a k-mer as a wildcard
+            'clearzone=999999',
+            'ambiguous=all',  # Count a read for every reference sequence it matches
+            'nzo=f',  # Also report reference sequences with no match
+            'qin=33',  # Force the quality encoding: autodetection fails on some low quality nanopore reads
+            'ow=t',
+            'stats={}'.format(stats_file),
+            'threads={}'.format(threads)]
+    return cmd
+
+
+# Paths that seal.sh cannot pass to Seal safely: it runs its command line with eval, so any shell character (spaces,
+# quotes, $, `, ;, &, |, parentheses...) is re-interpreted, it splits ref= lists on commas, and BBTools 40 takes any
+# argument containing "xmx" or "xms" (in any case, anywhere) for a Java memory setting. Only plain characters are
+# passed as they are: the other paths are linked under a neutral name.
+UNSAFE = re.compile(r'[^A-Za-z0-9._/+:@-]|xm[xs]', re.IGNORECASE)
+
+
+def extensions(name):
+    """The extensions Seal uses to recognize the format, e.g. ".fastq.gz" for "S1_R1.fastq.gz"."""
+    suffixes = [s for s in Path(name).suffixes[-2:] if re.fullmatch(r'\.[A-Za-z0-9]+', s) and not UNSAFE.search(s)]
+    return ''.join(suffixes)
+
+
+SEQUENCE_EXTENSION = re.compile(r'\.(fastq|fq|fasta|fa|fna|fas|fsa)(\.gz)?$', re.IGNORECASE)
+
+
+def content_extension(path):
+    """
+    Extension matching the content of a sequence file, e.g. ".fastq.gz". Seal recognizes formats and compression by
+    extension only, and Galaxy, for example, names its files "dataset_1.dat".
+    """
+    with open(path, 'rb') as f:
+        gzipped = f.read(2) == b'\x1f\x8b'
+    try:
+        with (gzip.open(path, 'rt') if gzipped else open(path)) as f:
+            first = next((line for line in f if line.strip()), '>')[0]
+    except (OSError, EOFError, UnicodeDecodeError):
+        first = '>'  # Unreadable: let Seal report the error
+    return ('.fastq' if first == '@' else '.fasta') + ('.gz' if gzipped else '')
+
+
+def safe_paths(paths, folder, prefix, check_extension=False):
+    """
+    Paths that Seal can read: unsafe ones, and with check_extension those whose extension does not match their
+    content, are linked into folder under a neutral name (e.g. "in0.fastq.gz").
+    """
+    safe = []
+    for i, path in enumerate(paths):
+        path = str(path)
+        extension = extensions(path)
+        if check_extension:
+            detected = content_extension(path)
+            match = SEQUENCE_EXTENSION.search(Path(path).name)
+            fastq = match and match.group(1).lower() in ('fastq', 'fq')
+            if not match or fastq != detected.startswith('.fastq') or bool(match.group(2)) != detected.endswith('.gz'):
+                extension = detected
+        if UNSAFE.search(path) or extension != extensions(path):
+            link = Path(folder) / '{}{}{}'.format(prefix, i, extension)
+            link.symlink_to(Path(path).resolve())
+            path = str(link)
+        safe.append(path)
+    return safe
+
+
+def safe_temporary_folder(attempts=20):
+    """A new temporary folder whose path Seal can read: random names can contain "xmx" or "xms", so retry."""
+    for _ in range(attempts):
+        folder = tempfile.mkdtemp(prefix='seqcounter_')
+        if not UNSAFE.search(folder):
+            return folder
+        os.rmdir(folder)
+    raise SealError('The temporary folder "{}" contains a space, a comma, "xmx" or "xms", which Seal cannot handle. '
+                    'Set TMPDIR to another folder.'.format(tempfile.gettempdir()))
+
+
+GENERIC_ERRORS = re.compile(r'Exception in thread "main"|terminated in an error state')
+
+
+def failure_reason(lines):
+    """
+    The most informative line of Seal's error output: the first error that is not Seal's generic final message.
+    Java exceptions often end with ":" and give their message on the next line, which is then added.
+    """
+    candidates = [i for i, line in enumerate(lines) if re.search(r'Exception|Error|error', line)
+                  and not line.strip().startswith('at ')]
+    specific = [i for i in candidates if not GENERIC_ERRORS.search(lines[i])]
+    if not candidates:
+        return lines[-1].strip()
+    i = (specific or candidates)[0]
+    reason = lines[i].strip()
+    if reason.endswith(':'):
+        following = [line.strip() for line in lines[i + 1:] if line.strip() and not line.strip().startswith('at ')]
+        if following:
+            reason += ' ' + following[0]
+    return reason
+
+
+@dataclass
+class SealStats:
+    counts: dict = field(default_factory=dict)  # {reference name: number of matching reads}
+    reads: int | None = None  # Total number of reads (or contigs) in the input
+    bases: int | None = None
+    matched: int | None = None  # Reads matching at least one reference sequence
+
+
+def parse_stats(stats_file):
+    """
+    Read Seal's stats file.
+
+    #File	sample_R1.fastq.gz
+    #Total	822714	123407100
+    #Matched	799	0.09712%
+    #Name	Reads	ReadsPct
+    spacer25	62	0.00754%
+    """
+    stats = SealStats()
+    with open(stats_file) as f:
+        for line in f:
+            fields = line.rstrip('\n').split('\t')
+            if not line.strip():
+                continue
+            try:
+                if fields[0] == '#Total':
+                    stats.reads = int(fields[1])
+                    stats.bases = int(fields[2]) if len(fields) > 2 else None
+                elif fields[0] == '#Matched':
+                    stats.matched = int(fields[1])
+                elif not line.startswith('#'):
+                    stats.counts[fields[0].split()[0]] = int(fields[1])  # Name without the description
+            except (IndexError, ValueError):
+                raise SealError('Unexpected line in Seal stats file {}: {}'.format(stats_file, line.strip())) from None
+    return stats
+
+
+def run_seal(inputs, refs, threads=1, memory='1g', k=DEFAULT_KMER_SIZE, hdist=DEFAULT_MISMATCHES):
+    """
+    Count the reads (or contigs) that contain each reference sequence.
+
+    :param inputs: one fasta/fastq file, or two paired-end fastq files
+    :param refs: reference fasta file(s)
+    :param memory: Java heap size given to Seal, e.g. "1g"
+    :return: SealStats
+    """
+    refs = [refs] if isinstance(refs, (str, os.PathLike)) else list(refs)
+    tmp = safe_temporary_folder()
+    try:
+        stats_file = Path(tmp) / 'stats.tsv'
+        cmd = seal_command(safe_paths(inputs, tmp, 'in', check_extension=True), safe_paths(refs, tmp, 'ref'),
+                           stats_file, threads, memory, k=k, hdist=hdist)
+        log.debug('Running: %s', shlex.join(cmd))
+        proc = subprocess.run(cmd, capture_output=True, text=True)
+        if proc.returncode != 0 or not stats_file.exists():
+            detail = (proc.stderr or proc.stdout).strip().splitlines() or ['no output']
+            raise SealError('Seal failed (exit code {}): {}\nCommand: {}\n{}'.format(
+                proc.returncode, failure_reason(detail), shlex.join(cmd), '\n'.join(detail[-10:])))
+        log.debug('Seal output:\n%s', proc.stderr.strip())
+        return parse_stats(stats_file)
+    finally:
+        shutil.rmtree(tmp, ignore_errors=True)
+
+
+def versions():
+    """{"BBTools": version, "Java": version} of the Seal installation, "unknown" when they cannot be read."""
+    found = {'BBTools': 'unknown', 'Java': 'unknown'}
+    path = executable()
+    if path is None:
+        return found
+    try:  # A small heap: without -Xmx, seal.sh reserves most of the free memory, even for --version
+        out = subprocess.run([path, '-Xmx64m', '--version'], capture_output=True, text=True, timeout=60)
+        match = re.search(r'(?:BBMap|BBTools) version (\S+)', out.stdout + out.stderr)
+        if match:
+            found['BBTools'] = match.group(1)
+        java = Path(path).parent / 'java'
+        java = str(java) if java.exists() else shutil.which('java')
+        if java:
+            out = subprocess.run([java, '-version'], capture_output=True, text=True, timeout=60)
+            first = (out.stderr or out.stdout).strip().splitlines()
+            if first:
+                found['Java'] = first[0]
+    except (OSError, subprocess.SubprocessError):
+        pass
+    return found
+
+
+def system_memory_mb():
+    """Total memory of the machine in MB, or None when it cannot be read."""
+    try:
+        return os.sysconf('SC_PHYS_PAGES') * os.sysconf('SC_PAGE_SIZE') // (1024 * 1024)
+    except (AttributeError, ValueError, OSError):
+        return None
+
+
+def auto_memory(ref_bases, jobs=1):
+    """
+    Java heap size for Seal, from the size of the reference sequences: Seal holds every reference k-mer in memory,
+    at a few tens of bytes each. Never more than 85% of the machine's memory, shared between the jobs: without
+    -Xmx, seal.sh would reserve most of the free memory for each job at once.
+
+    :return: a size for -Xmx, e.g. "1024m"
+    """
+    needed = 512 + ref_bases * 40 / 1e6  # MB
+    megabytes = max(1024, -(-int(needed) // 256) * 256)  # Rounded up to 256 MB
+    total = system_memory_mb()
+    if total:
+        allowed = max(512, int(total * 0.85) // max(1, jobs))
+        if megabytes > allowed:
+            log.warning('The reference sequences need about %d MB of memory for Seal, but only %d MB is available '
+                        '(85%% of the machine, shared between %d job(s)). Seal may run out of memory: use fewer '
+                        'jobs, or --memory to set the size yourself.', megabytes, allowed, jobs)
+            megabytes = allowed
+    return '{}m'.format(megabytes)

seqcounter-1.0.0.dist-info/METADATA

@@ -0,0 +1,140 @@
+Metadata-Version: 2.4
+Name: seqcounter
+Version: 1.0.0
+Summary: Count the occurrences of reference sequences in sequencing reads or genome assemblies
+Author-email: Marc-Olivier Duceppe <marc-olivier.duceppe@inspection.gc.ca>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/duceppemo/seqcounter
+Project-URL: Documentation, https://github.com/duceppemo/seqcounter/wiki
+Project-URL: Changelog, https://github.com/duceppemo/seqcounter/wiki/Changelog
+Project-URL: Issues, https://github.com/duceppemo/seqcounter/issues
+Keywords: bioinformatics,kmer,counting,reference sequences,fastq,fasta,wgs,BBTools,Seal
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Science/Research
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Operating System :: MacOS
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Scientific/Engineering :: Bio-Informatics
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: test
+Requires-Dist: pytest>=7; extra == "test"
+Requires-Dist: pytest-cov>=5; extra == "test"
+Dynamic: license-file
+
+<p align="center">
+  <picture>
+    <source media="(prefers-color-scheme: dark)" srcset="https://raw.githubusercontent.com/duceppemo/seqcounter/master/assets/logo_dark.svg">
+    <img src="https://raw.githubusercontent.com/duceppemo/seqcounter/master/assets/logo.svg" width="520" alt="seqcounter: count reference sequences in reads or assemblies">
+  </picture>
+</p>
+
+<p align="center">
+  <a href="https://github.com/duceppemo/seqcounter/actions/workflows/tests.yml"><img src="https://github.com/duceppemo/seqcounter/actions/workflows/tests.yml/badge.svg" alt="Tests"></a>
+  <a href="https://codecov.io/gh/duceppemo/seqcounter"><img src="https://codecov.io/gh/duceppemo/seqcounter/graph/badge.svg" alt="Coverage"></a>
+  <a href="https://github.com/duceppemo/seqcounter/releases/latest"><img src="https://img.shields.io/github/v/release/duceppemo/seqcounter?cacheSeconds=3600" alt="Release"></a>
+  <a href="https://pypi.org/project/seqcounter/"><img src="https://img.shields.io/pypi/v/seqcounter?cacheSeconds=3600" alt="PyPI"></a>
+  <img src="https://img.shields.io/badge/python-3.10%E2%80%933.14-blue" alt="Python 3.10–3.14">
+  <a href="LICENSE"><img src="https://img.shields.io/github/license/duceppemo/seqcounter" alt="License"></a>
+  <a href="https://github.com/duceppemo/seqcounter/wiki"><img src="https://img.shields.io/badge/docs-wiki-informational" alt="Documentation"></a>
+</p>
+
+Count how many sequencing reads (fastq) or contigs (fasta) contain each sequence of a reference file, with
+[Seal](https://sourceforge.net/projects/bbmap/) from BBTools. Point it at a reference fasta file and a sample, or a
+folder of samples, and it writes one table of counts per reference sequence and per sample.
+
+Any set of short sequences works: spoligotype spacers, marker or resistance genes, primer or probe sequences,
+plasmid or phage fragments, barcodes, spike-ins. seqcounter does not interpret them; it counts them, reproducibly
+and in the same way for reads and for assemblies.
+
+```
+$ seqcounter -ref refs.fasta -i samples/ -o results/
+Reference   assembly  no_match  paired  single_end
+absent      0         0         0       0
+present     1         0         86      34
+twice       1         0         154     65
+```
+
+## Features
+* **Reads or assemblies**: single-end or paired-end fastq, or fasta, gzipped or not. Both mates of a pair are
+  counted, once each.
+* **Batch mode**: point it at a folder; fastq and fasta files are found recursively and R1/R2 files paired
+  automatically. Several samples can be counted at the same time.
+* **Both strands, and mismatches**: a reference is found on either strand, and with up to `-m` mismatches per k-mer
+  (one by default).
+* **Three reports**: the counts table (`refseqcounts.tsv`, the table the first version of seqcounter wrote, with the
+  command that produced it on its first line), a per-sample summary of how much was read and how much matched, and a
+  JSON report with the parameters, the software versions and the counts.
+* **Nothing is hidden**: references Seal cannot find (shorter than the k-mer size), names that would collide, and
+  samples that failed are reported, not silently dropped. A failed sample leaves the others readable.
+* **Nothing to configure**: no database, no index, no reference genome. Only the Python standard library, plus
+  BBTools.
+* **Tested**: 105 tests, 100% coverage, end to end on synthetic references, genomes and reads with known counts.
+
+## Installation
+```
+conda create -n seqcounter -c conda-forge -c bioconda bbmap python">=3.10"
+conda activate seqcounter
+pip install seqcounter
+```
+BBTools (which provides `seal.sh`) is not on PyPI, so it comes from bioconda; seqcounter itself needs nothing else.
+See [Installation](https://github.com/duceppemo/seqcounter/wiki/Installation) for other options, including running
+it from a clone with `python seqcounter.py`, as the first version did.
+
+## Quick start
+```
+seqcounter -ref refs.fasta -r1 sample_R1.fastq.gz -r2 sample_R2.fastq.gz -o results/  # Paired-end reads
+seqcounter -ref refs.fasta -r1 sample.fastq.gz -o results/                            # Single-end reads
+seqcounter -ref refs.fasta -r1 assembly.fasta -o results/                             # An assembly
+seqcounter -ref refs.fasta -i samples/ -o results/ -p 4                               # A folder, 4 at a time
+```
+`-ref` is a fasta file of the sequences to count: each one gives a row, named after the first word of its `>` line.
+The counts are printed and saved in `results/`. To see it work on data with known counts, run
+`bash examples/run_example.sh`, which generates its own references and samples.
+
+**What a count is**: the number of reads, or contigs, that contain the reference sequence, not the number of copies
+it has in them. A reference present twice in a single-contig assembly is counted once; in reads, about twice as many
+reads match it. See [How it works](https://github.com/duceppemo/seqcounter/wiki/How-it-works).
+
+## Documentation
+The **[wiki](https://github.com/duceppemo/seqcounter/wiki)** covers
+[installation](https://github.com/duceppemo/seqcounter/wiki/Installation),
+[usage and options](https://github.com/duceppemo/seqcounter/wiki/Usage),
+[output files](https://github.com/duceppemo/seqcounter/wiki/Output-files),
+[how it works](https://github.com/duceppemo/seqcounter/wiki/How-it-works),
+[troubleshooting](https://github.com/duceppemo/seqcounter/wiki/Troubleshooting) and the
+[FAQ](https://github.com/duceppemo/seqcounter/wiki/FAQ).
+
+## Citing
+If you use seqcounter, please cite it and BBTools, which does the counting:
+
+> Duceppe M-O. seqcounter: count the occurrences of reference sequences in sequencing reads or genome assemblies.
+> https://github.com/duceppemo/seqcounter
+
+> Bushnell B. BBTools. https://sourceforge.net/projects/bbmap/
+
+GitHub's **"Cite this repository"** button gives the citation in APA and BibTeX formats, from
+[`CITATION.cff`](CITATION.cff).
+
+## Related
+* [spoligotyper](https://github.com/duceppemo/spoligotyper) — *in silico* spoligotyping of the *M. tuberculosis*
+  complex. It counts the 43 spacers the way seqcounter counts any reference, and then reads them as a spoligotype,
+  with the species, the lineage and a PDF report.
+* [brucetyper](https://github.com/duceppemo/brucetyper) — *in silico* Bruce-ladder, Suis-ladder, AMOS and RB51
+  junction PCR for *Brucella*, from assemblies.
+
+## Contributing
+Bug reports, questions and pull requests are welcome: see [CONTRIBUTING.md](CONTRIBUTING.md).
+
+## Author
+Marc-Olivier Duceppe, Canadian Food Inspection Agency (CFIA): marc-olivier.duceppe@inspection.gc.ca
+
+## License
+[MIT](LICENSE)

seqcounter-1.0.0.dist-info/RECORD

@@ -0,0 +1,14 @@
+seqcounter/__init__.py,sha256=KYpNYEbG86FKu52mmSQ5vWqjinL6kh1RR_bY_OPSLjM,112
+seqcounter/__main__.py,sha256=hAZmm9T7RoDlCXwO5VSXl3ySu-_GssGBfw39BLS9eGM,123
+seqcounter/cli.py,sha256=FMgq-BQPWajmHlNK9AK8-4E-3e1o5anxGmjdUgToIoM,9434
+seqcounter/counts.py,sha256=ISCaj18FEZly0egZH41_u7FuBlZ50If78tc4PfgjQBA,7081
+seqcounter/errors.py,sha256=lPP1G7DyN2JYp3VxeqU1okTn3cgI4SJofAgFxjyLW3Y,129
+seqcounter/references.py,sha256=ob9qjrFDTqDeEib1h2r-c1JXsi7hbTK6Y69ydGNhKP4,3607
+seqcounter/samples.py,sha256=eAQRmGYhxHVwrlpHt4VJntKfJVSz16yBcvDpbN8g_wI,5314
+seqcounter/seal.py,sha256=LFsblV0ghPBDqivXWgoWeLXoaRsSzUAluhqJU_25HSY,12021
+seqcounter-1.0.0.dist-info/licenses/LICENSE,sha256=xKXtFTyegSo7EWwkmNW4r0_tuKmmeO_9t5Ogbh2okYY,1077
+seqcounter-1.0.0.dist-info/METADATA,sha256=KWENv-_jC1C59BL8kPXIljO9ppNF2cDYn_TUd0MZc7E,8038
+seqcounter-1.0.0.dist-info/WHEEL,sha256=mOdXR9C3wMVov7cSY8PY-XCzo3SmmWCHvGQr5csJoao,91
+seqcounter-1.0.0.dist-info/entry_points.txt,sha256=6hN0y7taCJNOWtWJP-BP0Ic4wC1EQbcoI5soTVK3fWk,51
+seqcounter-1.0.0.dist-info/top_level.txt,sha256=Uarq7-22b5aTo0JsmBA7A84AyW71MSEp7JxNtzld7Cc,11
+seqcounter-1.0.0.dist-info/RECORD,,

seqcounter-1.0.0.dist-info/WHEEL

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

seqcounter-1.0.0.dist-info/entry_points.txt

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

seqcounter-1.0.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 Marc-Olivier Duceppe
+
+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.

seqcounter-1.0.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+seqcounter