barcadia 3.2.0__py3-none-any.whl

barcadia/tools/generate_random_sequences.py

@@ -0,0 +1,98 @@
+#!/usr/bin/env python3
+"""
+generate_random_sequences.py
+
+Generate random DNA sequences for testing validation scripts (variable length sequences supported).
+
+Example usage: python src/barcadia/tools/generate_random_sequences.py --count 10000 --lengths 12 13
+
+Output: random DNA sequences (one per line as .txt)
+
+Optional arguments:
+--output: output file path (default: test/{count}_random_{min}to{max}bp_sequences.txt)
+
+Required arguments:
+--count: number of sequences to generate
+--lengths: possible lengths for sequences
+"""
+
+import argparse
+import random
+import os
+import sys
+import numpy as np
+
+# Add src directory to Python path for imports
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), '..'))
+
+from config_utils import decode_sequence  # type: ignore
+
+def generate_random_sequence(length):
+    """Generate a single random DNA sequence of given length as integer array"""
+    return np.random.randint(0, 4, size=length, dtype=np.int8)
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Generate random DNA sequences for testing",
+        formatter_class=argparse.ArgumentDefaultsHelpFormatter,
+        epilog="Example: python src/barcadia/tools/generate_random_sequences.py --count 10000 --lengths 12 13"
+    )
+    
+    parser.add_argument('--count', type=int, required=True,
+                       help='Number of sequences to generate')
+    parser.add_argument('--lengths', nargs='+', type=int, required=True,
+                       help='Possible lengths for sequences')
+    parser.add_argument('--output', type=str, 
+                       help='Output file path (default: test/{count}_random_{min}to{max}bp_sequences.txt)')
+    
+    args = parser.parse_args()
+    
+    # Validate arguments
+    if args.count <= 0:
+        raise ValueError("Count must be > 0")
+    
+    for length in args.lengths:
+        if length <= 0:
+            raise ValueError(f"All lengths must be > 0, got {length}")
+    
+    # Check if count exceeds maximum possible sequences across all lengths
+    total_max_possible = sum(4 ** length for length in args.lengths)
+    if args.count > total_max_possible:
+        raise ValueError(f"Count ({args.count}) exceeds maximum possible sequences for lengths {args.lengths} ({total_max_possible})")
+    
+    # Generate default output path if not specified
+    if args.output is None:
+        os.makedirs('test', exist_ok=True)
+        min_length = min(args.lengths)
+        max_length = max(args.lengths)
+        
+        # Handle single length vs range
+        if min_length == max_length:
+            length_range = str(min_length)
+        else:
+            length_range = f"{min_length}to{max_length}"
+        
+        args.output = f"test/{args.count}_random_{length_range}bp_sequences.txt"
+    
+    # Generate sequences, write to file, and count lengths in one loop
+    length_counts = {}
+    with open(args.output, 'w') as f:
+        for _ in range(args.count):
+            # Randomly choose a length from the provided options
+            chosen_length = random.choice(args.lengths)
+            seq_array = generate_random_sequence(chosen_length)
+            
+            # Write to file (convert to DNA string for output)
+            dna_string = decode_sequence(seq_array)
+            f.write(dna_string + '\n')
+            
+            # Count sequences by length
+            length_counts[chosen_length] = length_counts.get(chosen_length, 0) + 1
+    
+    length_breakdown = ", ".join([f"{count} at length {length}" for length, count in sorted(length_counts.items())])
+    
+    print(f"Generated {args.count} random DNA sequences with lengths: {length_breakdown}")
+    print(f"Output written to: {args.output}")
+
+if __name__ == "__main__":
+    main() 

barcadia/tools/memory_benchmark.py

