🥮 mooncakes.io

moonbit-gffkit

MoonBit GFF3/GTF genome annotation parser, query library, and CLI.

gff3
gtf
genomics
bioinformatics
annotation
moon add wju-yuki111/moonbit-gffkit@0.1.0
Download zip
Version
0.1.0
License
MIT
Repository
Last updated
19 days ago
Downloads
3

Dependencies

README

#moonbit-gffkit

moonbit-gffkit is a MoonBit toolkit for GFF3 and GTF genome annotation files. It parses annotation rows, keeps attributes queryable, builds a gene-transcript-exon model, and exports compact JSON or BED output for downstream scripts.

The project is intentionally small at the edges and solid in the middle: pure MoonBit library code, a native CLI, fixture-driven tests, and no runtime service requirement.

#Features

  • Parse GFF3 and GTF records with checked coordinate validation.
  • Preserve GFF3 key=value attributes, flags, and common percent escapes.
  • Preserve GTF quoted attributes, including values with spaces.
  • Query features by type, attribute, and genomic interval.
  • Build gene -> transcript -> exon/CDS/UTR hierarchies.
  • Export annotations as BED6, deterministic JSON, and tabular summary counts.
  • Run as a library or through the gffkit CLI.

#Install

This repository targets the current MoonBit toolchain used during development:

moon version --all

Build and test:

moon check --target all --deny-warn
moon test --target all --deny-warn
moon fmt --check
moon info

#CLI Usage

moon run cmd/gffkit -- validate testdata/basic.gff3
moon run cmd/gffkit -- stats testdata/basic.gtf
moon run cmd/gffkit -- filter exon testdata/basic.gff3
moon run cmd/gffkit -- to-bed testdata/basic.gff3
moon run cmd/gffkit -- to-json testdata/basic.gtf

Example output:

features	5
genes	1
transcripts	1
exons	2
cds	1

#Library Example

let text =
  #|chr1	RefSeq	gene	1000	5000	.	+	.	ID=gene:BRCA1;Name=BRCA1
  #|
let annotation = parse_gff3(text)
let genes = annotation.to_gene_models()
println(genes[0].id)

#API Overview

  • parse_gff3(text) parses GFF3 text.
  • parse_gtf(text) parses GTF text.
  • parse_auto(text) detects GFF3/GTF from headers and attribute style.
  • Annotation::filter_by_type(type) returns features of a type.
  • Annotation::find_by_attribute(key, value) returns matching features.
  • Annotation::overlapping(seqid=..., start=..., end=...) returns interval overlaps.
  • Annotation::to_gene_models() builds gene-centric models.
  • Annotation::to_bed() exports BED6.
  • Annotation::to_json() exports stable JSON.
  • Annotation::summary() returns count totals.
  • Reference catalogs expose common feature terms, attributes, biotypes, validation rules, evidence labels, and sequence region labels.

#Scope

The first release focuses on annotation text processing. It does not implement tabix indexing, BGZF compression, FASTA sequence extraction, or a genome browser. The public model is shaped so those pieces can be added later without replacing the parser.

#Repository Notes

The repository is prepared for hackathon review with source files, tests, CI, license, examples, and submission notes. The current MoonBit source scale is about 5.4k lines including generated interface information. See docs/source-notes.md and docs/competition-checklist.md.

#License

MIT.

#
Annotation

source
pub(all) struct Annotation {
  format : Format
  features : Array[Feature]
  diagnostics : Array[Diagnostic]
} derive(Eq, 
Debug)

#
Annotation::attribute_frequencies

source
fn Annotation::attribute_frequencies(self : Annotation) -> Array[AttributeFrequency]

#
Annotation::attribute_frequency_tsv

source
fn Annotation::attribute_frequency_tsv(self : Annotation) -> String

#
Annotation::build_interval_index

source
fn Annotation::build_interval_index(self : Annotation) -> IntervalIndex

#
Annotation::coding_features

