SkillAgentSearch skills...

bio-compressed-files

Read and write compressed sequence files (gzip, bzip2, BGZF) using Biopython

Install / Use

npx skills add FreedomIntelligence/OpenClaw-Medical-Skills --skill bio-compressed-files

Installs into whichever agent you are using.

About this skill
📄

SKILL.md

Installable skill definition

Quality Score

86/100

Supported Platforms

Universal

Our assessment of bio-compressed-files

bio-compressed-files scores 86/100 on our quality scale, 2363rd of 4,700 Development & Engineering skills we index.

Its SKILL.md is 7.7 KB long, well organised into 29 sections with 19 code examples: a thorough specification that gives an agent plenty to work with.

With 3,034 GitHub stars, it is one of the more widely adopted skills in the catalogue.

Substance
29/30
Structure
20/20
Description
12/15
Adoption
15/20
Freshness
11/15

Maintenance, license and trust

  • The repository was last updated about 4 months ago. That is recent enough to be usable, but agent tooling moves fast, so check the instructions against your agent's current version.
  • Our last check on 2026-11-03 found the source still online.
  • No license is declared. By default that means all rights are reserved: you can read it, but reusing or redistributing it is not clearly permitted. Ask the author before building on it commercially.
  • Its trust signals score 86/100, with 1 caution from licensing, adoption, age or documentation. These come from repository metadata, not a code audit — read the skill file before letting an agent act on it.

Safety scan

No issues found

Our scan of the whole file found no instruction hijacking, hidden characters, credential access, data exfiltration or destructive commands. An AI review of the same text found nothing harmful.

AI review by kimi-k2.7-code on 2026-09-30. Automated pattern scan on 2026-09-30. It catches known dangerous patterns, not every risk — read a skill before letting an agent act on it.

bio-compressed-files compared with similar skills

All 4 of these similar skills score higher than bio-compressed-files; compare them before choosing.

SkillScoreStarsUpdatedFormat
bio-compressed-files (this skill)by FreedomIntelligence863.0k4mo agoSKILL.md
taste-skillby Leonxlnx100116.8k8d agoCLAUDE.md
Agent-Reachby Panniantong100112.3k9d agoCLAUDE.md
headroomby headroomlabs-ai10079.8ktodayCLAUDE.md
ai-job-searchby ai-job-search-dev10072.1ktodayCLAUDE.md

Frequently asked questions

How do I install bio-compressed-files?
Run npx skills add FreedomIntelligence/OpenClaw-Medical-Skills --skill bio-compressed-files. The install tabs above show the steps for each supported agent.
Which AI agents does bio-compressed-files work with?
It is written for Universal, as a SKILL.md file. Other agents that read the same format can often use it too.
Is bio-compressed-files safe to use?
Our scan of the whole file found no instruction hijacking, hidden characters, credential access, data exfiltration or destructive commands. An AI review of the same text found nothing harmful. It declares no license and scores 86/100 on trust signals. Skills are instructions an agent will follow, so read the file before installing it and do not approve commands you do not understand.
Is bio-compressed-files still maintained?
The repository was last updated about 4 months ago. That is recent enough to be usable, but agent tooling moves fast, so check the instructions against your agent's current version.

name: bio-compressed-files description: Read and write compressed sequence files (gzip, bzip2, BGZF) using Biopython. Use when working with .gz or .bz2 sequence files. Use BGZF for indexable compressed files. tool_type: python primary_tool: Bio.bgzf

Version Compatibility

Reference examples tested with: BioPython 1.83+, samtools 1.19+

Before using code patterns, verify installed versions match. If versions differ:

  • Python: pip show <package> then help(module.function) to check signatures

If code throws ImportError, AttributeError, or TypeError, introspect the installed package and adapt the example to match the actual API rather than retrying.

Compressed Files

Handle gzip, bzip2, and BGZF compressed sequence files with Biopython.

