Skip to content

Organism, taxonomy and microbiome queries

Query model organisms, taxonomy and microbiome data.

1) Query taxonomy and TaxIDs

  • Purpose: Resolve a species name, TaxID or alias into taxonomy records for subsequent queries and downloads.
  • Method: Query NCBI Taxonomy and normalize its reports into QueryResult.
  • API: dnakit.search.taxonomy(query[required], report[optional], children[optional], include_lineage[optional], ranks[optional], page_size[optional], page_token[optional], config[optional], verbose[optional])
  • Input: A species name or TaxID; optional report type, children, lineage, ranks, pagination and SearchConfig. Requires network access.
  • Output: Returns QueryResult with query records, source provider, and pagination information.
  • Example code:
from dnakit.search import SearchConfig, taxonomy

config = SearchConfig(timeout=30, max_response_bytes=20_000_000, max_records=100)
result = taxonomy("human", page_size=5, config=config, verbose=False)
print(result.query_type, result.provider, len(result.records))
  • Example output: Return format only; the network query was not run. The live database determines the record count.
taxonomy NCBI Datasets <record count returned>

2) Retrieve Drosophila gene details

  • Purpose: Retrieve Drosophila gene details.
  • Method: Use AllianceGenome to query or submit the supplied input and parse the response.
  • API： dnakit.databases.fly_base_get_gene(*, gene_id, verbose=True)
  • Input: Provide gene_id.
  • Output: Returns a mapping with id, symbol, name, species and related fields.
  • Example code:
import dnakit

result = dnakit.databases.fly_base_get_gene(
    gene_id='FB:FBgn0003996',
    verbose=False,
)
print(result)
  • Example output: The response has the following shape; records depend on the input and source.

Response-shape excerpt; <…> denotes type placeholders, not a captured query result.

{
  "id": "<string>",
  "symbol": "<string>",
  "name": "<string>",
  "species": {
    "name": "<string>",
    "short_name": "<string>",
    "taxon_id": "<string>",
    "data_provider": "<string>"
  },
  "gene_synopsis": "<string>",
  "automated_gene_synopsis": "<string>",
  "synonyms": [
    "<string>"
  ],
  "so_term": "<string>"
}

Full parameters and usage notes

3) Retrieve Drosophila gene alleles and phenotypes

  • Purpose: Retrieve Drosophila gene alleles and phenotypes.
  • Method: Use AllianceGenome to query or submit the supplied input and parse the response.
  • API： dnakit.databases.fly_base_get_gene_alleles(*, gene_id, limit=None, page=None, verbose=True)
  • Input: Provide gene_id.
  • Output: Returns a list of records; each record includes id, symbol, symbol_text, category and related fields.
  • Example code:
import dnakit

result = dnakit.databases.fly_base_get_gene_alleles(
    gene_id='FB:FBgn0000490',
    limit=5,
    verbose=False,
)
print(result)
  • Example output: The response has the following shape; records depend on the input and source.

Response-shape excerpt; <…> denotes type placeholders, not a captured query result.

[
  {
    "id": "<string>",
    "symbol": "<string>",
    "symbol_text": "<string>",
    "category": "<string>",
    "has_disease": "<boolean>",
    "has_phenotype": "<boolean>",
    "variants": [
      "<object>"
    ]
  }
]

Full parameters and usage notes

4) Retrieve Drosophila gene disease models

  • Purpose: Retrieve Drosophila gene disease models.
  • Method: Use AllianceGenome to query or submit the supplied input and parse the response.
  • API： dnakit.databases.fly_base_get_gene_disease_models(*, gene_id, limit=None, page=None, verbose=True)
  • Input: Provide gene_id.
  • Output: Returns a list of records; each record includes model_id, model_name, gene_symbol, gene_id and related fields.
  • Example code:
import dnakit

result = dnakit.databases.fly_base_get_gene_disease_models(
    gene_id='FB:FBgn0000490',
    limit=5,
    verbose=False,
)
print(result)
  • Example output: The response has the following shape; records depend on the input and source.

Response-shape excerpt; <…> denotes type placeholders, not a captured query result.

[
  {
    "model_id": "<string>",
    "model_name": "<string>",
    "gene_symbol": "<string>",
    "gene_id": "<string>",
    "data_provider": "<string>",
    "diseases": [
      "<object>"
    ]
  }
]

Full parameters and usage notes

5) Retrieve Drosophila developmental and anatomical expression

  • Purpose: Retrieve Drosophila developmental and anatomical expression.
  • Method: Use AllianceGenome to query or submit the supplied input and parse the response.
  • API： dnakit.databases.fly_base_get_gene_expression(*, gene_id, limit=None, verbose=True)
  • Input: Provide gene_id.
  • Output: Returns a mapping with total_annotations, returned, annotations and related fields.
  • Example code:
import dnakit

result = dnakit.databases.fly_base_get_gene_expression(
    gene_id='FB:FBgn0000490',
    limit=5,
    verbose=False,
)
print(result)
  • Example output: The response has the following shape; records depend on the input and source.

Response-shape excerpt; <…> denotes type placeholders, not a captured query result.

{
  "total_annotations": "<integer>",
  "returned": "<integer>",
  "annotations": [
    {
      "stage": "<string>",
      "location": "<string>",
      "data_provider": "<string>",
      "reference": "<string>"
    }
  ]
}

Full parameters and usage notes

6) Retrieve Drosophila molecular and genetic interactions

  • Purpose: Retrieve Drosophila molecular and genetic interactions.
  • Method: Use AllianceGenome to query or submit the supplied input and parse the response.
  • API： dnakit.databases.fly_base_get_gene_interactions(*, gene_id, interaction_type=None, limit=None, page=None, verbose=True)
  • Input: Provide gene_id.
  • Output: Returns a list of records; each record includes subject_gene_id, subject_symbol, interactor_gene_id, interactor_symbol and related fields.
  • Example code:
import dnakit

result = dnakit.databases.fly_base_get_gene_interactions(
    gene_id='FB:FBgn0000490',
    interaction_type='genetic',
    limit=5,
    verbose=False,
)
print(result)
  • Example output: The response has the following shape; records depend on the input and source.