source
fn Annotation::coding_features(self : Annotation) -> Array[Feature]

#
Annotation::count_by_type

source
fn Annotation::count_by_type(self : Annotation) -> Array[FeatureCount]

#
Annotation::exon_features

source
fn Annotation::exon_features(self : Annotation) -> Array[Feature]

#
Annotation::feature_table_tsv

source
fn Annotation::feature_table_tsv(self : Annotation) -> String

#
Annotation::features_by_class

source
fn Annotation::features_by_class(self : Annotation, class : FeatureClass) -> Array[Feature]

#
Annotation::filter_by_type

source
fn Annotation::filter_by_type(self : Annotation, feature_type : String) -> Array[Feature]

#
Annotation::find_by_attribute

source
fn Annotation::find_by_attribute(self : Annotation, key : String, value : String) -> Array[Feature]

#
Annotation::gene_features

source
fn Annotation::gene_features(self : Annotation) -> Array[Feature]

#
Annotation::gene_metrics_tsv

source
fn Annotation::gene_metrics_tsv(self : Annotation) -> String

#
Annotation::gene_table_tsv

source
fn Annotation::gene_table_tsv(self : Annotation) -> String

#
Annotation::infer_attribute_schema

source
fn Annotation::infer_attribute_schema(self : Annotation) -> AttributeSchema

#
Annotation::metrics

source
fn Annotation::metrics(self : Annotation) -> AnnotationMetrics

#
Annotation::overlapping

source
fn Annotation::overlapping(self : Annotation, seqid~ : String, start~ : Int, end~ : Int) -> Array[Feature]

#
Annotation::quality_report

source
fn Annotation::quality_report(self : Annotation) -> QualityReport

#
Annotation::sequence_summaries

source
fn Annotation::sequence_summaries(self : Annotation) -> Array[SequenceSummary]

#
Annotation::sequence_summary_tsv

source
fn Annotation::sequence_summary_tsv(self : Annotation) -> String

#
Annotation::summary

source
fn Annotation::summary(self : Annotation) -> Summary

#
Annotation::to_bed

source
fn Annotation::to_bed(self : Annotation) -> String

#
Annotation::to_bed12

source
fn Annotation::to_bed12(self : Annotation) -> String

#
Annotation::to_gene_models

source
fn Annotation::to_gene_models(self : Annotation) -> Array[GeneModel]

#
Annotation::to_gff3

source
fn Annotation::to_gff3(self : Annotation) -> String

#
Annotation::to_gtf

source
fn Annotation::to_gtf(self : Annotation) -> String

#
Annotation::to_json

source
fn Annotation::to_json(self : Annotation) -> String

#
Annotation::transcript_features

source
fn Annotation::transcript_features(self : Annotation) -> Array[Feature]

#
Annotation::transcript_metrics_tsv

source
fn Annotation::transcript_metrics_tsv(self : Annotation) -> String

#
Annotation::transcript_table_tsv

source
fn Annotation::transcript_table_tsv(self : Annotation) -> String

#
Annotation::type_report

source
fn Annotation::type_report(self : Annotation) -> Array[TypeReportRow]

#
Annotation::type_report_tsv

source
fn Annotation::type_report_tsv(self : Annotation) -> String

#
Annotation::unknown_reference_terms

source
fn Annotation::unknown_reference_terms(self : Annotation) -> Array[String]

#
Annotation::utr_features

source
fn Annotation::utr_features(self : Annotation) -> Array[Feature]

#
Annotation::validate

source
fn Annotation::validate(self : Annotation) -> ValidationReport

#
AnnotationMetrics

source
pub(all) struct AnnotationMetrics {
  feature_count : Int
  gene_count : Int
  transcript_count : Int
  exon_count : Int
  cds_count : Int
  seqid_count : Int
  total_feature_bases : Int
} derive(Eq, 
Debug)

#
AnnotationMetrics::is_empty

source
fn AnnotationMetrics::is_empty(self : AnnotationMetrics) -> Bool