@@ -0,0 +1,139 @@
+#!/usr/bin/env python3
+"""
+memory_benchmark.py
+
+Simple memory benchmarking utility for tracking maximum memory usage of barcadia commands.
+
+Example usage: 
+  python src/barcadia/tools/memory_benchmark.py barcadia generate --args
+  python src/barcadia/tools/memory_benchmark.py barcadia validate --args
+
+Output: memory usage report shown in terminal and memory_benchmark_{timestamp}.log file
+
+Optional arguments:
+--mem-output-dir: output directory for benchmark logs (default: test)
+
+Required arguments:
+command: the barcadia command to benchmark (e.g., generate or validate)
+"""
+
+import psutil
+import subprocess
+import sys
+import time
+import os
+import logging
+import argparse
+import os
+import sys
+
+# Add src directory to Python path for imports
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), '..'))
+
+from config_utils import setup_logging  # type: ignore
+
+def benchmark_command(command):
+    """
+    Benchmark memory usage of a barcadia command.
+    
+    Args:
+        command: The command to run (e.g., ['barcadia', 'generate', '--count', '1000'])
+    
+    Returns:
+        dict: Benchmark results
+    """
+    # Run the command as a subprocess and track its memory
+    start_time = time.time()
+    
+    # Start the subprocess; let it inherit stdout/stderr so it can print directly to terminal
+    process = subprocess.Popen(command)
+    
+    # Track memory usage of the subprocess
+    peak_memory = 0
+    try:
+        while process.poll() is None:  # While process is still running
+            try:
+                # Get memory usage of the subprocess
+                child_process = psutil.Process(process.pid)
+                memory_bytes = child_process.memory_info().rss
+                peak_memory = max(peak_memory, memory_bytes)
+                time.sleep(0.1)  # Sample every 100ms
+            except (psutil.NoSuchProcess, psutil.AccessDenied):
+                # Process might have finished or we don't have access
+                break
+        
+        # Wait for process to complete
+        process.wait()
+        return_code = process.returncode
+        stdout, stderr = None, None
+        
+    except Exception as e:
+        logging.error(f"Error tracking memory: {e}")
+        process.terminate()
+        return None
+    
+    duration = time.time() - start_time
+    peak_memory_mb = peak_memory / 1024 / 1024
+    
+    if return_code != 0:
+        logging.error(f"Command failed with return code {return_code}")
+        logging.error("Check the command's own log file for details")
+        return None
+    
+    return {
+        'command': ' '.join(command),
+        'duration_seconds': duration,
+        'peak_memory_mb': peak_memory_mb,
+        'return_code': return_code,
+        'stdout': stdout,
+        'stderr': stderr
+    }
+
+def main():
+    """Command-line interface for benchmarking barcadia commands."""
+    parser = argparse.ArgumentParser(
+        description="Benchmark memory usage of barcadia commands",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="Examples:\n"
+               "  python src/barcadia/tools/memory_benchmark.py barcadia validate --args\n"
+               "  python src/barcadia/tools/memory_benchmark.py barcadia generate --args"
+    )
+    
+    parser.add_argument('--mem-output-dir', type=str, default='test',
+                       help='Output directory for benchmark logs (default: test)')
+    parser.add_argument('command', nargs=argparse.REMAINDER, 
+                       help='The barcadia command to benchmark (e.g., generate or validate)')
+    
+    args = parser.parse_args()
+    
+    if not args.command:
+        parser.error("Please provide a barcadia command to benchmark")
+    
+    # Setup logging
+    args.output_dir = args.mem_output_dir
+    log_filepath = setup_logging(args, "memory_benchmark")
+    
+    # Log benchmark start
+    command_str = ' '.join(args.command)
+    logging.info(f"Starting memory benchmark for: {command_str}")
+    logging.info("-" * 50)
+    
+    # Run benchmark
+    result = benchmark_command(args.command)
+    
+    if result:
+        # Log benchmark results only
+        logging.info("-" * 50)
+        logging.info("BENCHMARK RESULTS:")
+        logging.info(f"Command: {result['command']}")
+        logging.info(f"Duration: {result['duration_seconds']:.2f} seconds")
+        logging.info(f"Peak Memory: {result['peak_memory_mb']:.2f} MB")
+        logging.info(f"Return Code: {result['return_code']}")
+        logging.info("-" * 50)
+        # Note: the benchmarked command prints its own log file path to the terminal.
+        logging.info(f"Benchmark log file: {log_filepath}")
+    else:
+        logging.error("Benchmark failed!")
+
+if __name__ == "__main__":
+    main() 

barcadia/validate_barcodes.py