Response-shape excerpt; <…> denotes type placeholders, not a captured query result.

[
  {
    "subject_gene_id": "<string>",
    "subject_symbol": "<string>",
    "interactor_gene_id": "<string>",
    "interactor_symbol": "<string>",
    "interactor_species": "<string>",
    "interaction_type": "<string>"
  }
]

Full parameters and usage notes

7) Retrieve cross-species orthologs of a Drosophila gene

  • Purpose: Retrieve cross-species orthologs of a Drosophila gene.
  • Method: Use AllianceGenome to query or submit the supplied input and parse the response.
  • API： dnakit.databases.fly_base_get_gene_orthologs(*, gene_id, limit=None, page=None, stringency=None, verbose=True)
  • Input: Provide gene_id.
  • Output: Returns a list of records; each record includes subject_gene_id, subject_symbol, subject_species, ortholog_gene_id and related fields.
  • Example code:
import dnakit

result = dnakit.databases.fly_base_get_gene_orthologs(
    gene_id='FB:FBgn0004647',
    limit=10,
    verbose=False,
)
print(result)
  • Example output: The response has the following shape; records depend on the input and source.

Response-shape excerpt; <…> denotes type placeholders, not a captured query result.

[
  {
    "subject_gene_id": "<string>",
    "subject_symbol": "<string>",
    "subject_species": "<string>",
    "ortholog_gene_id": "<string>",
    "ortholog_symbol": "<string>",
    "ortholog_species": "<string>",
    "is_best_score": "<string>",
    "is_best_score_reverse": "<string>"
  }
]

Full parameters and usage notes

  • Purpose: Search integrated Drosophila genomics records.
  • Method: Use Base to query or submit the supplied input and parse the response.
  • API： dnakit.databases.fly_mine_search(*, q, size=None, format=None, facet_Category=None, verbose=True)
  • Input: Provide q.
  • Output: Returns a mapping with totalHits, facets, results and related fields.
  • Example code:
import dnakit

result = dnakit.databases.fly_mine_search(
    q='Notch',
    size=5,
    format='json',
    verbose=False,
)
print(result)
  • Example output: The response has the following shape; records depend on the input and source.

Response-shape excerpt; <…> denotes type placeholders, not a captured query result.

{
  "totalHits": "<integer>",
  "facets": "<object>",
  "results": [
    {
      "id": "<integer>",
      "type": "<string>",
      "relevance": "<number>",
      "fields": "<object>"
    }
  ]
}

Full parameters and usage notes

9) Retrieve GBIF species details by taxon key

  • Purpose: Retrieve GBIF species details by taxon key.
  • Method: Use Base to query or submit the supplied input and parse the response.
  • API： dnakit.databases.gbif_get_species(*, speciesKey, verbose=True)
  • Input: Provide speciesKey.
  • Output: Returns a mapping with key, scientificName, canonicalName, vernacularName and related fields.
  • Example code:
import dnakit

result = dnakit.databases.gbif_get_species(
    speciesKey=2435099,
    verbose=False,
)
print(result)
  • Example output: The response has the following shape; records depend on the input and source.

Response-shape excerpt; <…> denotes type placeholders, not a captured query result.

{
  "key": "<integer>",
  "scientificName": "<string>",
  "canonicalName": "<string>",
  "vernacularName": "<string>",
  "authorship": "<string>",
  "rank": "<string>",
  "taxonomicStatus": "<string>",
  "kingdom": "<string>"
}

Full parameters and usage notes

10) Search GBIF species names and taxonomy

  • Purpose: Search GBIF species names and taxonomy.
  • Method: Use GBIF to query or submit the supplied input and parse the response.
  • API： dnakit.databases.gbif_search_species(*, query, limit=None, offset=None, verbose=True)
  • Input: Provide query.
  • Output: The data field contains the GBIF species search response and pagination information.
  • Example code:
import dnakit

result = dnakit.databases.gbif_search_species(
    query='Arabidopsis thaliana',
    limit=3,
    verbose=False,
)
print(result)
  • Example output: The data field contains the GBIF species search response and pagination information.

Full parameters and usage notes

11) Retrieve GTDB species clusters and their genomes

  • Purpose: Retrieve GTDB species clusters and their genomes.
  • Method: Use GTDB to query or submit the supplied input and parse the response.
  • API： dnakit.databases.gtdb_get_species(*, operation=None, species, max_genomes=None, verbose=True)
  • Input: Provide species.
  • Output: Returns a mapping with species_name, total_genomes, genomes_shown, genomes and related fields.
  • Example code:
import dnakit

result = dnakit.databases.gtdb_get_species(
    operation='get_species',
    species='Escherichia coli',
    max_genomes=5,
    verbose=False,
)
print(result)
  • Example output: The response has the following shape; records depend on the input and source.

Response-shape excerpt; <…> denotes type placeholders, not a captured query result.

{
  "species_name": "<string>",
  "total_genomes": "<integer>",
  "genomes_shown": "<integer>",
  "genomes": [
    {
      "accession": "<string>",
      "ncbi_org_name": "<string>",
      "ncbi_tax": "<string>",
      "gtdb_species_rep": "<boolean>",
      "ncbi_type_material": "<string>"
    }
  ]
}

Full parameters and usage notes

12) Retrieve GTDB taxonomy and release history

  • Purpose: Retrieve GTDB taxonomy and release history.
  • Method: Use GTDB to query or submit the supplied input and parse the response.
  • API： dnakit.databases.gtdb_get_taxon_info(*, operation=None, taxon, verbose=True)
  • Input: Provide taxon.
  • Output: Returns a mapping with taxon, rank, n_genomes, higher_ranks and related fields.
  • Example code:
import dnakit

result = dnakit.databases.gtdb_get_taxon_info(
    operation='get_taxon_info',
    taxon='f__Lachnospiraceae',
    verbose=False,
)
print(result)
  • Example output: The response has the following shape; records depend on the input and source.

Response-shape excerpt; <…> denotes type placeholders, not a captured query result.

{
  "taxon": "<string>",
  "rank": "<string>",
  "n_genomes": "<integer>",
  "higher_ranks": [
    "<string>"
  ],
  "in_releases": [
    "<string>"
  ],
  "lineage": "<object>"
}

