K-Dense-AI/scientific-agent-skills / skills/geniml
geniml
VerifiedSupports audited local Geniml genomic-interval workflows: validate BED and universe contracts, plan Region2Vec or scEmbed runs, inspect model/tokenizer compatibility, and assess consensus universes.
| File | Kind | Size |
|---|---|---|
| SKILL.md | skill md | 15.8 KB |
| references/bedspace.md | markdown | 10.0 KB |
| references/consensus_peaks.md | markdown | 11.0 KB |
| references/region2vec.md | markdown | 11.5 KB |
| references/scembed.md | markdown | 13.1 KB |
| references/utilities.md | markdown | 18.2 KB |
| scripts/__init__.py | script | 58 B |
| scripts/_common.py | script | 13.4 KB |
| scripts/bed_validator.py | script | 10.9 KB |
| scripts/consensus_plan.py | script | 13.9 KB |
| scripts/corpus_auditor.py | script | 10.4 KB |
| scripts/embedding_plan.py | script | 16.9 KB |
| scripts/model_artifact_inspector.py | script | 12.5 KB |
| scripts/tokenizer_compatibility.py | script | 10.7 KB |
scripts/bed_validator.py
View on GitHub#!/usr/bin/env python3
"""Validate one local BED file and emit a non-mutating normalization plan."""
from __future__ import annotations
import argparse
import re
import sys
from collections import Counter
from pathlib import Path
from _common import (
HARD_MAX_BYTES,
HARD_MAX_RECORDS,
MAX_COORDINATE,
SafetyError,
add_path_mode_argument,
display_path,
fail_json,
int_type,
iter_text_lines,
load_chrom_sizes,
local_path,
print_json,
sha256_file,
)
TOOL = "bed-validator"
_DECIMAL = re.compile(r"^-?[0-9]+$")
_VALID_STRANDS = {"+", "-", "."}
def build_parser() -> argparse.ArgumentParser:
parser = argparse.ArgumentParser(
description=(
"Validate a local BED file as 0-based half-open intervals and emit "
"a bounded normalization plan. The input is never rewritten."
)
)
parser.add_argument("--input", required=True, help="Local BED or BED.GZ file.")
parser.add_argument(
"--assembly",
required=True,
help="Declared assembly/accession recorded in the report.",
)
parser.add_argument(
"--chrom-sizes",
help="Optional local two-column chromosome-sizes file for contig/bounds checks.",
)
parser.add_argument(
"--max-bytes",
type=int_type(minimum=1, maximum=HARD_MAX_BYTES, label="max-bytes"),
default=512 * 1024**2,
help="Maximum compressed and expanded input bytes (default: 512 MiB).",
)
parser.add_argument(
"--max-records",
type=int_type(minimum=1, maximum=HARD_MAX_RECORDS, label="max-records"),
default=1_000_000,
help="Maximum text records, including headers (default: 1,000,000).",
)
parser.add_argument(
"--max-examples",
type=int_type(minimum=0, maximum=100, label="max-examples"),
default=10,
help="Maximum redacted issue examples (default: 10).",
)
parser.add_argument(
"--allow-empty",
action="store_true",
help="Do not treat a BED with zero data records as an error.",
)
add_path_mode_argument(parser)
return parser
def _record_issue(
counter: Counter[str],
examples: list[dict[str, int | str]],
code: str,
line_number: int,
maximum: int,
) -> None:
counter[code] += 1
if len(examples) < maximum:
examples.append({"code": code, "line": line_number})
def validate(args: argparse.Namespace) -> tuple[dict, int]:
if not args.assembly.strip() or len(args.assembly) > 200:
raise SafetyError("assembly must be a nonempty value of at most 200 characters")
bed_path = local_path(args.input, kind="file")
chrom_sizes: dict[str, int] | None = None
chrom_order: dict[str, int] | None = None
chrom_sizes_digest: str | None = None
if args.chrom_sizes:
chrom_path = local_path(args.chrom_sizes, kind="file")
sizes, order = load_chrom_sizes(
chrom_path,
max_bytes=min(args.max_bytes, 128 * 1024**2),
max_records=min(args.max_records, 1_000_000),
)
chrom_sizes = sizes
chrom_order = {chrom: index for index, chrom in enumerate(order)}
chrom_sizes_digest, _ = sha256_file(
chrom_path,
max_bytes=min(args.max_bytes, 128 * 1024**2),
)
errors: Counter[str] = Counter()
warnings: Counter[str] = Counter()
examples: list[dict[str, int | str]] = []
records = 0
skipped = 0
min_columns: int | None = None
max_columns = 0
contigs: set[str] = set()
seen: set[tuple[str, int, int]] = set()
duplicate_count = 0
overlap_count = 0
max_end_by_contig: dict[str, int] = {}
previous_sort_key: tuple[int | str, int, int] | None = None
unsorted_count = 0
strand_rows = 0
for line_number, line in iter_text_lines(
bed_path,
max_bytes=args.max_bytes,
max_records=args.max_records,
):
if not line:
skipped += 1
warnings["blank_line"] += 1
continue
if line.startswith("#") or line.startswith("track") or line.startswith("browser"):
skipped += 1
continue
fields = line.split("\t")
if len(fields) < 3:
_record_issue(
errors,
examples,
"fewer_than_three_columns",
line_number,
args.max_examples,
)
continue
records += 1
min_columns = len(fields) if min_columns is None else min(min_columns, len(fields))
max_columns = max(max_columns, len(fields))
chrom = fields[0]
if not chrom or any(character.isspace() or ord(character) < 32 for character in chrom):
_record_issue(
errors,
examples,
"invalid_contig",
line_number,
args.max_examples,
)
continue
start_text, end_text = fields[1], fields[2]
if not _DECIMAL.fullmatch(start_text) or not _DECIMAL.fullmatch(end_text):
_record_issue(
errors,
examples,
"non_decimal_coordinate",
line_number,
args.max_examples,
)
continue
start, end = int(start_text), int(end_text)
if start < 0 or end < 0:
_record_issue(
errors,
examples,
"negative_coordinate",
line_number,
args.max_examples,
)
continue
if start > MAX_COORDINATE or end > MAX_COORDINATE:
_record_issue(
errors,
examples,
"coordinate_integer_overflow",
line_number,
args.max_examples,
)
continue
if end == start:
_record_issue(
errors,
examples,
"zero_length_interval",
line_number,
args.max_examples,
)
continue
if end < start:
_record_issue(
errors,
examples,
"end_before_start",
line_number,
args.max_examples,
)
continue
if chrom_sizes is not None:
if chrom not in chrom_sizes:
_record_issue(
errors,
examples,
"unknown_contig",
line_number,
args.max_examples,
)
continue
if end > chrom_sizes[chrom]:
_record_issue(
errors,
examples,
"end_beyond_contig",
line_number,
args.max_examples,
)
continue
if len(fields) >= 6:
strand_rows += 1
if fields[5] not in _VALID_STRANDS:
_record_issue(
errors,
examples,
"invalid_bed6_strand",
line_number,
args.max_examples,
)
contigs.add(chrom)
key = (chrom, start, end)
if key in seen:
duplicate_count += 1
else:
seen.add(key)
prior_end = max_end_by_contig.get(chrom)
if prior_end is not None and start < prior_end:
overlap_count += 1
max_end_by_contig[chrom] = max(end, prior_end or end)
if chrom_order is None:
sort_key: tuple[int | str, int, int] = (chrom, start, end)
else:
sort_key = (chrom_order[chrom], start, end)
if previous_sort_key is not None and sort_key < previous_sort_key:
unsorted_count += 1
previous_sort_key = sort_key
if records == 0 and not args.allow_empty:
errors["no_data_records"] += 1
if chrom_sizes is None:
warnings["bounds_not_checked_without_chrom_sizes"] += 1
if unsorted_count:
warnings["out_of_order_records"] = unsorted_count
if duplicate_count:
warnings["duplicate_intervals"] = duplicate_count
if overlap_count:
warnings["overlapping_intervals"] = overlap_count
digest, size = sha256_file(bed_path, max_bytes=args.max_bytes)
actions: list[dict[str, str | int]] = []
if errors:
actions.append(
{
"action": "reject_or_quarantine_invalid_rows",
"count": sum(errors.values()),
}
)
if unsorted_count:
actions.append(
{
"action": "stable_sort",
"detail": (
"use chromosome-sizes order, then numeric start/end"
if chrom_order is not None
else "supply chromosome sizes before choosing contig order"
),
}
)
if duplicate_count:
actions.append(
{
"action": "decide_duplicate_policy",
"count": duplicate_count,
}
)
if chrom_sizes is None:
actions.append(
{
"action": "supply_chromosome_sizes",
"detail": "required before overflow/contig normalization",
}
)
actions.append(
{
"action": "preserve_coordinate_semantics",
"detail": "BED 0-based half-open; no implicit liftover or chr renaming",
}
)
report = {
"ok": not errors,
"tool": TOOL,
"contract": {
"assembly": args.assembly,
"coordinate_system": "0-based-half-open",
"input_mutated": False,
"network_used": False,
},
"input": {
"path": display_path(bed_path, 1, args.path_mode),
"sha256": digest,
"size_bytes": size,
},
"chromosome_sizes_sha256": chrom_sizes_digest,
"summary": {
"records": records,
"skipped_header_or_blank_lines": skipped,
"contig_count": len(contigs),
"minimum_columns": min_columns,
"maximum_columns": max_columns if records else None,
"bed6_or_wider_rows": strand_rows,
"duplicate_intervals": duplicate_count,
"overlap_observations": overlap_count,
"out_of_order_records": unsorted_count,
},
"errors": dict(sorted(errors.items())),
"warnings": dict(sorted(warnings.items())),
"issue_examples": examples,
"normalization_plan": actions,
}
return report, 0 if not errors else 2
def main() -> int:
parser = build_parser()
args = parser.parse_args()
try:
report, exit_code = validate(args)
print_json(report)
return exit_code
except (OSError, SafetyError, UnicodeError) as exc:
return fail_json(TOOL, exc)
if __name__ == "__main__":
sys.exit(main())
Related skills
| Skill | Stars | Updated | Works with | Status | Install |
|---|---|---|---|---|---|
| rea-analysis-optimizationmorluto/reaOptimize REA providers and shared analysis workflows for agent context, latency, CPU, and memory while preserving correctness and Evidence. Use for analysis bottlenecks and cache or query design; CI/test-suite optimization belongs to rea-ci-tests-audit. | Stars: 472k | Updated | Claude CodeCodex | Verified | Install |
| rea-ci-tests-auditmorluto/reaAudit REA CI and test suites for correctness, fixture drift, false passes, and measured performance; use for suite or workflow investigations and efficiency changes, rather than ordinary feature testing or a single test failure. | Stars: 472k | Updated | Claude CodeCodex | Verified | Install |
| rea-tool-designmorluto/reaAudit, investigate, design, or change REA investigation tools, CLI/MCP contracts, provider capabilities, and Evidence semantics. | Stars: 472k | Updated | Claude CodeCodex | Verified | Install |
| ponytail-auditDietrichGebert/ponytailQuality audit of the whole repo: bugs, security, real load, missing tests, speed, and what to delete. Most important first. | Stars: 194k | Updated | Claude CodeCodex | Verified | Install |