"Read a compressed sequence file" → Open a compressed file handle in text mode, then parse with the standard SeqIO interface.

  • gzip: gzip.open(path, 'rt') (Python stdlib)
  • bzip2: bz2.open(path, 'rt') (Python stdlib)
  • BGZF: bgzf.open(path, 'rt') (BioPython) or direct SeqIO.parse(path, fmt)

"Make a compressed file indexable" → Convert to BGZF format. Only BGZF supports SeqIO.index() on compressed data.

Required Imports

import gzip
import bz2
from Bio import SeqIO
from Bio import bgzf

Reading Compressed Files

Goal: Parse sequence records from compressed files without decompressing to disk.

Approach: Open a decompression handle in text mode ('rt'), then pass the handle to SeqIO.parse(). The parser works identically to uncompressed input.

Gzip (.gz) (BioPython 1.83+)

with gzip.open('sequences.fasta.gz', 'rt') as handle:
    for record in SeqIO.parse(handle, 'fasta'):
        print(record.id, len(record.seq))

Important: Use 'rt' (read text) mode, not 'rb' (read binary).

Bzip2 (.bz2) (BioPython 1.83+)

with bz2.open('sequences.fasta.bz2', 'rt') as handle:
    for record in SeqIO.parse(handle, 'fasta'):
        print(record.id, len(record.seq))

BGZF (Block Gzip) (BioPython 1.83+)

BGZF files can be read like regular gzip, but also support indexing:

for record in SeqIO.parse('sequences.fasta.bgz', 'fasta'):
    print(record.id)

with bgzf.open('sequences.fasta.bgz', 'rt') as handle:
    for record in SeqIO.parse(handle, 'fasta'):
        print(record.id)

Writing Compressed Files

Goal: Save sequence records directly to compressed files without an intermediate uncompressed step.

Approach: Open a compression handle in text mode ('wt'), then pass it to SeqIO.write().

Gzip (.gz)

with gzip.open('output.fasta.gz', 'wt') as handle:
    SeqIO.write(records, handle, 'fasta')

Bzip2 (.bz2)

with bz2.open('output.fasta.bz2', 'wt') as handle:
    SeqIO.write(records, handle, 'fasta')

BGZF (.bgz)

with bgzf.open('output.fasta.bgz', 'wt') as handle:
    SeqIO.write(records, handle, 'fasta')

BGZF: Indexable Compression

Goal: Enable random access to records in compressed sequence files.

Approach: Write sequences in BGZF (Block GZip Format) — the only compressed format supporting SeqIO.index() and SeqIO.index_db(). BGZF is a gzip variant used by BAM and tabix-indexed files.

Create Indexable Compressed File

from Bio import SeqIO, bgzf

records = SeqIO.parse('input.fasta', 'fasta')
with bgzf.open('output.fasta.bgz', 'wt') as handle:
    SeqIO.write(records, handle, 'fasta')

Index a BGZF File

records = SeqIO.index('sequences.fasta.bgz', 'fasta')
seq = records['target_id'].seq
records.close()

records = SeqIO.index_db('index.sqlite', 'sequences.fasta.bgz', 'fasta')

Convert Gzip to BGZF

"Convert gzip to indexable format" → Parse from gzip handle, write through BGZF handle.

from Bio import SeqIO, bgzf
import gzip

with gzip.open('input.fasta.gz', 'rt') as in_handle:
    with bgzf.open('output.fasta.bgz', 'wt') as out_handle:
        SeqIO.write(SeqIO.parse(in_handle, 'fasta'), out_handle, 'fasta')

Code Patterns

Read Gzipped FASTQ

with gzip.open('reads.fastq.gz', 'rt') as handle:
    records = list(SeqIO.parse(handle, 'fastq'))
print(f'Loaded {len(records)} reads')

Count Records in Gzipped File

with gzip.open('sequences.fasta.gz', 'rt') as handle:
    count = sum(1 for _ in SeqIO.parse(handle, 'fasta'))
print(f'{count} sequences')

Fast Count with Low-Level Parser