Full parameters and usage notes

13) Search prokaryotic genomes by organism name

  • Purpose: Search prokaryotic genomes by organism name.
  • Method: Use GTDB to query or submit the supplied input and parse the response.
  • API： dnakit.databases.gtdb_search_genomes(*, operation=None, query, page=None, items_per_page=None, verbose=True)
  • Input: Provide query.
  • Output: Returns a mapping with query, match_type, total_results, total_results_scope and related fields.
  • Example code:
import dnakit

result = dnakit.databases.gtdb_search_genomes(
    operation='search_genomes',
    query='Escherichia',
    items_per_page=5,
    verbose=False,
)
print(result)
  • Example output: The response has the following shape; records depend on the input and source.

Response-shape excerpt; <…> denotes type placeholders, not a captured query result.

{
  "query": "<string>",
  "match_type": "<string>",
  "total_results": "<integer>",
  "total_results_scope": "<string>",
  "note": "<string>",
  "page": "<integer>",
  "results": [
    {
      "gid": "<string>",
      "accession": "<string>",
      "ncbiOrgName": "<string>",
      "ncbiTaxonomy": "<string>",
      "gtdbTaxonomy": "<string>",
      "isGtdbSpeciesRep": "<boolean>",
      "isNcbiTypeMaterial": "<boolean>"
    }
  ],
  "count": "<integer>"
}

Full parameters and usage notes

14) Search prokaryotic taxa by partial name

  • Purpose: Search prokaryotic taxa by partial name.
  • Method: Use GTDB to query or submit the supplied input and parse the response.
  • API： dnakit.databases.gtdb_search_taxon(*, operation=None, query, limit=None, verbose=True)
  • Input: Provide query.
  • Output: Returns a mapping with query, matches, count and related fields.
  • Example code:
import dnakit

result = dnakit.databases.gtdb_search_taxon(
    operation='search_taxon',
    query='Lachnospiraceae',
    verbose=False,
)
print(result)
  • Example output: The response has the following shape; records depend on the input and source.

Response-shape excerpt; <…> denotes type placeholders, not a captured query result.

{
  "query": "<string>",
  "matches": [
    "<string>"
  ],
  "count": "<integer>"
}

Full parameters and usage notes

15) Retrieve mouse gene details by MGI identifier

  • Purpose: Retrieve mouse gene details by MGI identifier.
  • Method: Use AllianceGenome to query or submit the supplied input and parse the response.
  • API： dnakit.databases.mgi_get_gene(*, gene_id, verbose=True)
  • Input: Provide gene_id.
  • Output: Returns a mapping with id, symbol, name, species and related fields.
  • Example code:
import dnakit

result = dnakit.databases.mgi_get_gene(
    gene_id='MGI:98834',
    verbose=False,
)
print(result)
  • Example output: The response has the following shape; records depend on the input and source.

Response-shape excerpt; <…> denotes type placeholders, not a captured query result.

{
  "id": "<string>",
  "symbol": "<string>",
  "name": "<string>",
  "species": {
    "name": "<string>",
    "short_name": "<string>",
    "taxon_id": "<string>",
    "data_provider": "<string>"
  },
  "gene_synopsis": "<string>",
  "automated_gene_synopsis": "<string>",
  "synonyms": [
    "<string>"
  ],
  "so_term": "<string>"
}

Full parameters and usage notes

16) Retrieve mouse gene mutant phenotype annotations

  • Purpose: Retrieve mouse gene mutant phenotype annotations.
  • Method: Use AllianceGenome to query or submit the supplied input and parse the response.
  • API： dnakit.databases.mgi_get_phenotypes(*, gene_id, limit=None, page=None, verbose=True)
  • Input: Provide gene_id.
  • Output: Returns a list of records; each record includes gene_symbol, gene_id, phenotype_statement and related fields.
  • Example code:
import dnakit

result = dnakit.databases.mgi_get_phenotypes(
    gene_id='MGI:98834',
    limit=10,
    verbose=False,
)
print(result)
  • Example output: The response has the following shape; records depend on the input and source.

Response-shape excerpt; <…> denotes type placeholders, not a captured query result.

[
  {
    "gene_symbol": "<string>",
    "gene_id": "<string>",
    "phenotype_statement": "<string>"
  }
]

Full parameters and usage notes

17) Search mouse genes by name or keyword

  • Purpose: Search mouse genes by name or keyword.
  • Method: Use AllianceGenome to query or submit the supplied input and parse the response.
  • API： dnakit.databases.mgi_search_genes(*, query, limit=None, verbose=True)
  • Input: Provide query.
  • Output: Returns a list of records; each record includes symbol, name, gene_id, category and related fields.
  • Example code:
import dnakit

result = dnakit.databases.mgi_search_genes(
    query='Trp53',
    limit=5,
    verbose=False,
)
print(result)
  • Example output: The response has the following shape; records depend on the input and source.

Response-shape excerpt; <…> denotes type placeholders, not a captured query result.

[
  {
    "symbol": "<string>",
    "name": "<string>",
    "gene_id": "<string>",
    "category": "<string>"
  }
]

Full parameters and usage notes

18) Retrieve microbial genome quality and taxonomy

  • Purpose: Retrieve microbial genome quality and taxonomy.
  • Method: Use MGnifyExpanded to query or submit the supplied input and parse the response.
  • API： dnakit.databases.mgnify_get_genome(*, genome_id, verbose=True)
  • Input: Provide genome_id.
  • Output: Returns a mapping with genome_id, type, taxonomy, completeness and related fields.
  • Example code:
import dnakit

result = dnakit.databases.mgnify_get_genome(
    genome_id='MGYG000000001',
    verbose=False,
)
print(result)
  • Example output: The response has the following shape; records depend on the input and source.

Response-shape excerpt; <…> denotes type placeholders, not a captured query result.

{
  "genome_id": "<string>",
  "type": "<string>",
  "taxonomy": "<string>",
  "completeness": "<number>",
  "contamination": "<number>",
  "length": "<integer>",
  "num_proteins": "<integer>",
  "gc_content": "<number>"
}