#
AnnotationMetrics::mean_feature_length

source
fn AnnotationMetrics::mean_feature_length(self : AnnotationMetrics) -> Double

#
AnnotationMetrics::to_text

source
fn AnnotationMetrics::to_text(self : AnnotationMetrics) -> String

#
Attribute

source
pub(all) struct Attribute {
  key : String
  value : String
} derive(Eq, 
Debug)

#
AttributeFrequency

source
pub(all) struct AttributeFrequency {
  key : String
  count : Int
} derive(Eq, 
Debug)

#
AttributeFrequency::to_tsv_row

source
fn AttributeFrequency::to_tsv_row(self : AttributeFrequency) -> String

#
AttributePresence

source
pub(all) enum AttributePresence {
  Required
  Optional
  Rare
} derive(Eq, 
Debug)

#
AttributePresence::to_string

source
fn AttributePresence::to_string(self : AttributePresence) -> String

#
AttributeReference

source
pub(all) struct AttributeReference {
  key : String
  format : String
  category : String
  description : String
  typical_scope : String
} derive(Eq, 
Debug)

#
AttributeReference::to_tsv_row

source
fn AttributeReference::to_tsv_row(self : AttributeReference) -> String

#
AttributeSchema

source
pub(all) struct AttributeSchema {
  rows : Array[AttributeSchemaRow]
} derive(Eq, 
Debug)

#
AttributeSchema::optional_keys

source
fn AttributeSchema::optional_keys(self : AttributeSchema) -> Array[String]

#
AttributeSchema::rare_keys

source
fn AttributeSchema::rare_keys(self : AttributeSchema) -> Array[String]

#
AttributeSchema::required_keys

source
fn AttributeSchema::required_keys(self : AttributeSchema) -> Array[String]

#
AttributeSchema::to_tsv

source
fn AttributeSchema::to_tsv(self : AttributeSchema) -> String

#
AttributeSchemaRow

source
pub(all) struct AttributeSchemaRow {
  key : String
  count : Int
  feature_count : Int
  presence : AttributePresence
  example_value : String
} derive(Eq, 
Debug)

#
Bed12Record

source
pub(all) struct Bed12Record {
  chrom : String
  chrom_start : Int
  chrom_end : Int
  name : String
  score : String
  strand : String
  thick_start : Int
  thick_end : Int
  item_rgb : String
  block_count : Int
  block_sizes : Array[String]
  block_starts : Array[String]
} derive(Eq, 
Debug)

#
Bed12Record::to_line

source
fn Bed12Record::to_line(self : Bed12Record) -> String

#
BiotypeReference

source
pub(all) struct BiotypeReference {
  name : String
  family : String
  coding : Bool
  description : String
} derive(Eq, 
Debug)

#
BiotypeReference::to_tsv_row

source
fn BiotypeReference::to_tsv_row(self : BiotypeReference) -> String

#
Diagnostic

source
pub(all) struct Diagnostic {
  line : Int
  message : String
} derive(Eq, 
Debug)

#
EvidenceReference

source
pub(all) struct EvidenceReference {
  code : String
  category : String
  source : String
  description : String
  typical_scope : String
} derive(Eq, 
Debug)

#
EvidenceReference::to_tsv_row

source
fn EvidenceReference::to_tsv_row(self : EvidenceReference) -> String

#
Feature

source
pub(all) struct Feature {
  seqid : String
  source : String
  feature_type : String
  start : Int
  end : Int
  score : String?
  strand : Strand
  phase : String?
  attributes : Array[Attribute]
} derive(Eq, 
Debug)

#
Feature::attribute

source
fn Feature::attribute(self : Feature, key : String) -> String?

#
Feature::bed_start

source
fn Feature::bed_start(self : Feature) -> Int

#
Feature::display_name

source
fn Feature::display_name(self : Feature) -> String

#
Feature::feature_class

source
fn Feature::feature_class(self : Feature) -> FeatureClass