from Bio.SeqIO.FastaIO import SimpleFastaParser
import gzip

with gzip.open('sequences.fasta.gz', 'rt') as handle:
    count = sum(1 for _ in SimpleFastaParser(handle))

Convert Compressed to Uncompressed

with gzip.open('input.fasta.gz', 'rt') as in_handle:
    records = SeqIO.parse(in_handle, 'fasta')
    SeqIO.write(records, 'output.fasta', 'fasta')

Convert Uncompressed to Compressed

records = SeqIO.parse('input.fasta', 'fasta')
with gzip.open('output.fasta.gz', 'wt') as out_handle:
    SeqIO.write(records, out_handle, 'fasta')

Auto-Detect Compression

from pathlib import Path
from Bio import SeqIO, bgzf
import gzip
import bz2

def open_sequence_file(filepath, format):
    filepath = Path(filepath)
    suffix = filepath.suffix.lower()
    if suffix == '.gz':
        # Could be gzip or bgzf - bgzf handles both
        handle = bgzf.open(filepath, 'rt')
    elif suffix == '.bgz':
        handle = bgzf.open(filepath, 'rt')
    elif suffix == '.bz2':
        handle = bz2.open(filepath, 'rt')
    else:
        handle = open(filepath, 'r')
    return SeqIO.parse(handle, format)

Process Large Gzipped File (Memory Efficient)

with gzip.open('large.fastq.gz', 'rt') as handle:
    for record in SeqIO.parse(handle, 'fastq'):
        if len(record.seq) >= 100:
            process(record)

Compress Existing File (Raw Copy)

import shutil

with open('sequences.fasta', 'rb') as f_in:
    with gzip.open('sequences.fasta.gz', 'wb') as f_out:
        shutil.copyfileobj(f_in, f_out)

Compression Comparison

| Format | Extension | Indexable | Speed | Compression | |--------|-----------|-----------|-------|-------------| | Gzip | .gz | No | Fast | Good | | BGZF | .bgz | Yes | Fast | Good | | Bzip2 | .bz2 | No | Slow | Better | | LZMA | .xz | No | Slowest | Best |

When to Use Each Format

| Use Case | Recommended Format | |----------|-------------------| | Archive (no random access needed) | gzip or bzip2 | | Need to index compressed file | BGZF | | BAM files and tabix | BGZF (native) | | Maximum compression | bzip2 or xz | | Best speed | gzip or BGZF |

Common Errors

| Error | Cause | Solution | |-------|-------|----------| | TypeError: a bytes-like object is required | Used 'rb' mode | Use 'rt' for text mode | | UnicodeDecodeError | Wrong encoding | Try gzip.open(file, 'rt', encoding='latin-1') | | gzip.BadGzipFile | Not a gzip file | Check file extension matches actual format | | OSError: Not a gzipped file | Corrupt or wrong format | Verify file integrity | | SeqIO.index() fails on .gz | Regular gzip not indexable | Convert to BGZF first |

Decision Tree

Working with compressed sequence files?
├── Just reading sequentially?
│   └── Use gzip.open() or bz2.open() with 'rt' mode
├── Need to index the compressed file?
│   └── Convert to BGZF, then use SeqIO.index()
├── Writing compressed output?
│   ├── Will need to index later? → Use bgzf.open()
│   └── Just archiving? → Use gzip.open() or bz2.open()
└── Converting between formats?
    └── Parse with SeqIO, write to new handle

Related Skills

  • read-sequences - Core parsing functions used with compressed handles
  • write-sequences - Write to compressed output files
  • batch-processing - Process multiple compressed files
  • alignment-files - BAM files use BGZF natively; samtools handles compression

Related Skills

View on GitHub
GitHub Stars3.0k
CategoryDevelopment
Updated3mo ago
Forks413

Languages

Python

Trust signals

86/100

From repository metadata: license, adoption, age and documentation. Not a code audit — see the Safety scan above for what the skill file itself contains.

1 medium1 info