Full parameters and usage notes

19) Retrieve GO annotations from a metagenomics analysis

  • Purpose: Retrieve GO annotations from a metagenomics analysis.
  • Method: Use MGnifyExpanded to query or submit the supplied input and parse the response.
  • API： dnakit.databases.mgnify_get_go_terms(*, analysis_id, page_size=None, verbose=True)
  • Input: Provide analysis_id.
  • Output: Returns a list of records; each record includes go_id, description, count, category and related fields.
  • Example code:
import dnakit

result = dnakit.databases.mgnify_get_go_terms(
    analysis_id='MGYA00585482',
    page_size=10,
    verbose=False,
)
print(result)
  • Example output: The response has the following shape; records depend on the input and source.

Response-shape excerpt; <…> denotes type placeholders, not a captured query result.

[
  {
    "go_id": "<string>",
    "description": "<string>",
    "count": "<integer>",
    "category": "<string>"
  }
]

Full parameters and usage notes

20) Retrieve metagenomic protein domain annotations

  • Purpose: Retrieve metagenomic protein domain annotations.
  • Method: Use MGnifyExpanded to query or submit the supplied input and parse the response.
  • API： dnakit.databases.mgnify_get_interpro(*, analysis_id, page_size=None, verbose=True)
  • Input: Provide analysis_id.
  • Output: Returns a list of records; each record includes interpro_id, description, count and related fields.
  • Example code:
import dnakit

result = dnakit.databases.mgnify_get_interpro(
    analysis_id='MGYA00585482',
    page_size=10,
    verbose=False,
)
print(result)
  • Example output: The response has the following shape; records depend on the input and source.

Response-shape excerpt; <…> denotes type placeholders, not a captured query result.

[
  {
    "interpro_id": "<string>",
    "description": "<string>",
    "count": "<integer>"
  }
]

Full parameters and usage notes

21) Retrieve MGnify metagenomics study details

  • Purpose: Retrieve MGnify metagenomics study details.
  • Method: Use MGnifyExpanded to query or submit the supplied input and parse the response.
  • API： dnakit.databases.mgnify_get_study_detail(*, study_accession, verbose=True)
  • Input: Provide study_accession.
  • Output: Returns a mapping with study_id, study_name, study_abstract, bioproject and related fields.
  • Example code:
import dnakit

result = dnakit.databases.mgnify_get_study_detail(
    study_accession='MGYS00002008',
    verbose=False,
)
print(result)
  • Example output: The response has the following shape; records depend on the input and source.

Response-shape excerpt; <…> denotes type placeholders, not a captured query result.

{
  "study_id": "<string>",
  "study_name": "<string>",
  "study_abstract": "<string>",
  "bioproject": "<string>",
  "centre_name": "<string>",
  "biomes": [
    "<string>"
  ],
  "is_public": "<boolean>",
  "samples_count": "<integer>"
}

Full parameters and usage notes

22) Retrieve metagenomic taxonomic composition and abundance

  • Purpose: Retrieve metagenomic taxonomic composition and abundance.
  • Method: Use MGnifyExpanded to query or submit the supplied input and parse the response.
  • API： dnakit.databases.mgnify_get_taxonomy(*, analysis_id, rna_type=None, page_size=None, verbose=True)
  • Input: Provide analysis_id.
  • Output: Returns a list of records; each record includes organism_id, name, rank, domain and related fields.
  • Example code:
import dnakit

result = dnakit.databases.mgnify_get_taxonomy(
    analysis_id='MGYA00585482',
    page_size=10,
    verbose=False,
)
print(result)
  • Example output: The response has the following shape; records depend on the input and source.

Response-shape excerpt; <…> denotes type placeholders, not a captured query result.

[
  {
    "organism_id": "<string>",
    "name": "<string>",
    "rank": "<string>",
    "domain": "<string>",
    "count": "<integer>",
    "lineage": "<string>"
  }
]

Full parameters and usage notes

23) List analyses belonging to a metagenomics study

  • Purpose: List analyses belonging to a metagenomics study.
  • Method: Use MGnifyAnalyses to query or submit the supplied input and parse the response.
  • API： dnakit.databases.mgnify_list_analyses(*, study_accession, size=None, verbose=True)
  • Input: Provide study_accession.
  • Output: data contains MGnify analysis records for the study and the service's pagination information.
  • Example code:
import dnakit

result = dnakit.databases.mgnify_list_analyses(
    study_accession='MGYS00000596',
    size=3,
    verbose=False,
)
print(result)
  • Example output: data contains MGnify analysis records for the study and the service's pagination information.

Full parameters and usage notes

24) Browse the metagenomics biome hierarchy

  • Purpose: Browse the metagenomics biome hierarchy.
  • Method: Use MGnifyExpanded to query or submit the supplied input and parse the response.
  • API： dnakit.databases.mgnify_list_biomes(*, depth=None, page=None, page_size=None, verbose=True)
  • Input: Choose filters as shown in the example; omitted options use the operation defaults.
  • Output: Returns a list of records; each record includes biome_id, biome_name, samples_count and related fields.
  • Example code:
import dnakit

result = dnakit.databases.mgnify_list_biomes(
    page_size=10,
    verbose=False,
)
print(result)
  • Example output: The response has the following shape; records depend on the input and source.

Response-shape excerpt; <…> denotes type placeholders, not a captured query result.

[
  {
    "biome_id": "<string>",
    "biome_name": "<string>",
    "samples_count": "<integer>"
  }
]

Full parameters and usage notes

25) Search metagenome-assembled and isolate genomes

  • Purpose: Search metagenome-assembled and isolate genomes.
  • Method: Use MGnifyExpanded to query or submit the supplied input and parse the response.
  • API： dnakit.databases.mgnify_search_genomes(*, taxonomy=None, page=None, page_size=None, verbose=True)
  • Input: Choose filters as shown in the example; omitted options use the operation defaults.
  • Output: Returns a list of records; each record includes genome_id, type, taxonomy, completeness and related fields.
  • Example code:
import dnakit

result = dnakit.databases.mgnify_search_genomes(
    page=1,
    page_size=5,
    verbose=False,
)
print(result)
  • Example output: The response has the following shape; records depend on the input and source.