#
Feature::has_parent

source
fn Feature::has_parent(self : Feature) -> Bool

#
Feature::is_coding_feature

source
fn Feature::is_coding_feature(self : Feature) -> Bool

#
Feature::is_exon_feature

source
fn Feature::is_exon_feature(self : Feature) -> Bool

#
Feature::is_gene_feature

source
fn Feature::is_gene_feature(self : Feature) -> Bool

#
Feature::is_regulatory_feature

source
fn Feature::is_regulatory_feature(self : Feature) -> Bool

#
Feature::is_repeat_feature

source
fn Feature::is_repeat_feature(self : Feature) -> Bool

#
Feature::is_transcript_feature_public

source
fn Feature::is_transcript_feature_public(self : Feature) -> Bool

#
Feature::is_utr_feature

source
fn Feature::is_utr_feature(self : Feature) -> Bool

#
Feature::length

source
fn Feature::length(self : Feature) -> Int

#
Feature::overlaps

source
fn Feature::overlaps(self : Feature, seqid~ : String, start~ : Int, end~ : Int) -> Bool

#
Feature::reference_term

source
fn Feature::reference_term(self : Feature) -> ReferenceTerm

#
Feature::region_string

source
fn Feature::region_string(self : Feature) -> String

#
Feature::span

source
fn Feature::span(self : Feature) -> Span

#
Feature::stable_id

source
fn Feature::stable_id(self : Feature) -> String

#
Feature::to_bed_line

source
fn Feature::to_bed_line(self : Feature) -> String

#
Feature::to_debug_tsv

source
fn Feature::to_debug_tsv(self : Feature) -> String

#
Feature::to_gff3_line

source
fn Feature::to_gff3_line(self : Feature) -> String

#
Feature::to_gtf_line

source
fn Feature::to_gtf_line(self : Feature) -> String

#
Feature::to_half_open_end

source
fn Feature::to_half_open_end(self : Feature) -> Int

#
Feature::to_zero_based_start

source
fn Feature::to_zero_based_start(self : Feature) -> Int

#
FeatureClass

source
pub(all) enum FeatureClass {
  GeneClass
  TranscriptClass
  ExonClass
  CdsClass
  UtrClass
  RegulatoryClass
  RepeatClass
  OtherClass(String)
} derive(Eq, 
Debug)

#
FeatureClass::to_string

source
fn FeatureClass::to_string(self : FeatureClass) -> String

#
FeatureCount

source
pub(all) struct FeatureCount {
  feature_type : String
  count : Int
} derive(Eq, 
Debug)

#
FeatureTermReference

source
pub(all) struct FeatureTermReference {
  name : String
  category : String
  parent : String
  description : String
  typical_attribute : String
} derive(Eq, 
Debug)

#
FeatureTermReference::to_tsv_row

source
fn FeatureTermReference::to_tsv_row(self : FeatureTermReference) -> String

#
Format

source
pub(all) enum Format {
  GFF3
  GTF
} derive(Eq, 
Debug)

#
Format::to_string

source
fn Format::to_string(self : Format) -> String

#
GeneMetrics

source
pub(all) struct GeneMetrics {
  gene_id : String
  transcript_count : Int
  total_exon_bases : Int
  total_cds_bases : Int
  longest_transcript_id : String
  longest_transcript_bases : Int
  gene_span_bases : Int
} derive(Eq, 
Debug)

#
GeneMetrics::is_multi_transcript

source
fn GeneMetrics::is_multi_transcript(self : GeneMetrics) -> Bool

#
GeneMetrics::to_tsv_row

source
fn GeneMetrics::to_tsv_row(self : GeneMetrics) -> String

#
GeneModel

source
pub(all) struct GeneModel {
  id : String
  name : String?
  feature : Feature
  transcripts : Array[TranscriptModel]
  others : Array[Feature]
} derive(Eq, 
Debug)

#
GeneModel::metrics

