🥮 mooncakes.io

    moonbit-gffkit

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

    gff3
    gtf
    genomics
    bioinformatics
    annotation
    Download zip
    Version
    0.1.0
    License
    MIT
    Repository
    Last updated
    3 months ago
    Downloads
    30

    #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 issueModulesSkillsCLIBuild queueStatistics

    © 2026 mooncakes.io