Response-shape excerpt; <…> denotes type placeholders, not a captured query result.

[
  {
    "genome_id": "<string>",
    "type": "<string>",
    "taxonomy": "<string>",
    "completeness": "<number>",
    "contamination": "<number>",
    "length": "<integer>",
    "num_proteins": "<integer>"
  }
]

Full parameters and usage notes

26) Search metagenomics studies by biome and keyword

  • Purpose: Search metagenomics studies by biome and keyword.
  • Method: Use MGnifyStudies to query or submit the supplied input and parse the response.
  • API： dnakit.databases.mgnify_search_studies(*, biome=None, search=None, size=None, verbose=True)
  • Input: Choose filters as shown in the example; omitted options use the operation defaults.
  • Output: data contains MGnify study search results and the service's pagination information.
  • Example code:
import dnakit

result = dnakit.databases.mgnify_search_studies(
    search='human gut',
    size=3,
    verbose=False,
)
print(result)
  • Example output: data contains MGnify study search results and the service's pagination information.

Full parameters and usage notes

27) Search global plant names and taxonomy

  • Purpose: Search global plant names and taxonomy.
  • Method: Use Base to query or submit the supplied input and parse the response.
  • API： dnakit.databases.powo_search_plants(*, q, f=None, perPage=None, cursor=None, verbose=True)
  • Input: Provide q.
  • Output: Returns a mapping with totalResults, page, totalPages, perPage and related fields.
  • Example code:
import dnakit

result = dnakit.databases.powo_search_plants(
    q='Rosa canina',
    f='species_f:true',
    verbose=False,
)
print(result)
  • Example output: The response has the following shape; records depend on the input and source.

Response-shape excerpt; <…> denotes type placeholders, not a captured query result.

{
  "totalResults": "<integer>",
  "page": "<integer>",
  "totalPages": "<integer>",
  "perPage": "<integer>",
  "cursor": "<string>",
  "results": [
    {
      "accepted": "<boolean>",
      "author": "<string>",
      "kingdom": "<string>",
      "family": "<string>",
      "name": "<string>",
      "rank": "<string>",
      "snippet": "<string>",
      "url": "<string>"
    }
  ]
}

Full parameters and usage notes

28) Retrieve rat gene disease, phenotype and functional annotations

  • Purpose: Retrieve rat gene disease, phenotype and functional annotations.
  • Method: Use RGD to query or submit the supplied input and parse the response.
  • API： dnakit.databases.rgd_get_annotations(*, rgd_id, aspect=None, verbose=True)
  • Input: Provide rgd_id.
  • Output: Returns a list for “Retrieve rat gene disease, phenotype and functional annotations”; the item shape is shown below.
  • Example code:
import dnakit

result = dnakit.databases.rgd_get_annotations(
    rgd_id='2218',
    aspect='D',
    verbose=False,
)
print(result)
  • Example output: The response has the following shape; records depend on the input and source.

Response-shape excerpt; <…> denotes type placeholders, not a captured query result.

[
  "<value>"
]

Full parameters and usage notes

29) Retrieve rat gene details by RGD identifier

  • Purpose: Retrieve rat gene details by RGD identifier.
  • Method: Use RGD to query or submit the supplied input and parse the response.
  • API： dnakit.databases.rgd_get_gene(*, rgd_id, verbose=True)
  • Input: Provide rgd_id.
  • Output: Returns rat gene names, functional description, gene type and Ensembl cross-references.
  • Example code:
import dnakit

result = dnakit.databases.rgd_get_gene(
    rgd_id='2218',
    verbose=False,
)
print(result)
  • Example output: Returns rat gene names, functional description, gene type and Ensembl cross-references.

Full parameters and usage notes

30) Retrieve cross-species orthologs of a rat gene

  • Purpose: Retrieve cross-species orthologs of a rat gene.
  • Method: Use RGD to query or submit the supplied input and parse the response.
  • API： dnakit.databases.rgd_get_orthologs(*, rgd_id, verbose=True)
  • Input: Provide rgd_id.
  • Output: Returns a list for “Retrieve cross-species orthologs of a rat gene”; the item shape is shown below.
  • Example code:
import dnakit

result = dnakit.databases.rgd_get_orthologs(
    rgd_id='2218',
    verbose=False,
)
print(result)
  • Example output: The response has the following shape; records depend on the input and source.

Response-shape excerpt; <…> denotes type placeholders, not a captured query result.

[
  "<value>"
]

Full parameters and usage notes

31) Retrieve rat QTLs overlapping a genomic interval

  • Purpose: Retrieve rat QTLs overlapping a genomic interval.
  • Method: Use RGD to query or submit the supplied input and parse the response.
  • API： dnakit.databases.rgd_get_qtls_in_region(*, chromosome, start, stop, map_key, verbose=True)
  • Input: Provide chromosome, start, stop, map_key.
  • Output: Returns a list of records; each record includes rgd_id, symbol, name, chromosome and related fields.
  • Example code:
import dnakit

result = dnakit.databases.rgd_get_qtls_in_region(
    chromosome='10',
    start=1,
    stop=50000000,
    map_key=360,
    verbose=False,
)
print(result)
  • Example output: The response has the following shape; records depend on the input and source.

Response-shape excerpt; <…> denotes type placeholders, not a captured query result.

[
  {
    "rgd_id": "<integer>",
    "symbol": "<string>",
    "name": "<string>",
    "chromosome": "<string>",
    "lod": "<number>",
    "p_value": "<number>",
    "variance": "<number>",
    "inheritance_type": "<string>"
  }
]

Full parameters and usage notes

32) Retrieve rat strain details by strain symbol

  • Purpose: Retrieve rat strain details by strain symbol.
  • Method: Use RGDStrain to query or submit the supplied input and parse the response.
  • API： dnakit.databases.rgd_get_strain(*, symbol, verbose=True)
  • Input: Provide symbol.
  • Output: Returns a mapping with rgd_id, symbol, name, full_strain_name and related fields.
  • Example code:
import dnakit