@@ -0,0 +1,393 @@
+#!/usr/bin/env python3
+"""
+validate_barcodes.py
+
+Validate if provided lists of NGS barcodes satisfy all quality filters (variable length sequences supported).
+
+Program Overview:
+
+1. Load and parse input file(s) and report lengths distribution
+2. Check if sequences fail biological filters (GC content, homopolymer checks) - reports ALL violations per sequence
+3. For sequences passing biological filters, apply intelligent algorithm selection for distance validation (unless --skip-distance flag is enabled):
+   3a. Method selection logic (based on sequences passing biological filters):
+       - Small barcode sets (<10K sequences): Pairwise sequential
+       - Large barcode sets (≥10K sequences) with mixed lengths and/or min_distance > 4: Pairwise parallel (when multiple CPUs available, otherwise sequential)
+       - Large equal-length barcode sets (≥10K sequences) with min_distance ≤ 4: Neighbor enumeration
+   3b. Distance calculation: Hamming distance for equal-length sequences, Levenshtein for mixed lengths
+   3c. Progress logging during validation (every 10 chunks for pairwise parallel, every 10K sequences for neighbor enumeration)
+   3d. Early stopping on first distance violation with detailed reporting
+4. Generate comprehensive validation report with violation details 
+
+Input: list(s) of NGS barcodes (one per line as .txt). Multiple files supported, concatenated automatically.
+
+Output: validation report (validation_report_{timestamp}.txt) and validate_barcodes_{timestamp}.log file
+
+Optional arguments:
+--gc-min: minimum GC content (default: 0.4)
+--gc-max: maximum GC content (default: 0.6)
+--homopolymer-max: maximum allowed homopolymer repeat length (default: 2)
+--min-distance: minimum edit distance between barcodes (default: 3)
+--skip-distance: skip distance validation entirely (default: off)
+--output-dir: output directory for validation logs and reports (default: test)
+--cpus: number of CPUs to use for pairwise parallel distance validation (default: all available)
+
+Required arguments:
+--input: input file(s) containing NGS barcodes (one per line)
+"""
+
+import argparse
+import logging
+import os
+import time
+import multiprocessing as mp
+import sys
+from concurrent.futures import ProcessPoolExecutor
+from datetime import datetime
+
+# Import utility functions
+from .config_utils import decode_sequence, setup_logging, ExistingSequenceSet
+from .filter_utils import validate_filter_arguments, check_gc_content_int, check_homopolymer_int, calculate_distance, select_distance_method, generate_hamming_neighbors
+
+def validate_biological_filters(seq_array, gc_min, gc_max, homopolymer_max):
+    """Check if sequence passes all biological filters and return all violations"""
+    violations = []
+    
+    # Check GC content
+    if not check_gc_content_int(seq_array, gc_min, gc_max):
+        violations.append("GC content outside range")
+    
+    # Check homopolymer runs
+    if not check_homopolymer_int(seq_array, homopolymer_max):
+        violations.append("Homopolymer run too long")
+    
+    if violations:
+        return False, "; ".join(violations)
+    else:
+        return True, "Passes all filters"
+
+def log_violation_details(sequences, i, j, violation):
+    """Log distance violation and create violation details with DNA strings for reporting"""
+    logging.info(f"Early stopping: Found distance violation between sequences {violation[0]+1} and {violation[1]+1} (distance={violation[2]})")
+    seq1_str = decode_sequence(sequences[i])
+    seq2_str = decode_sequence(sequences[j])
+    return (violation[0]+1, violation[1]+1, seq1_str, seq2_str, violation[2])
+
+def validate_distances_neighbor_enum(sequences, min_distance):
+    """Validate using neighbor enumeration - much faster for appropriate cases"""
+    # Build hash set of all sequences for O(1) lookup
+    sequence_set = set(tuple(seq) for seq in sequences)
+    total_sequences = len(sequences)
+    
+    # Check each sequence for violations
+    for i, seq in enumerate(sequences):
+        # Progress logging every 10K sequences
+        if i % 10_000 == 0 and i > 0:
+            logging.info(f"Progress: {i:,}/{total_sequences:,} sequences processed "
+                       f"({i/total_sequences*100:.1f}%)")
+        
+        seq_array = list(seq)  # Make mutable copy for neighbor generation
+        
+        # Generate all neighbors within min_distance
+        for neighbor in generate_hamming_neighbors(seq_array, min_distance - 1):
+            if neighbor in sequence_set and neighbor != tuple(seq):
+                # Found a violation - get the index of the violating sequence
+                for j, other_seq in enumerate(sequences):
+                    if j != i and tuple(other_seq) == neighbor:
+                        # Calculate actual distance for reporting
+                        actual_distance = sum(a != b for a, b in zip(seq, other_seq))
+                        violation = (i, j, actual_distance)
+                        violation_details = log_violation_details(sequences, i, j, violation)
+                        sequences_processed = i + 1  # Number of sequences processed when violation found
+                        return True, sequences_processed, violation_details
+    
+    # No violations found - processed all sequences
+    return False, total_sequences, None
+
+def generate_pair_chunk(start_idx, chunk_size, n):
+    """Generate a chunk of pairs lazily starting from start_idx"""
+    pairs_generated = 0
+    current_idx = 0
+    
+    for i in range(n):
+        for j in range(i + 1, n):
+            if current_idx >= start_idx:
+                if pairs_generated >= chunk_size:
+                    return
+                yield (i, j)
+                pairs_generated += 1
+            current_idx += 1
+
+def validate_chunk(sequences_chunk, min_distance):
+    """Worker function for distance validation (can be used sequentially or in parallel)"""
+    pairs_checked = 0
+    n = len(sequences_chunk)
+    
+    # Use the lazy pair generator for memory efficiency
+    for i, j in generate_pair_chunk(0, n * (n - 1) // 2, n):
+        distance = calculate_distance(sequences_chunk[i], sequences_chunk[j], min_distance)
+        pairs_checked += 1
+        
+        if distance < min_distance:
+            violation = (i, j, distance)
+            violation_details = log_violation_details(sequences_chunk, i, j, violation)
+            return True, pairs_checked, violation_details
+    
+    return False, pairs_checked, None
+
+def validate_distances(sequences, min_distance, method, cpus, chunk_size):
+    """Unified distance validation with method selection and parallel/sequential execution"""
+    # Execute the chosen method
+    if method == "neighbor_enumeration":
+        # Use neighbor enumeration when set up is optimal (no parallelization involved)
+        return validate_distances_neighbor_enum(sequences, min_distance)
+    elif method == "pairwise_sequential" or cpus == 1:
+        # Use sequential for small barcode sets or single CPU
+        return validate_chunk(sequences, min_distance)
+    else:  # method == "pairwise" and cpus > 1
+        # Large dataset with multiple CPUs - always use parallel with pre-calculated chunk size
+        chunks = [sequences[i:i+chunk_size] for i in range(0, len(sequences), chunk_size)]
+        
+        with ProcessPoolExecutor(max_workers=cpus) as executor:
+            futures = [
+                executor.submit(validate_chunk, chunk, min_distance)
+                for chunk in chunks
+            ]
+            
+            # Process results with early stopping
+            total_pairs_checked = 0
+            for future in futures:
+                early_stopped, pairs_checked, violation_info = future.result()
+                total_pairs_checked += pairs_checked
+                
+                if early_stopped:
+                    # Cancel remaining futures for early stopping
+                    for f in futures:
+                        f.cancel()
+                    return True, total_pairs_checked, violation_info
+            
+            return False, total_pairs_checked, None
+
+def validate_barcodes_core(sequences, gc_min, gc_max, homopolymer_max, min_distance, has_mixed_lengths, skip_distance, cpus, output_dir, input_file, log_filepath):
+    """Main function to validate input barcode sets against biological filters and distance constraints"""
+    start_time = time.time()
+    
+    logging.info(f"Starting barcode validation...")
+    logging.info(f"Filter 1 (within-sequence), GC content: {gc_min:.1%} - {gc_max:.1%}")
+    logging.info(f"Filter 2 (within-sequence), Max homopolymer repeat: {homopolymer_max}")
+    logging.info(f"Filter 3 (between-sequence), Minimum edit distance: {min_distance}")
+    
+    # 1. Validate sequences for biological filters
+    valid_sequences = []
+    biological_violations = []
+    
+    for i, seq_array in enumerate(sequences):
+        # Check biological filters
+        is_valid, reason = validate_biological_filters(seq_array, gc_min, gc_max, homopolymer_max)
+        
+        if is_valid:
+            valid_sequences.append(seq_array)
+        else:
+            # Convert back to DNA string for reporting
+            dna_string = decode_sequence(seq_array)
+            biological_violations.append((i+1, dna_string, reason))
+    
+    logging.info(f"Biological filter (GC content and homopolymer repeats) results:")
+    logging.info(f"  Passed: {len(valid_sequences)} sequences")
+    logging.info(f"  Failed: {len(biological_violations)} sequences")
+    
+    # 2. Validate sequences for distance constraints
+    # Calculate total distance pairs for sequences that passed biological filters
+    n = len(valid_sequences)
+    total_pairs = n * (n - 1) // 2
+    
+    # Check if we should skip distance validation
+    distance_skipped = False
+    logging.info(f"Distance filter results:")
+    if skip_distance:
+        logging.info(f"Skipping distance validation (--skip-distance flag enabled)")
+        early_stopped = False
+        features_checked = 0
+        distance_skipped = True
+        validation_method = "skipped"
+        violation_info = None
+        logging.info(f"  Distance validation skipped")
+    # If not, continue with distance validation
+    else:        
+        logging.info(f"Validating distances for sequences that passed biological filters...")
+        # Determine method and calculate chunk size for pairwise method
+        method = select_distance_method(n, min_distance, has_mixed_lengths)
+        
+        # Calculate chunk size for pairwise method with multiple CPUs
+        chunk_size = None
+        if method == "pairwise_sequential":
+            logging.info(f"Using sequential pairwise distance checking (small barcode set for sequences that passed biological filters)")
+        elif method == "pairwise" and cpus == 1:
+            logging.info(f"Using sequential pairwise distance checking (1 CPU)")
+        elif method == "pairwise" and cpus > 1:
+            chunk_size = max(100000, total_pairs // (cpus * 10))
+            logging.info(f"Using parallel pairwise distance checking (chunk size: {chunk_size})")
+        
+        # Execute validation
+        early_stopped, features_checked, violation_info = validate_distances(valid_sequences, min_distance, method, cpus, chunk_size)
+        
+        # Log results
+        if method == "neighbor_enumeration":
+            logging.info(f"  Total sequences (that passed biological filters): {n}")
+            logging.info(f"  Sequences processed: {features_checked}")
+        else:
+            logging.info(f"  Total sequence pairs: {total_pairs:,} (sequences that passed biological filters)")
+            logging.info(f"  Pairs checked: {features_checked:,}")
+        
+        validation_method = method
+    
+    overall_valid = len(valid_sequences) == len(sequences) and not early_stopped
+    
+    duration = time.time() - start_time
+    
+    logging.info(f"Validation complete!")
+    logging.info(f"Overall validation: {'PASSED' if overall_valid else 'FAILED'}")
+    logging.info(f"Total time: {duration:.2f} seconds")
+    
+    # 3. Generate report
+    logging.info(f"Generating report...")
+    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+    report_file = os.path.join(output_dir, f"validation_report_{timestamp}.txt")
+    
+    with open(report_file, 'w') as f:
+        f.write("Barcode Validation Report\n")
+        f.write("=" * 50 + "\n\n")
+        
+        f.write(f"Input file: {input_file}\n")
+        f.write(f"Total sequences: {len(sequences)}\n\n")
+        f.write("Filter Settings:\n")
+        f.write(f"  GC content: {gc_min:.1%} - {gc_max:.1%}\n")
+        f.write(f"  Max homopolymer: {homopolymer_max}\n")
+        f.write(f"  Minimum distance: {min_distance}\n\n")
+        f.write(f"Biological filter passed: {len(valid_sequences)}\n")
+        f.write(f"Biological filter failed: {len(biological_violations)}\n")
+        
+        if distance_skipped:
+            f.write(f"Distance validation: SKIPPED (--skip-distance flag enabled)\n")
+        elif early_stopped:
+            f.write(f"Distance validation: EARLY STOPPED (found first violation)\n")
+            f.write(f"  Method used: {validation_method}\n")
+            if validation_method == "neighbor_enumeration":
+                f.write(f"  Sequences processed before stopping: {features_checked:,}\n")
+            else:
+                f.write(f"  Pairs checked before stopping: {features_checked:,}\n")
+        else:
+            f.write(f"Distance validation: PASSED (no violations found)\n")
+            f.write(f"  Method used: {validation_method}\n")
+            if validation_method == "neighbor_enumeration":
+                f.write(f"  Total sequences processed: {features_checked:,}\n")
+            else:
+                f.write(f"  Total pairs checked: {features_checked:,}\n")
+        f.write("\n")
+        
+        if biological_violations:
+            f.write("Biological Filter (GC content and homopolymer) Violations:\n")
+            f.write("-" * 30 + "\n")
+            for line_num, seq, reason in biological_violations:
+                f.write(f"Line {line_num}: {seq} - {reason}\n")
+            f.write("\n")
+        
+        # Add distance violation details if available
+        if violation_info is not None:
+            f.write("Distance Violations:\n")
+            f.write("-" * 19 + "\n")
+            seq1_line, seq2_line, seq1_str, seq2_str, distance = violation_info
+            f.write(f"Line {seq1_line}: {seq1_str} and Line {seq2_line}: {seq2_str} - distance {distance} (minimum required: {min_distance})\n")
+        f.write("\n")
+    
+    # Log file locations
+    if log_filepath:
+        logging.info(f"Log file: {log_filepath}")
+    logging.info(f"Report file: {report_file}")
+    
+    # Final output
+    if overall_valid:
+        print("All barcodes are valid!")
+    else:
+        print(f"VALIDATION FAILED!")
+
+def setup_argument_parser():
+    """Setup and return the argument parser for barcode validation"""
+    parser = argparse.ArgumentParser(
+        description="Validate DNA barcodes against quality filters (GC content, homopolymer repeats, minimum distance)",
+        formatter_class=argparse.ArgumentDefaultsHelpFormatter
+    )
+    
+    # Required arguments
+    parser.add_argument('--input', type=str, required=True, nargs='+',
+                       help='Input file(s) containing DNA barcodes (one per line)')
+
+    # Output arguments
+    parser.add_argument('--output-dir', type=str, default='test',
+                       help='Output directory for validation logs and reports')
+    
+    # Filter arguments with defaults
+    parser.add_argument('--gc-min', type=float, default=0.4,
+                       help='Minimum GC content (as fraction, e.g., 0.4 = 40%%)')
+    parser.add_argument('--gc-max', type=float, default=0.6,
+                       help='Maximum GC content (as fraction, e.g., 0.6 = 60%%)')
+    parser.add_argument('--homopolymer-max', type=int, default=2,
+                       help='Maximum allowed homopolymer repeat length')
+    parser.add_argument('--min-distance', type=int, default=3,
+                       help='Minimum edit distance between sequences')
+    
+    # Performance arguments
+    parser.add_argument('--cpus', type=int, default=mp.cpu_count(),
+                       help='Number of CPU cores to use for parallel distance validation')
+    
+    # Mode arguments
+    parser.add_argument('--skip-distance', action='store_true',
+                       help='Skip distance validation entirely')
+
+    return parser
+
+def validate_validator_arguments(args, length_counts):
+    """Validate validator-specific arguments (length, distance, homopolymer) and return has_mixed_lengths flag"""
+    input_length = max(length_counts.keys())
+
+    # Homopolymer repeat x max input length validation
+    if args.homopolymer_max >= input_length:
+        raise ValueError(f"Maximum homopolymer repeat length must be < max input length ({input_length}bp)")
+
+    # Minimum distance x max input length validation
+    if args.min_distance >= input_length:
+        raise ValueError(f"Minimum distance must be < max input length ({input_length}bp)")
+    
+    # Check for mixed lengths
+    has_mixed_lengths = len(length_counts) > 1
+    
+    return has_mixed_lengths
+
+def main(argv=None):
+    parser = setup_argument_parser()
+    args = parser.parse_args(argv)
+    log_filepath = setup_logging(args, "validate_barcodes")
+    validate_filter_arguments(args) # simple validation of filter arguments
+
+    # Load input files using ExistingSequenceSet
+    sequence_set = ExistingSequenceSet.from_input_files(args.input)
+    
+    # Validate validator-specific arguments and get mixed lengths flag
+    has_mixed_lengths = validate_validator_arguments(args, sequence_set.length_counts)
+    
+    # Validate barcodes
+    validate_barcodes_core(
+        sequences=sequence_set.sequences,
+        gc_min=args.gc_min,
+        gc_max=args.gc_max,
+        homopolymer_max=args.homopolymer_max,
+        min_distance=args.min_distance,
+        has_mixed_lengths=has_mixed_lengths,
+        skip_distance=args.skip_distance,
+        cpus=args.cpus,
+        output_dir=args.output_dir,
+        input_file=args.input,
+        log_filepath=log_filepath
+    )
+
+if __name__ == "__main__":
+    main(sys.argv[1:])