# Cleaning Up Messy Sequence Data in Python Raw sequencing files arrive with adapter contamination, low quality tails, ambiguous base calls, mixed line endings, duplicated records, and format quirks that break downstream tools. This guide walks you through a complete workflow for cleaning up messy sequence data in Python. By the end, you will be able to parse a raw FASTQ or FASTA file, trim adapters and low quality bases, filter reads by length and quality, standardize sequence strings, write a cleaned output file, and verify the result with summary statistics you can put in a methods section. Here is what you need before starting: - Python 3.9 or newer installed - The Biopython package (`pip install biopython`) - A raw sequencing file to work on, such as a FASTQ file from an Illumina run or a FASTA file exported from a database - A terminal or notebook where you can run Python Python has a long track record in this space. The Galaxy platform's tool suite for manipulating FASTQ data through quality filtering was implemented in Python [1], and dedicated pipelines such as ClinQC, which handles format conversion, quality control, trimming, and filtering for both Sanger and [next generation sequencing](/blog/guides/next-generation-sequencing) data, are also built in Python [2]. Learning this workflow in Python means the same skills carry into nearly every sequencing project you will touch. ## Why Sequencing Data Gets Messy Before writing any code, understand what kinds of mess you will encounter. **Adapters and barcodes.** Library preparation attaches short synthetic oligonucleotides to fragments. When an insert is shorter than the read length, the sequencer reads into the adapter, leaving artificial sequence at the end of reads. **Low quality tails and bases.** Sequencing quality degrades toward the end of reads. Quality is expressed as a Phred score, where Q = -10 log₁₀(P) and P is the probability the base call is wrong. Q20 means a 1 in 100 error rate, Q30 means a 1 in 1,000 error rate. These scores are stored as printable ASCII characters in FASTQ files. **Ambiguous bases.** A base call the instrument cannot resolve is written as N. IUPAC ambiguity codes such as R (A or G), Y (C or T), and W (A or T) also appear in consensus and reference sequences. **Format variants.** The [FASTQ format](/knowledge/bioinformatics/fastq-file-format-phred-scores-qc) is not one format. It has several historical variants that encode quality scores with different ASCII offsets, and a tool suite that handles "all of the commonly known FASTQ format variants" was specifically built for this reason [1]. If you assume the wrong variant, every quality score in your file is silently misread. **Structural mess.** Duplicated record identifiers, trailing whitespace, Windows carriage returns, blank lines inside records, mixed case, and annotation files (GFF3, GTF) with inconsistent feature names all appear routinely in public data. Each of these has a concrete fix, and the rest of this article shows the code for each one. ## Setting Up a Python Environment for Bioinformatics Install Biopython, the standard library for reading and writing biological file formats: ```bash python -m pip install biopython ``` Verify the install: ```bash python -c "import Bio; print(Bio.__version__)" ``` Expected output looks like: ``` 1.83 ``` Biopython is the backbone of most Python for bioinformatics work. It provides parsers for FASTA, FASTQ, GenBank, alignment formats, and more. Many specialized packages are built on top of it or alongside it. The modules for working with the SCOP structural classification and ASTRAL domain subsets, for example, were designed to work as part of the Biopython distribution [3]. For [data management](/blog/guides/data-management-basics-principles-processes-and-best-practices) in population genetics, EggLib provides a C++ core with a high level Python interface, and its implemented methods include file format conversion, sequence alignment editing, and polymorphism analysis [4]. You do not need all of these today. Biopython plus the standard library covers the cleaning steps in this guide. ## Step-by-Step: Clean Sequence Data in Python from a Raw FASTQ File ![Five step flow showing inspection, parsing, adapter trimming, tail trimming and filtering of a raw FASTQ file.](/article-images/illustrations/clean-sequence-data-python-fastq-cleaning-pipeline.webp) This walkthrough takes a raw Illumina-style FASTQ file called `raw_reads.fastq` and produces `clean_reads.fastq` plus a summary report. Follow the numbered steps in order. ### Step 1: Inspect the File Before Touching It Never clean blind. Look at the first few records: ```bash head -n 8 raw_reads.fastq ``` Expected output for a standard four-line FASTQ record: ``` @READ_0001 length=101 GATCGGAAGAGCACACGTCTGAACTCCAGTCACNNNNNNATCTCGTATGCCGTCTTCTGCTTG + FFFFFHHHHHJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJ#-0= MIN_INSERT: quals = record.letter_annotations["phred_quality"] return record[:idx], True return record, False ``` The `MIN_INSERT` guard matters. If the adapter sequence appears at position 3, you are probably looking at a very short insert or a spurious match, and trimming would leave a useless three base read. In that case the read should be dropped later by the length filter instead. ### Step 4: Trim Low Quality Tails with a Sliding Window Walk backward from the end of the read, one base at a time. While the mean quality of the last five bases falls below Q20, peel bases off: ```python from Bio.SeqRecord import SeqRecord WINDOW = 5 WINDOW_MIN_Q = 20 def trim_tail(record, window=WINDOW, min_q=WINDOW_MIN_Q): quals = record.letter_annotations["phred_quality"] cut = len(quals) while cut >= window and sum(quals[cut - window:cut]) / window < min_q: cut -= 1 if cut == len(quals): return record return SeqRecord( record.seq[:cut], id=record.id, description=record.description, letter_annotations={"phred_quality": quals[:cut]}, ) ``` This function builds a new `SeqRecord` with sliced sequence and sliced quality scores. Doing it explicitly avoids a subtle problem: relying on default slicing behavior for per-letter annotations is version sensitive, and an explicit rebuild makes the invariant obvious, that the sequence and the quality list always have the same length. ### Step 5: Filter by Length and Mean Quality ```python MIN_LEN = 50 # drop reads shorter than 50 bp MEAN_Q_MIN = 25 # drop reads with mean Q below 25 (roughly 0.3 percent error) def mean_quality(quals): return sum(quals) / len(quals) kept, dropped_short, dropped_lowq, had_adapter = 0, 0, 0, 0 clean_records = [] for record in SeqIO.parse("raw_reads.fastq", "fastq"): rec, trimmed = trim_adapter(record) if trimmed: had_adapter += 1 rec = trim_tail(rec) if len(rec) < MIN_LEN: dropped_short += 1 continue if mean_quality(rec.letter_annotations["phred_quality"]) < MEAN_Q_MIN: dropped_lowq += 1 continue clean_records.append(rec) kept += 1 from Bio import SeqIO SeqIO.write(clean_records, "clean_reads.fastq", "fastq") print(f"kept {kept} | adapter trimmed {had_adapter} | dropped short {dropped_short} | dropped low-Q {dropped_lowq}") ``` Expected output on a 20,000 read test file: ``` kept 18742 | adapter trimmed 1204 | dropped short 611 | dropped low-Q 647 ``` Sanity check the arithmetic: 18,742 + 611 + 647 = 20,000. The counts must always add up to the input total. If they do not, your loop has a logic bug or the file changed between runs. ### Step 6: Write the Report Persist the numbers from Step 5 to a small text file so the cleaning step is auditable: ```python with open("cleaning_report.txt", "w") as handle: handle.write(f"input_reads\t20000\n") handle.write(f"kept\t{kept}\n") handle.write(f"adapter_trimmed\t{had_adapter}\n") handle.write(f"dropped_short\t{dropped_short}\n") handle.write(f"dropped_low_quality\t{dropped_lowq}\n") ``` This mirrors what production pipelines do. ClinQC, for example, runs as a flexible pipeline that converts raw input files to a common format and then applies quality control, trimming, and filtering across Sanger and three NGS platforms, supporting many samples in a single run [2]. You are building the same logic at small scale, which makes the professional tools far easier to trust and debug later. ### Step 7: Verify the Cleaned File Reload the output and confirm it is internally consistent: ```python from Bio import SeqIO n = 0 bad = 0 lengths = [] for record in SeqIO.parse("clean_reads.fastq", "fastq"): n += 1 if len(record.seq) != len(record.letter_annotations["phred_quality"]): bad += 1 lengths.append(len(record)) print(f"records: {n}, inconsistent: {bad}") print(f"min length: {min(lengths)}, max length: {max(lengths)}") ``` Expected output: ``` records: 18742, inconsistent: 0 min length: 50, max length: 101 ``` Every record now passes the length floor, sequence and quality lengths agree, and the file parses cleanly. That is a clean dataset by definition: consistent, filtered, and traceable back to the numbers that justify each cut. ## Key Cleaning Parameters at a Glance ![Worked example turning a Phred score of 20 into a per-base error probability of 0.01.](/article-images/illustrations/clean-sequence-data-python-phred-error-probability.webp) | Parameter | Example value | What it controls | Failure mode if wrong | |--|--|--|--| | Adapter sequence | AGATCGGAAGAGC | The oligo prefix you cut out | Wrong sequence means adapters pass through into assembly | | Minimum insert position | 10 | Guards against trimming spurious early matches | Over-trimming destroys short but valid reads | | Sliding window size | 5 bases | Smooths single fluke low scores | Too large trims valid data, too small over-trims | | Window quality floor | Q20 (1 percent error) | Tail trimming cutoff | Too aggressive removes real signal near read ends | | Minimum read length | 50 bp | Drops fragments too short to map or assemble | Too high biases against short true fragments | | Mean quality floor | Q25 (about 0.3 percent error) | Drops globally poor reads | Too strict shrinks your dataset unnecessarily | | Quality encoding | Phred+33 vs Phred+64 | How ASCII characters map to scores | Wrong offset silently corrupts every score [1] | The Phred relationship is worth memorizing: Q = -10 log₁₀(P). Q20 corresponds to a 1 percent per-base error probability, Q30 to 0.1 percent, and Q40 to 0.01 percent. Every threshold in the table reduces to a statement about how much per-base error your downstream analysis can tolerate. ## Cleaning FASTA Files and Sequence Strings FASTA cleaning is different from FASTQ cleaning because there are no quality scores, only sequence strings, headers, and formatting artifacts. The messes are usually textual. ### Standardize Sequence Strings ```python VALID = set("ACGTUNRYKMSWBDHV-.") def clean_sequence(raw: str) -> str: seq = raw.strip().replace(" ", "").replace("\t", "").replace("\r", "") seq = seq.upper() invalid = set(seq) - VALID if invalid: raise ValueError(f"invalid characters in sequence: {sorted(invalid)}") return seq ``` This function handles the four most common FASTA string problems: 1. **Leading and trailing whitespace** from copy-pasted records, removed by `strip()` 2. **Internal spaces and tabs** from spreadsheet exports, removed by the replace calls 3. **Windows carriage returns** (`\r`), which sneak into the end of sequence lines and corrupt every downstream operation silently 4. **Case**, normalized to uppercase so that a match against `acgt` and `ACGT` behaves identically The final check raises a `ValueError` for anything outside the IUPAC nucleotide alphabet plus gap and unknown characters. Common real-world offenders are `X`, digits from junk copy-paste, and asterisks from translated protein endings. Fail loudly here. A silent `X` in the middle of a sequence is far more dangerous later than an exception now. ### Rewrite a Whole FASTA File in One Pass ```python from Bio import SeqIO cleaned = 0 with open("clean_sequences.fasta", "w") as out_handle: for record in SeqIO.parse("messy_sequences.fasta", "fasta"): record.seq = record.seq.upper() record.id = record.id.split() # strip junk after the first token record.description = record.id # keep header consistent SeqIO.write(record, out_handle, "fasta") cleaned += 1 print(f"cleaned {cleaned} records") ``` Expected output: ``` cleaned 312 records ``` ### Handle Annotation Files Genome annotations bring their own cleaning burden. Feature types arrive with ambiguous or inconsistent sequence ontology names, and pipelines often need to split a single annotation file into feature-specific pieces. GAD is a Python tool built exactly for this, handling GFF3 and GTF files, resolving ambiguous sequence ontology terms by either extracting them or treating them as genes or transcripts, and writing results as BED, GTF, GFF3, or FASTA for other programs to consume [5]. If your cleaning task is really "pull out all upstream regions from a GTF file," a purpose-built tool beats hand-written parsing, and the same principle applies broadly: clean the file only when no well-tested converter exists. Format conversion itself is a cleaning step. EggLib lists file format conversion among its implemented methods, alongside alignment editing and population genetic analyses, precisely because heterogeneous input formats are a permanent feature of [nucleotide sequence](/knowledge/molecular-biology/nucleotide-sequence) work [4]. ## Cleaning Variant Records and Named Mutations Variant data is a special kind of messy sequence data. The same point mutation can be written as `c.76A>C`, `p.Asp26Gly`, or `g.4321A>C` depending on the reference and the level of description, and the [Human Genome](/blog/guides/human-genome) Variation Society (HGVS) nomenclature standard governs how these strings should be written. Cleaning here means parsing, validating, and normalizing variant strings rather than trimming reads. The `hgvs` Python package was created for exactly this purpose. It facilitates parsing, manipulation, formatting, and validation of variants according to the HGVS specification, focusing on the subset of recommendations that describe sequence-level variation relevant to high-throughput sequencing in clinical diagnostics, and it is released under the Apache 2.0 license [6]. A typical cleaning pattern: ```python # parsing and normalizing HGVS strings with the hgvs package # pip install hgvs import hgvs.parser hp = hgvs.parser.Parser() variant = hp.parse_hgvs_vs("NM_000059.4:c.76A>C") print(type(variant), variant.pos_start, variant.ref, variant.alt) ``` The practical rule: never hand-parse HGVS strings with string slicing. The grammar has edge cases (intronic positions like `c.76+5A>G`, protein-level three-letter and one-letter codes, uncertain positions in parentheses) that a validated parser handles for you. ## Cleaning Alignments and Profiles Two related cleaning problems deserve their own section because they ruin analyses quietly. **Profile corruption from non-homologous segments.** When building PSI-BLAST position-specific scoring profiles for multidomain proteins or domains with long insertions, non-homologous sequence segments can be included in the profile, corrupting it and generating false positives in downstream searches. The HangOut procedure was developed to clean these erroneously extended PSI-BLAST alignments for a domain with a specified insertion position, producing better profiles, and it is implemented in Python [7]. The lesson generalizes: alignment cleaning is not cosmetic. A contaminated profile propagates errors into every search that uses it. **[Preprocessing](/blog/data-analysis/what-is-data-preprocessing) before phylogenomic inference.** In targeted enrichment studies (sequence capture of conserved loci), data must be preprocessed before any downstream inference: contigs must be assembled from reads, enriched loci must be identified from the off-target background, contigs must be aligned to one another, and alignments must be prepared for phylogenetic analysis. PHYLUCE is an efficient, easy-to-install Python package built to carry out exactly this preprocessing across hundreds of taxa and thousands of loci [8]. Cleaning in this context means the entire staged pipeline between raw reads and analysis-ready alignments. The common thread for both cases is that "clean" is defined relative to the downstream method. A profile clean enough for domain recognition may still be unfit for phylogenetic reconstruction, and vice versa. ## Working at Scale The loop-based code above is fine for tens of thousands of reads. At a million reads or thousands of files, change tactics. **Stream, do not load.** `SeqIO.parse` is already a generator, so it reads one record at a time. Never wrap it in `list()` for large files. If you must accumulate, accumulate filtered results, not raw inputs. **Use purpose-built, performant tools for structured pipelines.** Pairtools is a Python-based suite of modular command line tools for turning sequencing data from chromosome conformation assays into contact pairs, with core operations including parsing alignments, sorting, and PCR duplicate removal, chained into high-performance pipelines [9]. Its architecture, small tools composed into pipelines, is the pattern to imitate even when you write your own scripts. **For region-based genomic data at cohort scale,** PyGMQL was built on the GMQL system to scale data extraction and metadata-aware manipulation over arbitrary clusters and thousands of files, integrating with Spark under the hood while presenting a native Python interface [10]. When your cleaning task becomes "apply the same normalization to 5,000 ChIP-seq peak files," a per-file Python loop is the wrong shape of solution. **For integrated analysis of multiple [genomic data types](/knowledge/bioinformatics/genomic-data-types-a-primer-for-bioinformatics-beginners),** metaseq loads several genomic data formats into standard Python data structures and supports flexible, customized manipulation and visualization of high-throughput sequencing data, demonstrated by integrating RIP-seq, ChIP-seq, and RNA-seq datasets in one analysis [11]. **For single-cell [transcriptomics](/knowledge/bioinformatics/modern-transcriptomics-bulk-single-cell-spatial),** cleaning is usually statistical rather than textual. [Single-cell RNA sequencing](/knowledge/bioinformatics/single-cell-rna-sequencing-from-bulk-to-resolution) data has an intrinsically low signal-to-noise ratio, which challenges quantitative analysis, and tools such as pyVIPER provide flexible data transformation and postprocessing modules as part of protein activity inference from transcriptional data, with PyTorch-based GPU acceleration that reduced analysis time for large datasets from hours to minutes relative to the original R implementation [12]. The takeaway for a Python practitioner is that the definition of "messy" widens with data type, and so must your toolkit. ## How to Check Your Cleaning Worked Verification separates careful work from hopeful work. Run these checks on every cleaned file: **1. Count reconciliation.** Input records must equal kept records plus every discard category, exactly. This caught nothing less than arithmetic honesty in Step 5. **2. Length distribution.** Compare before and after: ```python from collections import Counter length_counts = Counter(lengths) for length in sorted(length_counts)[:10]: print(length, length_counts[length]) ``` Expected output shape: ``` 50 213 51 187 52 164 ... ``` A spike at exactly your `MIN_LEN` means many reads were trimmed right to the boundary, which is normal but worth knowing. A heavy mass below the floor would mean the filter failed. **3. Residual adapter check.** Re-run the adapter search on the cleaned file. The hit count should be near zero. A nonzero residual means your adapter string or trimming logic missed something. **4. Quality distribution.** After cleaning, no base should sit below your window floor except at read starts you chose not to trim. Plot or tabulate the minimum per-read quality to confirm. **5. Downstream smoke test.** Feed the cleaned file to the next tool in your pipeline and confirm it parses without warnings. Public-data-driven pipelines that reuse sequencing reads for pathogen screening, for example, work from clean reads against nucleotide databases and then analyze the results with in-house Python scripts [13]. If the next stage cannot parse your output, the cleaning step failed regardless of how good your numbers looked. A useful habit is to save the cleaning report, the input file checksum, and the script version together. Reproducibility in bioinformatics depends on being able to say exactly which version of which code turned which input file into which output file. ## Common Mistakes and Limitations These are the errors that cost people days. Each one comes from real failure modes in cleaning workflows. **Assuming one FASTQ encoding.** Older Illumina pipelines used Phred+64 offsets, and Sanger and modern Illumina use Phred+33. If you parse a Phred+64 file with a Phred+33 assumption, quality scores shift by 31 units and every threshold you apply is meaningless. The existence of a tool suite dedicated to handling all commonly known FASTQ variants exists precisely because this problem is endemic [1]. Confirm the encoding from the instrument documentation or by inspecting the range of ASCII characters in the quality line. **Cleaning the only copy of the raw data.** Never overwrite raw files. Write cleaned output to a new file and keep the raw data read-only. Every cleaning decision is reversible only if the input survives. **Cleaning mates independently in paired-end data.** If you trim or filter read 1 and read 2 in separate passes with independent discard rules, the pairs desynchronize, and every downstream alignment tool that expects ordered mates produces garbage or silent misassignments. Filter pairs jointly: keep both mates or drop both. **Over-trimming.** Aggressive windows and strict floors can shave reads down to fragments. Check your length distribution after trimming. If the median length collapsed, relax the parameters. There is a genuine tradeoff: low quality tails cause errors, but every trimmed base is information gone. **Trusting the file extension.** `.fastq` files that are gzipped, `.fasta` files with Windows line endings, and FASTQ files with truncated final records all parse differently or fail unpredictably. Inspect the first records before trusting anything. **Ignoring duplicate record identifiers.** Cleaning that rewrites headers or merges files can create duplicate IDs, which break tools that key on identifiers. After cleaning, verify ID uniqueness: ```python ids = [record.id for record in SeqIO.parse("clean_reads.fastq", "fastq")] print(len(ids), len(set(ids))) ``` If the two numbers differ, decide deliberately whether duplicates are legitimate (they can be, in amplicon data) or artifacts. **Hand-parsing standardized formats.** HGVS variant strings have a grammar with documented edge cases [6]. GFF3 and GTF files have ontology ambiguities that drove the creation of dedicated extraction tools [5]. String slicing feels faster until it silently misclassifies one record in ten thousand. **Storing sequences as growing strings in loops.** Concatenating to a string inside a loop is quadratic in Python. Accumulate in a list and join once, or better, process record by record and never hold the whole file in memory. **Confusing "clean" with "correct."** Cleaning removes artifacts, filtering removes low quality records, and neither fixes a swapped sample sheet or a wrong reference genome. Verification at each handoff is the only safeguard. **One limitation to state plainly:** the right thresholds in this guide, Q20 windows, 50 base floors, are sensible defaults, not universal truths. The correct values depend on your sequencing platform, library type, and downstream method, and you should justify your own choices in your methods section with your own data. ## Frequently Asked Questions ### Do I need Biopython to clean sequence data in Python? No, but it is strongly recommended. You can parse FASTA with plain string handling, but Biopython gives you robust parsers, correct handling of per-letter quality annotations, and writers for dozens of formats. It is the de facto standard library for Python for bioinformatics and the foundation most specialized packages build on. ### What quality threshold should I use for trimming FASTQ reads? There is no universal threshold. Q20 corresponds to a 1 percent per-base error probability and Q30 to 0.1 percent, so pick the error rate your downstream analysis tolerates. A sliding window trim with a Q20 window floor and a read length floor of 50 bases is a reasonable starting point that you should adjust based on your own length and quality distributions. ### How do I handle ambiguous bases like N in DNA sequences? Keep them in reads when the rest of the read is usable, because Ns are informative about where quality failed, and drop entire reads only when the N fraction is high. In reference or consensus sequences, preserve the correct IUPAC code rather than forcing a guess. Validate with an explicit character whitelist so unexpected characters raise an error instead of passing silently. ### Why do my paired-end reads get out of sync after trimming? Because each mate was filtered independently. If read 1 of a pair passes your filters but read 2 fails and gets dropped, the remaining files no longer align record for record. Filter pairs jointly and write surviving mates together so both output files stay synchronized. ### Should I clean the raw file directly or work on a copy? Always work on a copy and leave the raw data untouched. Write cleaned output to a new file with a new name, keep the cleaning script and its report, and treat the raw file as immutable evidence. Cleaning decisions change as methods evolve, and you can only revisit them if the input survives. ### How do I deal with different FASTQ quality encodings? Check the ASCII range of the quality line before parsing. Modern Sanger and Illumina 1.8 files use Phred+33, while older Illumina variants used higher offsets. The problem is well documented enough that a dedicated Python tool suite was built to handle all commonly known FASTQ variants within one framework, so use tools that declare which encoding they assume. ### Can I use Python instead of dedicated command line trimming tools? Yes for moderate file sizes and custom logic, and the Biopython-based workflow in this guide is a legitimate approach. For very large files or standard workflows, purpose-built tools are faster and better tested, and many of them, including pipeline suites for contact pair extraction [9] and integrated Sanger and NGS quality control pipelines [2], are themselves written in Python, so you can read and extend them. ### How do I know my cleaned data is good enough for downstream analysis? Run the verification checklist: count reconciliation, a length distribution comparison, a residual adapter scan, a quality floor check, and a smoke test in the next tool of your pipeline. If every record parses, sequence and quality lengths agree everywhere, and your discard counts add up to your input count, the file is structurally clean, and the remaining judgment calls are biological, not computational. ## Sources 1. [Manipulation of FASTQ data with Galaxy.](https://pubmed.ncbi.nlm.nih.gov/20562416/) 2. [ClinQC: a tool for quality control and cleaning of Sanger and NGS data in clinical research.](https://pubmed.ncbi.nlm.nih.gov/26830926/) 3. [A high level interface to SCOP and ASTRAL implemented in python.](https://pubmed.ncbi.nlm.nih.gov/16403221/) 4. [EggLib: processing, analysis and simulation tools for population genetics and genomics.](https://pubmed.ncbi.nlm.nih.gov/22494792/) 5. [GAD: A Python Script for Dividing Genome Annotation Files into Feature-Based Files.](https://pubmed.ncbi.nlm.nih.gov/32524530/) 6. [A Python package for parsing, validating, mapping and formatting sequence variants using HGVS nomenclature.](https://pubmed.ncbi.nlm.nih.gov/25273102/) 7. [HangOut: generating clean PSI-BLAST profiles for domains with long insertions.](https://pubmed.ncbi.nlm.nih.gov/20413635/) 8. [PHYLUCE is a software package for the analysis of conserved genomic loci.](https://pubmed.ncbi.nlm.nih.gov/26530724/) 9. [Pairtools: From sequencing data to chromosome contacts.](https://pubmed.ncbi.nlm.nih.gov/38809952/) 10. [PyGMQL: scalable data extraction and analysis for heterogeneous genomic datasets.](https://pubmed.ncbi.nlm.nih.gov/31703553/) 11. [metaseq: a Python package for integrative genome-wide analysis reveals relationships between chromatin insulators and associated nuclear mRNA.](https://pubmed.ncbi.nlm.nih.gov/25063299/) 12. [pyVIPER: a fast and scalable Python package for protein activity estimation and master regulator analysis of single-cell RNA sequencing data.](https://pubmed.ncbi.nlm.nih.gov/42332576/) 13. [An efficient strategy of screening for pathogens in wild-caught ticks and mosquitoes by reusing small RNA deep sequencing data.](https://pubmed.ncbi.nlm.nih.gov/24618575/)