result = dnakit.databases.rgd_get_strain(
    symbol='SHR',
    verbose=False,
)
print(result)
  • Example output: The response has the following shape; records depend on the input and source.

Response-shape excerpt; <…> denotes type placeholders, not a captured query result.

{
  "rgd_id": "<integer>",
  "symbol": "<string>",
  "name": "<string>",
  "full_strain_name": "<string>",
  "substrain": "<string>",
  "strain_type": "<string>",
  "genetics": "<string>",
  "origin": "<string>"
}

Full parameters and usage notes

33) Retrieve rat strain disease and phenotype annotations

  • Purpose: Retrieve rat strain disease and phenotype annotations.
  • Method: Use RGDStrain to query or submit the supplied input and parse the response.
  • API： dnakit.databases.rgd_get_strain_annotations(*, symbol, category=None, verbose=True)
  • Input: Provide symbol.
  • Output: Returns a list of records; each record includes term, term_acc, category, aspect and related fields.
  • Example code:
import dnakit

result = dnakit.databases.rgd_get_strain_annotations(
    symbol='SHR',
    category='disease',
    verbose=False,
)
print(result)
  • Example output: The response has the following shape; records depend on the input and source.

Response-shape excerpt; <…> denotes type placeholders, not a captured query result.

[
  {
    "term": "<string>",
    "term_acc": "<string>",
    "category": "<string>",
    "aspect": "<string>",
    "qualifier": "<string>",
    "evidence": "<string>",
    "data_source": "<string>",
    "ref_rgd_id": "<integer>"
  }
]

Full parameters and usage notes

34) Search RGD genes by name or keyword

  • Purpose: Search RGD genes by name or keyword.
  • Method: Use RGD to query or submit the supplied input and parse the response.
  • API： dnakit.databases.rgd_search_genes(*, query, species=None, verbose=True)
  • Input: Provide query.
  • Output: Returns a list for “Search RGD genes by name or keyword”; the item shape is shown below.
  • Example code:
import dnakit

result = dnakit.databases.rgd_search_genes(
    query='Brca1',
    verbose=False,
)
print(result)
  • Example output: The response has the following shape; records depend on the input and source.

Response-shape excerpt; <…> denotes type placeholders, not a captured query result.

[
  "<value>"
]

Full parameters and usage notes

35) Search rat strains by keyword and type

  • Purpose: Search rat strains by keyword and type.
  • Method: Use RGDStrain to query or submit the supplied input and parse the response.
  • API： dnakit.databases.rgd_search_strains(*, query=None, strain_type=None, limit=None, verbose=True)
  • Input: Choose filters as shown in the example; omitted options use the operation defaults.
  • Output: Returns a list of records; each record includes rgd_id, symbol, name, full_strain_name and related fields.
  • Example code:
import dnakit

result = dnakit.databases.rgd_search_strains(
    query='hypertensive',
    strain_type='inbred',
    verbose=False,
)
print(result)
  • Example output: The response has the following shape; records depend on the input and source.

Response-shape excerpt; <…> denotes type placeholders, not a captured query result.

[
  {
    "rgd_id": "<integer>",
    "symbol": "<string>",
    "name": "<string>",
    "full_strain_name": "<string>",
    "substrain": "<string>",
    "strain_type": "<string>",
    "genetics": "<string>",
    "origin": "<string>"
  }
]

Full parameters and usage notes

36) Retrieve yeast gene and locus overviews

  • Purpose: Retrieve yeast gene and locus overviews.
  • Method: Use SGD to query or submit the supplied input and parse the response.
  • API： dnakit.databases.sgd_get_gene(*, sgd_id, verbose=True)
  • Input: Provide sgd_id.
  • Output: Returns a mapping with sgd_id, display_name, gene_name, systematic_name and related fields.
  • Example code:
import dnakit

result = dnakit.databases.sgd_get_gene(
    sgd_id='S000000259',
    verbose=False,
)
print(result)
  • Example output: The response has the following shape; records depend on the input and source.

Response-shape excerpt; <…> denotes type placeholders, not a captured query result.

{
  "sgd_id": "<string>",
  "display_name": "<string>",
  "gene_name": "<string>",
  "systematic_name": "<string>",
  "locus_type": "<string>",
  "description": "<string>",
  "uniprot_id": "<string>",
  "aliases": [
    "<string>"
  ]
}

Full parameters and usage notes

37) Retrieve yeast gene GO annotations and evidence

  • Purpose: Retrieve yeast gene GO annotations and evidence.
  • Method: Use SGD to query or submit the supplied input and parse the response.
  • API： dnakit.databases.sgd_get_go_annotations(*, sgd_id, verbose=True)
  • Input: Provide sgd_id.
  • Output: Returns a list of records; each record includes go_id, go_term, go_aspect, evidence_code and related fields.
  • Example code:
import dnakit

result = dnakit.databases.sgd_get_go_annotations(
    sgd_id='S000003219',
    verbose=False,
)
print(result)
  • Example output: The response has the following shape; records depend on the input and source.

Response-shape excerpt; <…> denotes type placeholders, not a captured query result.

[
  {
    "go_id": "<string>",
    "go_term": "<string>",
    "go_aspect": "<string>",
    "evidence_code": "<string>",
    "qualifier": "<string>",
    "annotation_type": "<string>",
    "reference": "<string>"
  }
]

Full parameters and usage notes

38) Retrieve yeast genetic and physical interactions

  • Purpose: Retrieve yeast genetic and physical interactions.
  • Method: Use SGD to query or submit the supplied input and parse the response.
  • API： dnakit.databases.sgd_get_interactions(*, sgd_id, verbose=True)
  • Input: Provide sgd_id.
  • Output: Returns a list of records; each record includes interaction_type, experiment_type, bait_gene, hit_gene and related fields.
  • Example code:
import dnakit

result = dnakit.databases.sgd_get_interactions(
    sgd_id='S000003219',
    verbose=False,
)
print(result)
  • Example output: The response has the following shape; records depend on the input and source.

Response-shape excerpt; <…> denotes type placeholders, not a captured query result.

[
  {
    "interaction_type": "<string>",
    "experiment_type": "<string>",
    "bait_gene": "<string>",
    "hit_gene": "<string>",
    "annotation_type": "<string>",
    "reference": "<string>"
  }
]