source
fn GeneModel::metrics(self : GeneModel) -> GeneMetrics

#
IntervalHit

source
pub(all) struct IntervalHit {
  feature : Feature
  index : Int
} derive(Eq, 
Debug)

#
IntervalIndex

source
pub(all) struct IntervalIndex {
  features : Array[Feature]
} derive(Eq, 
Debug)

#
IntervalIndex::count_seqid

source
fn IntervalIndex::count_seqid(self : IntervalIndex, seqid : String) -> Int

#
IntervalIndex::features_on

source
fn IntervalIndex::features_on(self : IntervalIndex, seqid : String) -> Array[Feature]

#
IntervalIndex::query

source
fn IntervalIndex::query(self : IntervalIndex, seqid~ : String, start~ : Int, end~ : Int) -> Array[IntervalHit]

#
IntervalIndex::query_span

source
fn IntervalIndex::query_span(self : IntervalIndex, span : Span) -> Array[IntervalHit]

#
IntervalIndex::seqids

source
fn IntervalIndex::seqids(self : IntervalIndex) -> Array[String]

#
QualityReport

source
pub(all) struct QualityReport {
  score : Int
  feature_count : Int
  gene_count : Int
  transcript_count : Int
  exon_count : Int
  validation_errors : Int
  validation_warnings : Int
  has_required_hierarchy : Bool
  has_attributes : Bool
  has_multiple_seqids : Bool
} derive(Eq, 
Debug)

#
QualityReport::grade

source
fn QualityReport::grade(self : QualityReport) -> String

#
QualityReport::to_text

source
fn QualityReport::to_text(self : QualityReport) -> String

#
ReferenceTerm

source
pub(all) struct ReferenceTerm {
  name : String
  category : String
  description : String
} derive(Eq, 
Debug)

#
SequenceRegionReference

source
pub(all) struct SequenceRegionReference {
  name : String
  category : String
  topology : String
  description : String
  typical_scope : String
} derive(Eq, 
Debug)

#
SequenceRegionReference::to_tsv_row

source
fn SequenceRegionReference::to_tsv_row(self : SequenceRegionReference) -> String

#
SequenceSummary

source
pub(all) struct SequenceSummary {
  seqid : String
  feature_count : Int
  min_start : Int
  max_end : Int
  strand_plus_count : Int
  strand_minus_count : Int
  strand_unknown_count : Int
} derive(Eq, 
Debug)

#
SequenceSummary::span_bases

source
fn SequenceSummary::span_bases(self : SequenceSummary) -> Int

#
SequenceSummary::to_tsv_row

source
fn SequenceSummary::to_tsv_row(self : SequenceSummary) -> String

#
Severity

source
pub(all) enum Severity {
  Info
  Warning
  Error
} derive(Eq, 
Debug)

#
Severity::to_string

source
fn Severity::to_string(self : Severity) -> String

#
Span

source
pub(all) struct Span {
  seqid : String
  start : Int
  end : Int
} derive(Eq, 
Debug)

#
Span::contains

source
fn Span::contains(self : Span, position~ : Int) -> Bool

#
Span::distance_to

source
fn Span::distance_to(self : Span, other : Span) -> Int?

#
Span::expand

source
fn Span::expand(self : Span, bases : Int) -> Span

#
Span::length

source
fn Span::length(self : Span) -> Int

#
Span::overlap_length

source
fn Span::overlap_length(self : Span, other : Span) -> Int

#
Span::overlaps

source
fn Span::overlaps(self : Span, other : Span) -> Bool

#
Span::shift

source
fn Span::shift(self : Span, offset : Int) -> Span

#
Span::to_bed_end

source
fn Span::to_bed_end(self : Span) -> Int

#
Span::to_bed_start

source
fn Span::to_bed_start(self : Span) -> Int

#
Span::to_region_string

source
fn Span::to_region_string(self : Span) -> String

#
Strand