Full parameters and usage notes

39) Retrieve yeast mutant phenotypes and experimental conditions

  • Purpose: Retrieve yeast mutant phenotypes and experimental conditions.
  • Method: Use SGD to query or submit the supplied input and parse the response.
  • API： dnakit.databases.sgd_get_phenotypes(*, sgd_id, verbose=True)
  • Input: Provide sgd_id.
  • Output: Returns a list of records; each record includes phenotype, mutant_type, experiment_type, strain_name and related fields.
  • Example code:
import dnakit

result = dnakit.databases.sgd_get_phenotypes(
    sgd_id='S000003219',
    verbose=False,
)
print(result)
  • Example output: The response has the following shape; records depend on the input and source.

Response-shape excerpt; <…> denotes type placeholders, not a captured query result.

[
  {
    "phenotype": "<string>",
    "mutant_type": "<string>",
    "experiment_type": "<string>",
    "strain_name": "<string>",
    "allele": "<string>",
    "chemical": "<string>",
    "reference": "<string>"
  }
]

Full parameters and usage notes

  • Purpose: Search the yeast database across data types.
  • Method: Use SGD to query or submit the supplied input and parse the response.
  • API： dnakit.databases.sgd_search(*, query, category=None, limit=None, offset=None, verbose=True)
  • Input: Provide query.
  • Output: Returns a list of records; each record includes name, category, description, href and related fields.
  • Example code:
import dnakit

result = dnakit.databases.sgd_search(
    query='GAL4',
    category='locus',
    limit=5,
    verbose=False,
)
print(result)
  • Example output: The response has the following shape; records depend on the input and source.

Response-shape excerpt; <…> denotes type placeholders, not a captured query result.

[
  {
    "name": "<string>",
    "category": "<string>",
    "description": "<string>",
    "href": "<string>",
    "aliases": [
      "<value>"
    ]
  }
]

Full parameters and usage notes

41) Retrieve plant morphology, growth and reproduction characteristics

  • Purpose: Retrieve plant morphology, growth and reproduction characteristics.
  • Method: Use USDAPlantsCharacteristics to query or submit the supplied input and parse the response.
  • API： dnakit.databases.usda_plants_get_characteristics(*, symbol, verbose=True)
  • Input: Provide symbol.
  • Output: Returns a list for “Retrieve plant morphology, growth and reproduction characteristics”; the item shape is shown below.
  • Example code:
import dnakit

result = dnakit.databases.usda_plants_get_characteristics(
    symbol='ABBA',
    verbose=False,
)
print(result)
  • Example output: The response has the following shape; records depend on the input and source.

Response-shape excerpt; <…> denotes type placeholders, not a captured query result.

[
  "<object>"
]

Full parameters and usage notes

42) Retrieve plant names, taxonomy and growth habits

  • Purpose: Retrieve plant names, taxonomy and growth habits.
  • Method: Use USDAPlantsProfile to query or submit the supplied input and parse the response.
  • API： dnakit.databases.usda_plants_get_profile(*, symbol, verbose=True)
  • Input: Provide symbol.
  • Output: Returns scientific/common names, taxonomy, growth habits and regional native status; fine-grained distributions are not always available.
  • Example code:
import dnakit

result = dnakit.databases.usda_plants_get_profile(
    symbol='ABBA',
    verbose=False,
)
print(result)
  • Example output: Returns scientific/common names, taxonomy, growth habits and regional native status; fine-grained distributions are not always available.

Full parameters and usage notes

43) Retrieve nematode tissue and developmental expression

  • Purpose: Retrieve nematode tissue and developmental expression.
  • Method: Use WormBase to query or submit the supplied input and parse the response.
  • API： dnakit.databases.worm_base_get_expression(*, gene_id, verbose=True)
  • Input: Provide gene_id.
  • Output: Returns a mapping with wormbase_id, gene_name, expressed_in_count, expressed_in and related fields.
  • Example code:
import dnakit

result = dnakit.databases.worm_base_get_expression(
    gene_id='WBGene00006763',
    verbose=False,
)
print(result)
  • Example output: The response has the following shape; records depend on the input and source.

Response-shape excerpt; <…> denotes type placeholders, not a captured query result.

{
  "wormbase_id": "<string>",
  "gene_name": "<string>",
  "expressed_in_count": "<integer>",
  "expressed_in": [
    {
      "term_id": "<string>",
      "term_name": "<string>"
    }
  ],
  "expressed_during": [
    {
      "term_id": "<string>",
      "term_name": "<string>"
    }
  ],
  "subcellular_localization": [
    {
      "term_id": "<string>",
      "term_name": "<string>"
    }
  ],
  "expression_clusters_count": "<integer>",
  "expression_clusters": [
    {
      "cluster_id": "<string>",
      "cluster_label": "<string>"
    }
  ]
}

Full parameters and usage notes

44) Retrieve C. elegans gene details

  • Purpose: Retrieve C. elegans gene details.
  • Method: Use WormBase to query or submit the supplied input and parse the response.
  • API： dnakit.databases.worm_base_get_gene(*, gene_id, verbose=True)
  • Input: Provide gene_id.
  • Output: Returns a mapping with wormbase_id, gene_name, sequence_name, species and related fields.
  • Example code:
import dnakit

result = dnakit.databases.worm_base_get_gene(
    gene_id='WBGene00006763',
    verbose=False,
)
print(result)
  • Example output: The response has the following shape; records depend on the input and source.

Response-shape excerpt; <…> denotes type placeholders, not a captured query result.

{
  "wormbase_id": "<string>",
  "gene_name": "<string>",
  "sequence_name": "<string>",
  "species": "<string>",
  "description": "<string>",
  "gene_type": "<string>",
  "status": "<string>"
}

Full parameters and usage notes

45) Retrieve experimentally observed nematode gene phenotypes

  • Purpose: Retrieve experimentally observed nematode gene phenotypes.
  • Method: Use WormBase to query or submit the supplied input and parse the response.
  • API： dnakit.databases.worm_base_get_phenotypes(*, gene_id, verbose=True)
  • Input: Provide gene_id.
  • Output: Returns a mapping with wormbase_id, gene_name, phenotype_count, phenotypes and related fields.
  • Example code:
import dnakit

result = dnakit.databases.worm_base_get_phenotypes(
    gene_id='WBGene00006763',
    verbose=False,
)
print(result)
  • Example output: The response has the following shape; records depend on the input and source.

Response-shape excerpt; <…> denotes type placeholders, not a captured query result.

{
  "wormbase_id": "<string>",
  "gene_name": "<string>",
  "phenotype_count": "<integer>",
  "phenotypes": [
    {
      "phenotype_id": "<string>",
      "phenotype_name": "<string>",
      "evidence_type": "<string>"
    }
  ],
  "not_observed_count": "<integer>",
  "phenotypes_not_observed": [
    {
      "phenotype_id": "<string>",
      "phenotype_name": "<string>"
    }
  ]
}

Full parameters and usage notes

46) Retrieve Xenopus gene details and cross-references

  • Purpose: Retrieve Xenopus gene details and cross-references.
  • Method: Use Xenbase to query or submit the supplied input and parse the response.
  • API： dnakit.databases.xenbase_get_gene(*, gene_id, verbose=True)
  • Input: Provide gene_id.
  • Output: Returns a mapping with gene_id, symbol, name, species and related fields.
  • Example code:
import dnakit

result = dnakit.databases.xenbase_get_gene(
    gene_id='XB-GENE-484286',
    verbose=False,
)
print(result)
  • Example output: The response has the following shape; records depend on the input and source.

Response-shape excerpt; <…> denotes type placeholders, not a captured query result.

{
  "gene_id": "<string>",
  "symbol": "<string>",
  "name": "<string>",
  "species": {
    "name": "<string>",
    "short_name": "<string>",
    "taxon_id": "<string>",
    "data_provider": "<string>"
  },
  "synonyms": [
    "<string>"
  ],
  "gene_synopsis": "<string>",
  "automated_gene_synopsis": "<string>",
  "so_term": "<string>"
}

Full parameters and usage notes

47) Search genes in Xenopus tropicalis and Xenopus laevis

  • Purpose: Search genes in Xenopus tropicalis and Xenopus laevis.
  • Method: Use Xenbase to query or submit the supplied input and parse the response.
  • API： dnakit.databases.xenbase_search_genes(*, query, species=None, limit=None, verbose=True)
  • Input: Provide query.
  • Output: Returns a list of records; each record includes gene_id, symbol, name, species and related fields.
  • Example code:
import dnakit

result = dnakit.databases.xenbase_search_genes(
    query='tp53',
    verbose=False,
)
print(result)
  • Example output: The response has the following shape; records depend on the input and source.

Response-shape excerpt; <…> denotes type placeholders, not a captured query result.

[
  {
    "gene_id": "<string>",
    "symbol": "<string>",
    "name": "<string>",
    "species": "<string>",
    "synonyms": [
      "<string>"
    ]
  }
]

Full parameters and usage notes

48) Retrieve zebrafish gene details

  • Purpose: Retrieve zebrafish gene details.
  • Method: Use AllianceGenome to query or submit the supplied input and parse the response.
  • API： dnakit.databases.zfin_get_gene(*, gene_id, verbose=True)
  • Input: Provide gene_id.
  • Output: Returns a mapping with id, symbol, name, species and related fields.
  • Example code:
import dnakit

result = dnakit.databases.zfin_get_gene(
    gene_id='ZFIN:ZDB-GENE-990415-8',
    verbose=False,
)
print(result)
  • Example output: The response has the following shape; records depend on the input and source.

Response-shape excerpt; <…> denotes type placeholders, not a captured query result.

{
  "id": "<string>",
  "symbol": "<string>",
  "name": "<string>",
  "species": {
    "name": "<string>",
    "short_name": "<string>",
    "taxon_id": "<string>",
    "data_provider": "<string>"
  },
  "gene_synopsis": "<string>",
  "automated_gene_synopsis": "<string>",
  "synonyms": [
    "<string>"
  ],
  "so_term": "<string>"
}

Full parameters and usage notes

49) Retrieve zebrafish developmental and anatomical expression

  • Purpose: Retrieve zebrafish developmental and anatomical expression.
  • Method: Use AllianceGenome to query or submit the supplied input and parse the response.
  • API： dnakit.databases.zfin_get_gene_expression(*, gene_id, limit=None, verbose=True)
  • Input: Provide gene_id.
  • Output: Returns a mapping with total_annotations, returned, annotations and related fields.
  • Example code:
import dnakit

result = dnakit.databases.zfin_get_gene_expression(
    gene_id='ZFIN:ZDB-GENE-980526-166',
    limit=5,
    verbose=False,
)
print(result)
  • Example output: The response has the following shape; records depend on the input and source.

Response-shape excerpt; <…> denotes type placeholders, not a captured query result.

{
  "total_annotations": "<integer>",
  "returned": "<integer>",
  "annotations": [
    {
      "stage": "<string>",
      "location": "<string>",
      "data_provider": "<string>",
      "reference": "<string>"
    }
  ]
}

Full parameters and usage notes

50) Retrieve zebrafish gene mutant phenotypes

  • Purpose: Retrieve zebrafish gene mutant phenotypes.
  • Method: Use AllianceGenome to query or submit the supplied input and parse the response.
  • API： dnakit.databases.zfin_get_gene_phenotypes(*, gene_id, limit=None, page=None, verbose=True)
  • Input: Provide gene_id.
  • Output: Returns a list of records; each record includes gene_symbol, gene_id, phenotype_statement and related fields.
  • Example code:
import dnakit

result = dnakit.databases.zfin_get_gene_phenotypes(
    gene_id='ZFIN:ZDB-GENE-990415-8',
    limit=10,
    verbose=False,
)
print(result)
  • Example output: The response has the following shape; records depend on the input and source.

Response-shape excerpt; <…> denotes type placeholders, not a captured query result.

[
  {
    "gene_symbol": "<string>",
    "gene_id": "<string>",
    "phenotype_statement": "<string>"
  }
]

Full parameters and usage notes