source
pub(all) enum Strand {
  Plus
  Minus
  Unknown
  NotApplicable
} derive(Eq, 
Debug)

#
Strand::to_string

source
fn Strand::to_string(self : Strand) -> String

#
Summary

source
pub(all) struct Summary {
  feature_count : Int
  gene_count : Int
  transcript_count : Int
  exon_count : Int
  cds_count : Int
} derive(Eq, 
Debug)

#
TranscriptMetrics

source
pub(all) struct TranscriptMetrics {
  transcript_id : String
  exon_count : Int
  cds_count : Int
  utr_count : Int
  exon_bases : Int
  cds_bases : Int
  utr_bases : Int
  intron_count : Int
  intron_bases : Int
  span_bases : Int
} derive(Eq, 
Debug)

#
TranscriptMetrics::coding_ratio

source
fn TranscriptMetrics::coding_ratio(self : TranscriptMetrics) -> Double

#
TranscriptMetrics::has_cds

source
fn TranscriptMetrics::has_cds(self : TranscriptMetrics) -> Bool

#
TranscriptMetrics::has_introns

source
fn TranscriptMetrics::has_introns(self : TranscriptMetrics) -> Bool

#
TranscriptMetrics::to_tsv_row

source
fn TranscriptMetrics::to_tsv_row(self : TranscriptMetrics) -> String

#
TranscriptModel

source
pub(all) struct TranscriptModel {
  id : String
  name : String?
  feature : Feature
  exons : Array[Feature]
  cds : Array[Feature]
  utrs : Array[Feature]
  others : Array[Feature]
} derive(Eq, 
Debug)

#
TranscriptModel::metrics

source

#
TranscriptModel::to_bed12

source

#
TypeReportRow

source
pub(all) struct TypeReportRow {
  feature_type : String
  count : Int
  total_bases : Int
} derive(Eq, 
Debug)

#
TypeReportRow::to_tsv_row

source
fn TypeReportRow::to_tsv_row(self : TypeReportRow) -> String

#
ValidationIssue

source
pub(all) struct ValidationIssue {
  severity : Severity
  code : String
  line : Int
  feature_type : String
  message : String
} derive(Eq, 
Debug)

#
ValidationIssue::is_error

source
fn ValidationIssue::is_error(self : ValidationIssue) -> Bool

#
ValidationIssue::is_info

source
fn ValidationIssue::is_info(self : ValidationIssue) -> Bool

#
ValidationIssue::is_warning

source
fn ValidationIssue::is_warning(self : ValidationIssue) -> Bool

#
ValidationIssue::rule_reference

source

#
ValidationIssue::summary

source
fn ValidationIssue::summary(self : ValidationIssue) -> String

#
ValidationReport

source
pub(all) struct ValidationReport {
  issues : Array[ValidationIssue]
} derive(Eq, 
Debug)

#
ValidationReport::codes

source
fn ValidationReport::codes(self : ValidationReport) -> Array[String]

#
ValidationReport::count_by_severity

source
fn ValidationReport::count_by_severity(self : ValidationReport, severity : Severity) -> Int

#
ValidationReport::error_count

source
fn ValidationReport::error_count(self : ValidationReport) -> Int

#
ValidationReport::filter_by_code

source
fn ValidationReport::filter_by_code(self : ValidationReport, code : String) -> Array[ValidationIssue]

#
ValidationReport::filter_by_feature_type

source
fn ValidationReport::filter_by_feature_type(self : ValidationReport, feature_type : String) -> Array[ValidationIssue]

#
ValidationReport::has_errors

source
fn ValidationReport::has_errors(self : ValidationReport) -> Bool

#
ValidationReport::info_count

source
fn ValidationReport::info_count(self : ValidationReport) -> Int

#
ValidationReport::issue_count

source
fn ValidationReport::issue_count(self : ValidationReport) -> Int

#
ValidationReport::summary_tsv

source
fn ValidationReport::summary_tsv(self : ValidationReport) -> String

#
ValidationReport::to_text

source
fn ValidationReport::to_text(self : ValidationReport) -> String

#
ValidationReport::warning_count

source
fn ValidationReport::warning_count(self : ValidationReport) -> Int

#
ValidationRuleReference

source
pub(all) struct ValidationRuleReference {
  code : String
  severity : Severity
  format : String
  description : String
  repair_hint : String
} derive(Eq, 
Debug)

#
ValidationRuleReference::to_tsv_row

source
fn ValidationRuleReference::to_tsv_row(self : ValidationRuleReference) -> String

#
coding_reference_biotypes

source
fn coding_reference_biotypes() -> Array[BiotypeReference]

#
evidence_references

source
fn evidence_references() -> Array[EvidenceReference]

#
evidence_references_by_category

source
fn evidence_references_by_category(category : String) -> Array[EvidenceReference]

#
evidence_references_by_source

source
fn evidence_references_by_source(source : String) -> Array[EvidenceReference]

#
example_complex_gff3

source
fn example_complex_gff3() -> String

#
example_complex_gtf

source
fn example_complex_gtf() -> String

#
feature_term_references

source
fn feature_term_references() -> Array[FeatureTermReference]

#
feature_term_references_by_category

source
fn feature_term_references_by_category(category : String) -> Array[FeatureTermReference]

#
find_evidence_reference

source
fn find_evidence_reference(code : String) -> EvidenceReference

#
find_feature_term_reference

source
fn find_feature_term_reference(name : String) -> FeatureTermReference

#
find_reference_attribute

source
fn find_reference_attribute(key : String) -> AttributeReference

#
find_reference_biotype

source
fn find_reference_biotype(name : String) -> BiotypeReference

#
find_reference_term

source
fn find_reference_term(name : String) -> ReferenceTerm

#
find_sequence_region_reference

source
fn find_sequence_region_reference(name : String) -> SequenceRegionReference

#
find_validation_rule_reference

source
fn find_validation_rule_reference(code : String) -> ValidationRuleReference

#
noncoding_reference_biotypes

source
fn noncoding_reference_biotypes() -> Array[BiotypeReference]

#
parse_auto

source
fn parse_auto(text : String) -> Annotation raise

#
parse_gff3

source
fn parse_gff3(text : String) -> Annotation raise

#
parse_gtf

source
fn parse_gtf(text : String) -> Annotation raise

#
reference_attributes

source
fn reference_attributes() -> Array[AttributeReference]

#
reference_attributes_by_category

source
fn reference_attributes_by_category(category : String) -> Array[AttributeReference]

#
reference_attributes_by_format

source
fn reference_attributes_by_format(format : String) -> Array[AttributeReference]

#
reference_attributes_tsv

source
fn reference_attributes_tsv() -> String

#
reference_biotypes

source
fn reference_biotypes() -> Array[BiotypeReference]

#
reference_biotypes_by_family

source
fn reference_biotypes_by_family(family : String) -> Array[BiotypeReference]

#
reference_term_categories

source
fn reference_term_categories() -> Array[String]

#
reference_terms

source
fn reference_terms() -> Array[ReferenceTerm]

#
reference_terms_by_category

source
fn reference_terms_by_category(category : String) -> Array[ReferenceTerm]

#
sequence_region_references

source
fn sequence_region_references() -> Array[SequenceRegionReference]

#
sequence_region_references_by_category

source
fn sequence_region_references_by_category(category : String) -> Array[SequenceRegionReference]

#
sequence_region_references_by_topology

source
fn sequence_region_references_by_topology(topology : String) -> Array[SequenceRegionReference]

#
validation_rule_references

source
fn validation_rule_references() -> Array[ValidationRuleReference]

#
validation_rule_references_by_format

source
fn validation_rule_references_by_format(format : String) -> Array[ValidationRuleReference]

Source Files

Powered by MoonBit

Site sourceReport issuePackagesBuild queueSkillsStatistics

© 2026 mooncakes.io