bkbit.models.anatomical_structure module

class bkbit.models.anatomical_structure.ANATOMICALDIRECTION(value)[source]

Bases: str, Enum

A controlled vocabulary term defining axis direction in terms of anatomical direction.

anterior_to_posterior = 'anterior_to_posterior'

inferior_to_superior = 'inferior_to_superior'

left_to_right = 'left_to_right'

posterior_to_anterior = 'posterior_to_anterior'

superior_to_inferior = 'superior_to_inferior'

class bkbit.models.anatomical_structure.Activity(*, id: str, iri: str | None = None, category: list[Literal['https://w3id.org/biolink/vocab/Activity', 'biolink:Activity']] = ['biolink:Activity'], type: list[str] | None = None, name: str | None = None, description: str | None = None, has_attribute: list[str] | None = None, deprecated: bool | None = None, provided_by: list[str] | None = None, xref: list[str] | None = None, full_name: str | None = None, synonym: list[str] | None = None)[source]

Bases: ActivityAndBehavior, NamedThing

An activity is something that occurs over a period of time and acts upon or with entities; it may include consuming, processing, transforming, modifying, relocating, using, or generating entities.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

category: list[Literal['https://w3id.org/biolink/vocab/Activity', 'biolink:Activity']]

deprecated: bool | None

description: str | None

full_name: str | None

has_attribute: list[str] | None

id: str

iri: str | None

linkml_meta: ClassVar[LinkMLMeta] = LinkMLMeta(root={'class_uri': 'biolink:Activity', 'definition_uri': 'https://w3id.org/biolink/vocab/Activity', 'exact_mappings': ['prov:Activity', 'NCIT:C43431', 'STY:T052'], 'from_schema': 'https://w3id.org/biolink/bican-biolink-schema', 'mixins': ['activity and behavior'], 'narrow_mappings': ['STY:T056', 'STY:T057', 'STY:T064', 'STY:T066', 'STY:T062', 'STY:T065', 'STY:T058']})

model_config: ClassVar[ConfigDict] = {'arbitrary_types_allowed': True, 'extra': 'forbid', 'strict': False, 'use_enum_values': True, 'validate_assignment': True, 'validate_default': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

name: str | None

provided_by: list[str] | None

synonym: list[str] | None

type: list[str] | None

xref: list[str] | None

class bkbit.models.anatomical_structure.ActivityAndBehavior[source]

Bases: Occurrent

Activity or behavior of any independent integral living, organization or mechanical actor in the world

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

linkml_meta: ClassVar[LinkMLMeta] = LinkMLMeta(root={'class_uri': 'biolink:ActivityAndBehavior', 'definition_uri': 'https://w3id.org/biolink/vocab/ActivityAndBehavior', 'exact_mappings': ['UMLSSG:ACTI'], 'from_schema': 'https://w3id.org/biolink/bican-biolink-schema', 'mixin': True})

model_config: ClassVar[ConfigDict] = {'arbitrary_types_allowed': True, 'extra': 'forbid', 'strict': False, 'use_enum_values': True, 'validate_assignment': True, 'validate_default': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class bkbit.models.anatomical_structure.AnatomicalAnnotationSet(*, id: str, iri: str | None = None, category: list[Literal['https://identifiers.org/brain-bican/vocab/AnatomicalAnnotationSet', 'bican:AnatomicalAnnotationSet']] = ['bican:AnatomicalAnnotationSet'], type: list[str] | None = None, name: str | None = None, description: str | None = None, has_attribute: list[str] | None = None, deprecated: bool | None = None, provided_by: list[str] | None = None, xref: list[str] | None = None, full_name: str | None = None, synonym: list[str] | None = None, version: str, revision_of: str | None = None, parameterizes: str)[source]

Bases: VersionedNamedThing

An anatomical annotation set is a versioned release of a set of anatomical annotations anchored in the same anatomical space that divides the space into distinct segments following some annotation criteria or parcellation scheme. For example, the anatomical annotation set of 3D image based reference atlases (e.g. Allen Mouse CCF) can be expressed as a set of label indices of single multi-valued image annotations or as a set of segmentation masks (ref: ILX:0777108, RRID:SCR_023499)

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

category: list[Literal['https://identifiers.org/brain-bican/vocab/AnatomicalAnnotationSet', 'bican:AnatomicalAnnotationSet']]

deprecated: bool | None

description: str | None

full_name: str | None

has_attribute: list[str] | None

id: str

iri: str | None

linkml_meta: ClassVar[LinkMLMeta] = LinkMLMeta(root={'from_schema': 'https://identifiers.org/brain-bican/anatomical-structure-schema', 'slot_usage': {'revision_of': {'any_of': [{'range': 'AnatomicalAnnotationSet'}, {'range': 'string'}], 'name': 'revision_of'}}})

model_config: ClassVar[ConfigDict] = {'arbitrary_types_allowed': True, 'extra': 'forbid', 'strict': False, 'use_enum_values': True, 'validate_assignment': True, 'validate_default': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

name: str | None

parameterizes: str

provided_by: list[str] | None

revision_of: str | None

synonym: list[str] | None

type: list[str] | None

version: str

xref: list[str] | None

class bkbit.models.anatomical_structure.AnatomicalSpace(*, id: str, iri: str | None = None, category: list[Literal['https://identifiers.org/brain-bican/vocab/AnatomicalSpace', 'bican:AnatomicalSpace']] = ['bican:AnatomicalSpace'], type: list[str] | None = None, name: str | None = None, description: str | None = None, has_attribute: list[str] | None = None, deprecated: bool | None = None, provided_by: list[str] | None = None, xref: list[str] | None = None, full_name: str | None = None, synonym: list[str] | None = None, version: str, revision_of: str | None = None, measures: str)[source]

Bases: VersionedNamedThing

An anatomical space is versioned release of a mathematical space with a defined mapping between the anatomical axes and the mathematical axes. An anatomical space may be defined by a reference image chosen as the biological reference for an anatomical structure of interest derived from a single or multiple specimens (ref: ILX:0777106, RRID:SCR_023499)

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

category: list[Literal['https://identifiers.org/brain-bican/vocab/AnatomicalSpace', 'bican:AnatomicalSpace']]

deprecated: bool | None

description: str | None

full_name: str | None

has_attribute: list[str] | None

id: str

iri: str | None

linkml_meta: ClassVar[LinkMLMeta] = LinkMLMeta(root={'from_schema': 'https://identifiers.org/brain-bican/anatomical-structure-schema', 'slot_usage': {'revision_of': {'any_of': [{'range': 'AnatomicalSpace'}, {'range': 'string'}], 'name': 'revision_of'}}})

measures: str

model_config: ClassVar[ConfigDict] = {'arbitrary_types_allowed': True, 'extra': 'forbid', 'strict': False, 'use_enum_values': True, 'validate_assignment': True, 'validate_default': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

name: str | None

provided_by: list[str] | None

revision_of: str | None

synonym: list[str] | None

type: list[str] | None

version: str

xref: list[str] | None

class bkbit.models.anatomical_structure.Annotation[source]

Bases: ConfiguredBaseModel

Biolink Model root class for entity annotations.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

linkml_meta: ClassVar[LinkMLMeta] = LinkMLMeta(root={'abstract': True, 'class_uri': 'biolink:Annotation', 'definition_uri': 'https://w3id.org/biolink/vocab/Annotation', 'from_schema': 'https://w3id.org/biolink/bican-biolink-schema'})

model_config: ClassVar[ConfigDict] = {'arbitrary_types_allowed': True, 'extra': 'forbid', 'strict': False, 'use_enum_values': True, 'validate_assignment': True, 'validate_default': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class bkbit.models.anatomical_structure.Attribute(*, id: str, iri: str | None = None, category: list[Literal['https://w3id.org/biolink/vocab/Attribute', 'biolink:Attribute']] = ['biolink:Attribute'], type: list[str] | None = None, name: str | None = None, description: str | None = None, has_attribute: list[str] | None = None, deprecated: bool | None = None, provided_by: list[str] | None = None, xref: list[str] | None = None, full_name: str | None = None, synonym: list[str] | None = None, has_attribute_type: str, has_quantitative_value: list[QuantityValue] | None = None, has_qualitative_value: str | None = None)[source]

Bases: NamedThing, OntologyClass

A property or characteristic of an entity. For example, an apple may have properties such as color, shape, age, crispiness. An environmental sample may have attributes such as depth, lat, long, material.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

category: list[Literal['https://w3id.org/biolink/vocab/Attribute', 'biolink:Attribute']]

deprecated: bool | None

description: str | None

full_name: str | None

has_attribute: list[str] | None

has_attribute_type: str

has_qualitative_value: str | None

has_quantitative_value: list[QuantityValue] | None

id: str

iri: str | None

linkml_meta: ClassVar[LinkMLMeta] = LinkMLMeta(root={'class_uri': 'biolink:Attribute', 'definition_uri': 'https://w3id.org/biolink/vocab/Attribute', 'exact_mappings': ['SIO:000614'], 'from_schema': 'https://w3id.org/biolink/bican-biolink-schema', 'id_prefixes': ['EDAM-DATA', 'EDAM-FORMAT', 'EDAM-OPERATION', 'EDAM-TOPIC'], 'in_subset': ['samples'], 'mixins': ['ontology class'], 'slot_usage': {'name': {'description': "The human-readable 'attribute name' can be set to a string which reflects its context of interpretation, e.g. SEPIO evidence/provenance/confidence annotation or it can default to the name associated with the 'has attribute type' slot ontology term.", 'name': 'name'}}})

model_config: ClassVar[ConfigDict] = {'arbitrary_types_allowed': True, 'extra': 'forbid', 'strict': False, 'use_enum_values': True, 'validate_assignment': True, 'validate_default': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

name: str | None

provided_by: list[str] | None

synonym: list[str] | None

type: list[str] | None

xref: list[str] | None

class bkbit.models.anatomical_structure.BiologicalEntity(*, id: str, iri: str | None = None, category: list[Literal['https://w3id.org/biolink/vocab/BiologicalEntity', 'biolink:BiologicalEntity']] = ['biolink:BiologicalEntity'], type: list[str] | None = None, name: str | None = None, description: str | None = None, has_attribute: list[str] | None = None, deprecated: bool | None = None, provided_by: list[str] | None = None, xref: list[str] | None = None, full_name: str | None = None, synonym: list[str] | None = None, in_taxon: list[str] | None = None, in_taxon_label: str | None = None)[source]

Bases: ThingWithTaxon, NamedThing

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

category: list[Literal['https://w3id.org/biolink/vocab/BiologicalEntity', 'biolink:BiologicalEntity']]

deprecated: bool | None

description: str | None

full_name: str | None

has_attribute: list[str] | None

id: str

in_taxon: list[str] | None

in_taxon_label: str | None

iri: str | None

linkml_meta: ClassVar[LinkMLMeta] = LinkMLMeta(root={'abstract': True, 'aliases': ['bioentity'], 'class_uri': 'biolink:BiologicalEntity', 'definition_uri': 'https://w3id.org/biolink/vocab/BiologicalEntity', 'from_schema': 'https://w3id.org/biolink/bican-biolink-schema', 'mixins': ['thing with taxon'], 'narrow_mappings': ['WIKIDATA:Q28845870', 'STY:T050', 'SIO:010046', 'STY:T129']})

model_config: ClassVar[ConfigDict] = {'arbitrary_types_allowed': True, 'extra': 'forbid', 'strict': False, 'use_enum_values': True, 'validate_assignment': True, 'validate_default': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

name: str | None

provided_by: list[str] | None

synonym: list[str] | None

type: list[str] | None

xref: list[str] | None

class bkbit.models.anatomical_structure.Checksum(*, id: str, iri: str | None = None, category: list[Literal['https://identifiers.org/brain-bican/vocab/Checksum', 'bican:Checksum']] = ['bican:Checksum'], type: list[str] | None = None, name: str | None = None, description: str | None = None, has_attribute: list[str] | None = None, deprecated: bool | None = None, checksum_algorithm: DigestType | None = None, value: str | None = None)[source]

Bases: Entity

Checksum values associated with digital entities.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

category: list[Literal['https://identifiers.org/brain-bican/vocab/Checksum', 'bican:Checksum']]

checksum_algorithm: DigestType | None

deprecated: bool | None

description: str | None

has_attribute: list[str] | None

id: str

iri: str | None

linkml_meta: ClassVar[LinkMLMeta] = LinkMLMeta(root={'from_schema': 'https://identifiers.org/brain-bican/bican-core-schema'})

model_config: ClassVar[ConfigDict] = {'arbitrary_types_allowed': True, 'extra': 'forbid', 'strict': False, 'use_enum_values': True, 'validate_assignment': True, 'validate_default': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

name: str | None

type: list[str] | None

value: str | None

class bkbit.models.anatomical_structure.ChemicalEntityOrGeneOrGeneProduct[source]

Bases: ConfiguredBaseModel

A union of chemical entities and children, and gene or gene product. This mixin is helpful to use when searching across chemical entities that must include genes and their children as chemical entities.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

linkml_meta: ClassVar[LinkMLMeta] = LinkMLMeta(root={'class_uri': 'biolink:ChemicalEntityOrGeneOrGeneProduct', 'definition_uri': 'https://w3id.org/biolink/vocab/ChemicalEntityOrGeneOrGeneProduct', 'from_schema': 'https://w3id.org/biolink/bican-biolink-schema', 'mixin': True})

model_config: ClassVar[ConfigDict] = {'arbitrary_types_allowed': True, 'extra': 'forbid', 'strict': False, 'use_enum_values': True, 'validate_assignment': True, 'validate_default': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class bkbit.models.anatomical_structure.ConfiguredBaseModel[source]

Bases: BaseModel

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

model_config: ClassVar[ConfigDict] = {'arbitrary_types_allowed': True, 'extra': 'forbid', 'strict': False, 'use_enum_values': True, 'validate_assignment': True, 'validate_default': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class bkbit.models.anatomical_structure.DISTANCEUNIT(value)[source]

Bases: str, Enum

An enumeration.

meter = 'm'

micrometer = 'um'

millimeter = 'mm'

Bases: InformationContentEntity

an item that refers to a collection of data from a data source.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

category: list[Literal['https://w3id.org/biolink/vocab/Dataset', 'biolink:Dataset']]

creation_date: date | None

deprecated: bool | None

description: str | None

format: str | None

full_name: str | None

has_attribute: list[str] | None

id: str

iri: str | None

license: str | None

linkml_meta: ClassVar[LinkMLMeta] = LinkMLMeta(root={'class_uri': 'biolink:Dataset', 'definition_uri': 'https://w3id.org/biolink/vocab/Dataset', 'exact_mappings': ['IAO:0000100', 'dctypes:Dataset', 'schema:dataset', 'dcid:Dataset'], 'from_schema': 'https://w3id.org/biolink/bican-biolink-schema'})

model_config: ClassVar[ConfigDict] = {'arbitrary_types_allowed': True, 'extra': 'forbid', 'strict': False, 'use_enum_values': True, 'validate_assignment': True, 'validate_default': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

name: str | None

provided_by: list[str] | None

rights: str | None

synonym: list[str] | None

type: list[str] | None

xref: list[str] | None

class bkbit.models.anatomical_structure.DigestType(value)[source]

Bases: str, Enum

An enumeration.

MD5 = 'spdx:checksumAlgorithm_md5'

SHA1 = 'spdx:checksumAlgorithm_sha1'

SHA256 = 'spdx:checksumAlgorithm_sha256'

class bkbit.models.anatomical_structure.Entity(*, id: str, iri: str | None = None, category: list[Literal['https://w3id.org/biolink/vocab/Entity', 'biolink:Entity']] = ['biolink:Entity'], type: list[str] | None = None, name: str | None = None, description: str | None = None, has_attribute: list[str] | None = None, deprecated: bool | None = None)[source]

Bases: ConfiguredBaseModel

Root Biolink Model class for all things and informational relationships, real or imagined.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

category: list[Literal['https://w3id.org/biolink/vocab/Entity', 'biolink:Entity']]

deprecated: bool | None

description: str | None

has_attribute: list[str] | None

id: str

iri: str | None

linkml_meta: ClassVar[LinkMLMeta] = LinkMLMeta(root={'abstract': True, 'class_uri': 'biolink:Entity', 'definition_uri': 'https://w3id.org/biolink/vocab/Entity', 'from_schema': 'https://w3id.org/biolink/bican-biolink-schema'})

model_config: ClassVar[ConfigDict] = {'arbitrary_types_allowed': True, 'extra': 'forbid', 'strict': False, 'use_enum_values': True, 'validate_assignment': True, 'validate_default': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

name: str | None

type: list[str] | None

class bkbit.models.anatomical_structure.Gene(*, id: str, iri: str | None = None, category: list[Literal['https://w3id.org/biolink/vocab/Gene', 'biolink:Gene']] = ['biolink:Gene'], type: list[str] | None = None, name: str | None = None, description: str | None = None, has_attribute: list[str] | None = None, deprecated: bool | None = None, provided_by: list[str] | None = None, xref: list[str] | None = None, full_name: str | None = None, synonym: list[str] | None = None, in_taxon: list[str] | None = None, in_taxon_label: str | None = None, has_biological_sequence: str | None = None, symbol: str | None = None)[source]

Bases: GeneOrGeneProduct, ChemicalEntityOrGeneOrGeneProduct, GenomicEntity, BiologicalEntity, PhysicalEssence, OntologyClass

A region (or regions) that includes all of the sequence elements necessary to encode a functional transcript. A gene locus may include regulatory regions, transcribed regions and/or other functional sequence regions.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

category: list[Literal['https://w3id.org/biolink/vocab/Gene', 'biolink:Gene']]

deprecated: bool | None

description: str | None

full_name: str | None

has_attribute: list[str] | None

has_biological_sequence: str | None

id: str

in_taxon: list[str] | None

in_taxon_label: str | None

iri: str | None

linkml_meta: ClassVar[LinkMLMeta] = LinkMLMeta(root={'broad_mappings': ['NCIT:C45822'], 'class_uri': 'biolink:Gene', 'definition_uri': 'https://w3id.org/biolink/vocab/Gene', 'exact_mappings': ['SO:0000704', 'SIO:010035', 'WIKIDATA:Q7187', 'dcid:Gene'], 'from_schema': 'https://w3id.org/biolink/bican-biolink-schema', 'id_prefixes': ['NCBIGene', 'ENSEMBL', 'HGNC', 'MGI', 'ZFIN', 'dictyBase', 'WB', 'WormBase', 'FB', 'RGD', 'SGD', 'PomBase', 'OMIM', 'KEGG.GENES', 'UMLS', 'Xenbase', 'AspGD', 'PHARMGKB.GENE'], 'in_subset': ['translator_minimal', 'model_organism_database'], 'mixins': ['gene or gene product', 'genomic entity', 'chemical entity or gene or gene product', 'physical essence', 'ontology class'], 'narrow_mappings': ['bioschemas:gene']})

model_config: ClassVar[ConfigDict] = {'arbitrary_types_allowed': True, 'extra': 'forbid', 'strict': False, 'use_enum_values': True, 'validate_assignment': True, 'validate_default': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

name: str | None

provided_by: list[str] | None

symbol: str | None

synonym: list[str] | None

type: list[str] | None

xref: list[str] | None

class bkbit.models.anatomical_structure.GeneOrGeneProduct(*, name: str | None = None)[source]

Bases: MacromolecularMachineMixin

A union of gene loci or gene products. Frequently an identifier for one will be used as proxy for another

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

linkml_meta: ClassVar[LinkMLMeta] = LinkMLMeta(root={'class_uri': 'biolink:GeneOrGeneProduct', 'definition_uri': 'https://w3id.org/biolink/vocab/GeneOrGeneProduct', 'from_schema': 'https://w3id.org/biolink/bican-biolink-schema', 'id_prefixes': ['CHEMBL.TARGET', 'IUPHAR.FAMILY'], 'mixin': True})

model_config: ClassVar[ConfigDict] = {'arbitrary_types_allowed': True, 'extra': 'forbid', 'strict': False, 'use_enum_values': True, 'validate_assignment': True, 'validate_default': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

name: str | None

class bkbit.models.anatomical_structure.Genome(*, id: str, iri: str | None = None, category: list[Literal['https://w3id.org/biolink/vocab/Genome', 'biolink:Genome']] = ['biolink:Genome'], type: list[str] | None = None, name: str | None = None, description: str | None = None, has_attribute: list[str] | None = None, deprecated: bool | None = None, provided_by: list[str] | None = None, xref: list[str] | None = None, full_name: str | None = None, synonym: list[str] | None = None, in_taxon: list[str] | None = None, in_taxon_label: str | None = None, has_biological_sequence: str | None = None)[source]

Bases: GenomicEntity, BiologicalEntity, PhysicalEssence, OntologyClass

A genome is the sum of genetic material within a cell or virion.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

category: list[Literal['https://w3id.org/biolink/vocab/Genome', 'biolink:Genome']]

deprecated: bool | None

description: str | None

full_name: str | None

has_attribute: list[str] | None

has_biological_sequence: str | None

id: str

in_taxon: list[str] | None

in_taxon_label: str | None

iri: str | None

linkml_meta: ClassVar[LinkMLMeta] = LinkMLMeta(root={'class_uri': 'biolink:Genome', 'close_mappings': ['dcid:GenomeAssemblyUnit'], 'definition_uri': 'https://w3id.org/biolink/vocab/Genome', 'exact_mappings': ['SO:0001026', 'SIO:000984', 'WIKIDATA:Q7020'], 'from_schema': 'https://w3id.org/biolink/bican-biolink-schema', 'in_subset': ['model_organism_database'], 'mixins': ['genomic entity', 'physical essence', 'ontology class']})

model_config: ClassVar[ConfigDict] = {'arbitrary_types_allowed': True, 'extra': 'forbid', 'strict': False, 'use_enum_values': True, 'validate_assignment': True, 'validate_default': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

name: str | None

provided_by: list[str] | None

synonym: list[str] | None

type: list[str] | None

xref: list[str] | None

class bkbit.models.anatomical_structure.GenomicEntity(*, has_biological_sequence: str | None = None)[source]

Bases: ConfiguredBaseModel

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

has_biological_sequence: str | None

linkml_meta: ClassVar[LinkMLMeta] = LinkMLMeta(root={'class_uri': 'biolink:GenomicEntity', 'definition_uri': 'https://w3id.org/biolink/vocab/GenomicEntity', 'from_schema': 'https://w3id.org/biolink/bican-biolink-schema', 'in_subset': ['translator_minimal'], 'mixin': True, 'narrow_mappings': ['STY:T028', 'GENO:0000897']})

model_config: ClassVar[ConfigDict] = {'arbitrary_types_allowed': True, 'extra': 'forbid', 'strict': False, 'use_enum_values': True, 'validate_assignment': True, 'validate_default': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class bkbit.models.anatomical_structure.ImageDataset(*, id: str, iri: str | None = None, category: list[Literal['https://identifiers.org/brain-bican/vocab/ImageDataset', 'bican:ImageDataset']] = ['bican:ImageDataset'], type: list[str] | None = None, name: str | None = None, description: str | None = None, has_attribute: list[str] | None = None, deprecated: bool | None = None, provided_by: list[str] | None = None, xref: list[str] | None = None, full_name: str | None = None, synonym: list[str] | None = None, version: str, revision_of: str | None = None, x_direction: ANATOMICALDIRECTION | None = None, y_direction: ANATOMICALDIRECTION | None = None, z_direction: ANATOMICALDIRECTION | None = None, x_size: Annotated[int | None, Ge(ge=1)] = None, y_size: Annotated[int | None, Ge(ge=1)] = None, z_size: Annotated[int | None, Ge(ge=1)] = None, x_resolution: float | None = None, y_resolution: float | None = None, z_resolution: float | None = None, unit: DISTANCEUNIT | None = None)[source]

Bases: VersionedNamedThing

An image dataset is versioned release of a multidimensional regular grid of measurements and metadata required for a morphological representation of an entity such as an anatomical structure (ref: OBI_0003327, RRID:SCR_006266)

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

category: list[Literal['https://identifiers.org/brain-bican/vocab/ImageDataset', 'bican:ImageDataset']]

deprecated: bool | None

description: str | None

full_name: str | None

has_attribute: list[str] | None

id: str

iri: str | None

linkml_meta: ClassVar[LinkMLMeta] = LinkMLMeta(root={'from_schema': 'https://identifiers.org/brain-bican/anatomical-structure-schema', 'slot_usage': {'revision_of': {'any_of': [{'range': 'ImageDataset'}, {'range': 'string'}], 'name': 'revision_of'}}})

model_config: ClassVar[ConfigDict] = {'arbitrary_types_allowed': True, 'extra': 'forbid', 'strict': False, 'use_enum_values': True, 'validate_assignment': True, 'validate_default': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

name: str | None

provided_by: list[str] | None

revision_of: str | None

synonym: list[str] | None

type: list[str] | None

unit: DISTANCEUNIT | None

version: str

x_direction: ANATOMICALDIRECTION | None

x_resolution: float | None

x_size: int | None

xref: list[str] | None

y_direction: ANATOMICALDIRECTION | None

y_resolution: float | None

y_size: int | None

z_direction: ANATOMICALDIRECTION | None

z_resolution: float | None

z_size: int | None

class bkbit.models.anatomical_structure.InformationContentEntity(*, id: str, iri: str | None = None, category: list[Literal['https://w3id.org/biolink/vocab/InformationContentEntity', 'biolink:InformationContentEntity']] = ['biolink:InformationContentEntity'], type: list[str] | None = None, name: str | None = None, description: str | None = None, has_attribute: list[str] | None = None, deprecated: bool | None = None, provided_by: list[str] | None = None, xref: list[str] | None = None, full_name: str | None = None, synonym: list[str] | None = None, license: str | None = None, rights: str | None = None, format: str | None = None, creation_date: date | None = None)[source]

Bases: NamedThing

a piece of information that typically describes some topic of discourse or is used as support.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

category: list[Literal['https://w3id.org/biolink/vocab/InformationContentEntity', 'biolink:InformationContentEntity']]

creation_date: date | None

deprecated: bool | None

description: str | None

format: str | None

full_name: str | None

has_attribute: list[str] | None

id: str

iri: str | None

license: str | None

linkml_meta: ClassVar[LinkMLMeta] = LinkMLMeta(root={'abstract': True, 'aliases': ['information', 'information artefact', 'information entity'], 'class_uri': 'biolink:InformationContentEntity', 'definition_uri': 'https://w3id.org/biolink/vocab/InformationContentEntity', 'exact_mappings': ['IAO:0000030'], 'from_schema': 'https://w3id.org/biolink/bican-biolink-schema', 'id_prefixes': ['doi'], 'narrow_mappings': ['UMLSSG:CONC', 'STY:T077', 'STY:T078', 'STY:T079', 'STY:T080', 'STY:T081', 'STY:T082', 'STY:T089', 'STY:T102', 'STY:T169', 'STY:T171', 'STY:T185']})

model_config: ClassVar[ConfigDict] = {'arbitrary_types_allowed': True, 'extra': 'forbid', 'strict': False, 'use_enum_values': True, 'validate_assignment': True, 'validate_default': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

name: str | None

provided_by: list[str] | None

rights: str | None

synonym: list[str] | None

type: list[str] | None

xref: list[str] | None

class bkbit.models.anatomical_structure.LinkMLMeta(root: RootModelRootType = PydanticUndefined)[source]

Bases: RootModel

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

model_config: ClassVar[ConfigDict] = {'frozen': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

root: dict[str, Any]

class bkbit.models.anatomical_structure.MacromolecularMachineMixin(*, name: str | None = None)[source]

Bases: ConfiguredBaseModel

A union of gene locus, gene product, and macromolecular complex. These are the basic units of function in a cell. They either carry out individual biological activities, or they encode molecules which do this.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

linkml_meta: ClassVar[LinkMLMeta] = LinkMLMeta(root={'class_uri': 'biolink:MacromolecularMachineMixin', 'definition_uri': 'https://w3id.org/biolink/vocab/MacromolecularMachineMixin', 'from_schema': 'https://w3id.org/biolink/bican-biolink-schema', 'mixin': True})

model_config: ClassVar[ConfigDict] = {'arbitrary_types_allowed': True, 'extra': 'forbid', 'strict': False, 'use_enum_values': True, 'validate_assignment': True, 'validate_default': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

name: str | None

class bkbit.models.anatomical_structure.MaterialSample(*, id: str, iri: str | None = None, category: list[Literal['https://w3id.org/biolink/vocab/MaterialSample', 'biolink:MaterialSample']] = ['biolink:MaterialSample'], type: list[str] | None = None, name: str | None = None, description: str | None = None, has_attribute: list[str] | None = None, deprecated: bool | None = None, provided_by: list[str] | None = None, xref: list[str] | None = None, full_name: str | None = None, synonym: list[str] | None = None)[source]

Bases: SubjectOfInvestigation, PhysicalEntity

A sample is a limited quantity of something (e.g. an individual or set of individuals from a population, or a portion of a substance) to be used for testing, analysis, inspection, investigation, demonstration, or trial use. [SIO]

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

category: list[Literal['https://w3id.org/biolink/vocab/MaterialSample', 'biolink:MaterialSample']]

deprecated: bool | None

description: str | None

full_name: str | None

has_attribute: list[str] | None

id: str

iri: str | None

linkml_meta: ClassVar[LinkMLMeta] = LinkMLMeta(root={'aliases': ['biospecimen', 'sample', 'biosample', 'physical sample'], 'class_uri': 'biolink:MaterialSample', 'definition_uri': 'https://w3id.org/biolink/vocab/MaterialSample', 'exact_mappings': ['OBI:0000747', 'SIO:001050'], 'from_schema': 'https://w3id.org/biolink/bican-biolink-schema', 'id_prefixes': ['BIOSAMPLE', 'GOLD.META'], 'mixins': ['subject of investigation']})

model_config: ClassVar[ConfigDict] = {'arbitrary_types_allowed': True, 'extra': 'forbid', 'strict': False, 'use_enum_values': True, 'validate_assignment': True, 'validate_default': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

name: str | None

provided_by: list[str] | None

synonym: list[str] | None

type: list[str] | None

xref: list[str] | None

class bkbit.models.anatomical_structure.NamedThing(*, id: str, iri: str | None = None, category: list[Literal['https://w3id.org/biolink/vocab/NamedThing', 'biolink:NamedThing']] = ['biolink:NamedThing'], type: list[str] | None = None, name: str | None = None, description: str | None = None, has_attribute: list[str] | None = None, deprecated: bool | None = None, provided_by: list[str] | None = None, xref: list[str] | None = None, full_name: str | None = None, synonym: list[str] | None = None)[source]

Bases: Entity

a databased entity or concept/class

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

category: list[Literal['https://w3id.org/biolink/vocab/NamedThing', 'biolink:NamedThing']]

deprecated: bool | None

description: str | None

full_name: str | None

has_attribute: list[str] | None

id: str

iri: str | None

linkml_meta: ClassVar[LinkMLMeta] = LinkMLMeta(root={'class_uri': 'biolink:NamedThing', 'definition_uri': 'https://w3id.org/biolink/vocab/NamedThing', 'exact_mappings': ['BFO:0000001', 'WIKIDATA:Q35120', 'UMLSSG:OBJC', 'STY:T071', 'dcid:Thing'], 'from_schema': 'https://w3id.org/biolink/bican-biolink-schema'})

model_config: ClassVar[ConfigDict] = {'arbitrary_types_allowed': True, 'extra': 'forbid', 'strict': False, 'use_enum_values': True, 'validate_assignment': True, 'validate_default': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

name: str | None

provided_by: list[str] | None

synonym: list[str] | None

type: list[str] | None

xref: list[str] | None

class bkbit.models.anatomical_structure.Occurrent[source]

Bases: PhysicalEssenceOrOccurrent

A processual entity.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

linkml_meta: ClassVar[LinkMLMeta] = LinkMLMeta(root={'class_uri': 'biolink:Occurrent', 'definition_uri': 'https://w3id.org/biolink/vocab/Occurrent', 'exact_mappings': ['BFO:0000003'], 'from_schema': 'https://w3id.org/biolink/bican-biolink-schema', 'mixin': True})

model_config: ClassVar[ConfigDict] = {'arbitrary_types_allowed': True, 'extra': 'forbid', 'strict': False, 'use_enum_values': True, 'validate_assignment': True, 'validate_default': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class bkbit.models.anatomical_structure.OntologyClass(*, id: str)[source]

Bases: ConfiguredBaseModel

a concept or class in an ontology, vocabulary or thesaurus. Note that nodes in a biolink compatible KG can be considered both instances of biolink classes, and OWL classes in their own right. In general you should not need to use this class directly. Instead, use the appropriate biolink class. For example, for the GO concept of endocytosis (GO:0006897), use bl:BiologicalProcess as the type.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

id: str

linkml_meta: ClassVar[LinkMLMeta] = LinkMLMeta(root={'class_uri': 'biolink:OntologyClass', 'comments': ["This is modeled as a mixin. 'ontology class' should not be the primary type of a node in the KG. Instead you should use an informative bioloink category, such as AnatomicalEntity (for Uberon classes), ChemicalSubstance (for CHEBI or CHEMBL), etc", "Note that formally this is a metaclass. Instances of this class are instances in the graph, but can be the object of 'type' edges. For example, if we had a node in the graph representing a specific brain of a specific patient (e.g brain001), this could have a category of bl:Sample, and by typed more specifically with an ontology class UBERON:nnn, which has as category bl:AnatomicalEntity"], 'definition_uri': 'https://w3id.org/biolink/vocab/OntologyClass', 'exact_mappings': ['owl:Class', 'schema:Class'], 'examples': [{'description': "the class 'brain' from the Uberon anatomy ontology", 'value': 'UBERON:0000955'}], 'from_schema': 'https://w3id.org/biolink/bican-biolink-schema', 'id_prefixes': ['MESH', 'UMLS', 'KEGG.BRITE'], 'mixin': True, 'see_also': ['https://github.com/biolink/biolink-model/issues/486']})

model_config: ClassVar[ConfigDict] = {'arbitrary_types_allowed': True, 'extra': 'forbid', 'strict': False, 'use_enum_values': True, 'validate_assignment': True, 'validate_default': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class bkbit.models.anatomical_structure.OrganismTaxon(*, id: str, iri: str | None = None, category: list[Literal['https://w3id.org/biolink/vocab/OrganismTaxon', 'biolink:OrganismTaxon']] = ['biolink:OrganismTaxon'], type: list[str] | None = None, name: str | None = None, description: str | None = None, has_attribute: list[str] | None = None, deprecated: bool | None = None, provided_by: list[str] | None = None, xref: list[str] | None = None, full_name: str | None = None, synonym: list[str] | None = None, has_taxonomic_rank: str | None = None)[source]

Bases: NamedThing

A classification of a set of organisms. Example instances: NCBITaxon:9606 (Homo sapiens), NCBITaxon:2 (Bacteria). Can also be used to represent strains or subspecies.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

category: list[Literal['https://w3id.org/biolink/vocab/OrganismTaxon', 'biolink:OrganismTaxon']]

deprecated: bool | None

description: str | None

full_name: str | None

has_attribute: list[str] | None

has_taxonomic_rank: str | None

id: str

iri: str | None

linkml_meta: ClassVar[LinkMLMeta] = LinkMLMeta(root={'aliases': ['taxon', 'taxonomic classification'], 'class_uri': 'biolink:OrganismTaxon', 'definition_uri': 'https://w3id.org/biolink/vocab/OrganismTaxon', 'exact_mappings': ['WIKIDATA:Q16521', 'STY:T001', 'bioschemas:Taxon'], 'from_schema': 'https://w3id.org/biolink/bican-biolink-schema', 'id_prefixes': ['NCBITaxon', 'MESH', 'UMLS'], 'in_subset': ['model_organism_database'], 'narrow_mappings': ['dcid:BiologicalSpecies'], 'values_from': ['NCBITaxon']})

model_config: ClassVar[ConfigDict] = {'arbitrary_types_allowed': True, 'extra': 'forbid', 'strict': False, 'use_enum_values': True, 'validate_assignment': True, 'validate_default': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

name: str | None

provided_by: list[str] | None

synonym: list[str] | None

type: list[str] | None

xref: list[str] | None

class bkbit.models.anatomical_structure.ParcellationAnnotation(*, part_of_anatomical_annotation_set: str, internal_identifier: str, voxel_count: Annotated[int | None, Ge(ge=0)] = None)[source]

Bases: ConfiguredBaseModel

A parcellation annotation defines a specific segment of an anatomical space denoted by an internal identifier and is a unique and exclusive member of a versioned release anatomical annotation set. For example, in the case where the anatomical annotation set is a single multi-value image mask (e.g. Allen Mouse CCF), a specific annotation corresponds to a specific label index (internal identifier) in the mask.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

internal_identifier: str

linkml_meta: ClassVar[LinkMLMeta] = LinkMLMeta(root={'from_schema': 'https://identifiers.org/brain-bican/anatomical-structure-schema'})

model_config: ClassVar[ConfigDict] = {'arbitrary_types_allowed': True, 'extra': 'forbid', 'strict': False, 'use_enum_values': True, 'validate_assignment': True, 'validate_default': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

part_of_anatomical_annotation_set: str

voxel_count: int | None

class bkbit.models.anatomical_structure.ParcellationAnnotationTermMap(*, subject_parcellation_term: str, subject_parcellation_annotation: ParcellationAnnotation | str)[source]

Bases: ConfiguredBaseModel

The parcellation annotation term map table defines the relationship between parcellation annotations and parcellation terms. A parcellation term is uniquely denoted by a parcellation term identifier and the parcellation terminology it belongs to. A parcellation term can be spatially parameterized by the union of one or more parcellation annotations within a versioned release of an anatomical annotation set. For example, annotations defining individual cortical layers in cortical region R (R1, R2/3, R4, etc) can be combined to define the parent region R.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

linkml_meta: ClassVar[LinkMLMeta] = LinkMLMeta(root={'from_schema': 'https://identifiers.org/brain-bican/anatomical-structure-schema'})

model_config: ClassVar[ConfigDict] = {'arbitrary_types_allowed': True, 'extra': 'forbid', 'strict': False, 'use_enum_values': True, 'validate_assignment': True, 'validate_default': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

subject_parcellation_annotation: ParcellationAnnotation | str

subject_parcellation_term: str

class bkbit.models.anatomical_structure.ParcellationAtlas(*, id: str, iri: str | None = None, category: list[Literal['https://identifiers.org/brain-bican/vocab/ParcellationAtlas', 'bican:ParcellationAtlas']] = ['bican:ParcellationAtlas'], type: list[str] | None = None, name: str | None = None, description: str | None = None, has_attribute: list[str] | None = None, deprecated: bool | None = None, provided_by: list[str] | None = None, xref: list[str] | None = None, full_name: str | None = None, synonym: list[str] | None = None, version: str, revision_of: str | None = None, has_anatomical_space: str, has_anatomical_annotation_set: str, has_parcellation_terminology: str, specialization_of: str | None = None)[source]

Bases: VersionedNamedThing

A parcellation atlas is a versioned release reference used to guide experiments or deal with the spatial relationship between objects or the location of objects within the context of some anatomical structure. An atlas is minimally defined by a notion of space (either implicit or explicit) and an annotation set. Reference atlases usually have additional parts that make them more useful in certain situations, such as a well defined coordinate system, delineations indicating the boundaries of various regions or cell populations, landmarks, and labels and names to make it easier to communicate about well known and useful locations (ref: ILX:0777109, RRID:SCR_023499).

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

category: list[Literal['https://identifiers.org/brain-bican/vocab/ParcellationAtlas', 'bican:ParcellationAtlas']]

deprecated: bool | None

description: str | None

full_name: str | None

has_anatomical_annotation_set: str

has_anatomical_space: str

has_attribute: list[str] | None

has_parcellation_terminology: str

id: str

iri: str | None

linkml_meta: ClassVar[LinkMLMeta] = LinkMLMeta(root={'from_schema': 'https://identifiers.org/brain-bican/anatomical-structure-schema', 'slot_usage': {'revision_of': {'any_of': [{'range': 'ParcellationAtlas'}, {'range': 'string'}], 'name': 'revision_of'}}})

model_config: ClassVar[ConfigDict] = {'arbitrary_types_allowed': True, 'extra': 'forbid', 'strict': False, 'use_enum_values': True, 'validate_assignment': True, 'validate_default': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

name: str | None

provided_by: list[str] | None

revision_of: str | None

specialization_of: str | None

synonym: list[str] | None

type: list[str] | None

version: str

xref: list[str] | None

class bkbit.models.anatomical_structure.ParcellationColorAssignment(*, subject_parcellation_term: str, part_of_parcellation_color_scheme: str, color: str | None = None)[source]

Bases: ConfiguredBaseModel

The parcellation color assignment associates hex color value to a parcellation term within a versioned release of a color scheme. A parcellation term is uniquely denoted by a parcellation term identifier and the parcellation terminology it belongs to.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

color: str | None

linkml_meta: ClassVar[LinkMLMeta] = LinkMLMeta(root={'from_schema': 'https://identifiers.org/brain-bican/anatomical-structure-schema'})

model_config: ClassVar[ConfigDict] = {'arbitrary_types_allowed': True, 'extra': 'forbid', 'strict': False, 'use_enum_values': True, 'validate_assignment': True, 'validate_default': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

part_of_parcellation_color_scheme: str

subject_parcellation_term: str

class bkbit.models.anatomical_structure.ParcellationColorScheme(*, id: str, iri: str | None = None, category: list[Literal['https://identifiers.org/brain-bican/vocab/ParcellationColorScheme', 'bican:ParcellationColorScheme']] = ['bican:ParcellationColorScheme'], type: list[str] | None = None, name: str | None = None, description: str | None = None, has_attribute: list[str] | None = None, deprecated: bool | None = None, provided_by: list[str] | None = None, xref: list[str] | None = None, full_name: str | None = None, synonym: list[str] | None = None, version: str, revision_of: str | None = None, subject_parcellation_terminology: str)[source]

Bases: VersionedNamedThing

A parcellation color scheme is a versioned release color palette that can be used to visualize a parcellation terminology or its related parcellation annotation. A parcellation terminology may have zero or more parcellation color schemes and each color scheme is in context of a specific parcellation terminology, where each parcellation term is assigned a hex color value. A parcellation color scheme is defined as a part of one and only one parcellation terminology.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

category: list[Literal['https://identifiers.org/brain-bican/vocab/ParcellationColorScheme', 'bican:ParcellationColorScheme']]

deprecated: bool | None

description: str | None

full_name: str | None

has_attribute: list[str] | None

id: str

iri: str | None

linkml_meta: ClassVar[LinkMLMeta] = LinkMLMeta(root={'from_schema': 'https://identifiers.org/brain-bican/anatomical-structure-schema', 'slot_usage': {'revision_of': {'any_of': [{'range': 'ParcellationColorScheme'}, {'range': 'string'}], 'name': 'revision_of'}}})

model_config: ClassVar[ConfigDict] = {'arbitrary_types_allowed': True, 'extra': 'forbid', 'strict': False, 'use_enum_values': True, 'validate_assignment': True, 'validate_default': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

name: str | None

provided_by: list[str] | None

revision_of: str | None

subject_parcellation_terminology: str

synonym: list[str] | None

type: list[str] | None

version: str

xref: list[str] | None

class bkbit.models.anatomical_structure.ParcellationTerm(*, id: str, iri: str | None = None, category: list[Literal['https://identifiers.org/brain-bican/vocab/ParcellationTerm', 'bican:ParcellationTerm']] = ['bican:ParcellationTerm'], type: list[str] | None = None, name: str | None = None, description: str | None = None, has_attribute: list[str] | None = None, deprecated: bool | None = None, provided_by: list[str] | None = None, xref: list[str] | None = None, full_name: str | None = None, synonym: list[str] | None = None, version: str, revision_of: str | None = None, ordinal: Annotated[int | None, Ge(ge=0)] = None, symbol: str | None = None, part_of_parcellation_term_set: str, has_parent_parcellation_term: str | None = None)[source]

Bases: VersionedNamedThing

A parcellation term is an individual term within a specific parcellation terminology describing a single anatomical entity by a persistent identifier, name, symbol and description. A parcellation term is a unique and exclusive member of a versioned release parcellation terminology. Although term identifiers must be unique within the context of one versioned release of a parcellation terminology, they can be reused in different parcellation terminology versions enabling the representation of terminology updates and modifications over time.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

category: list[Literal['https://identifiers.org/brain-bican/vocab/ParcellationTerm', 'bican:ParcellationTerm']]

deprecated: bool | None

description: str | None

full_name: str | None

has_attribute: list[str] | None

has_parent_parcellation_term: str | None

id: str

iri: str | None

linkml_meta: ClassVar[LinkMLMeta] = LinkMLMeta(root={'from_schema': 'https://identifiers.org/brain-bican/anatomical-structure-schema', 'slot_usage': {'ordinal': {'description': 'Ordinal of the parcellation term among other terms within the context of the associated parcellation terminology.', 'name': 'ordinal'}}})

model_config: ClassVar[ConfigDict] = {'arbitrary_types_allowed': True, 'extra': 'forbid', 'strict': False, 'use_enum_values': True, 'validate_assignment': True, 'validate_default': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

name: str | None

ordinal: int | None

part_of_parcellation_term_set: str

provided_by: list[str] | None

revision_of: str | None

symbol: str | None

synonym: list[str] | None

type: list[str] | None

version: str

xref: list[str] | None

class bkbit.models.anatomical_structure.ParcellationTermSet(*, id: str, iri: str | None = None, category: list[Literal['https://identifiers.org/brain-bican/vocab/ParcellationTermSet', 'bican:ParcellationTermSet']] = ['bican:ParcellationTermSet'], type: list[str] | None = None, name: str | None = None, description: str | None = None, has_attribute: list[str] | None = None, deprecated: bool | None = None, provided_by: list[str] | None = None, xref: list[str] | None = None, full_name: str | None = None, synonym: list[str] | None = None, version: str, revision_of: str | None = None, ordinal: Annotated[int | None, Ge(ge=0)] = None, part_of_parcellation_terminology: str, has_parent_parcellation_term_set: str | None = None)[source]

Bases: VersionedNamedThing

A parcellation term set is the set of parcellation terms within a specific parcellation terminology. A parcellation term set belongs to one and only one parcellation terminology and each parcellation term in a parcellation terminology belongs to one and only one term set. If the parcellation terminology is a taxonomy, parcellation term sets can be used to represent taxonomic ranks. For consistency, if the terminology does not have the notion of taxonomic ranks, all terms are grouped into a single parcellation term set.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

category: list[Literal['https://identifiers.org/brain-bican/vocab/ParcellationTermSet', 'bican:ParcellationTermSet']]

deprecated: bool | None

description: str | None

full_name: str | None

has_attribute: list[str] | None

has_parent_parcellation_term_set: str | None

id: str

iri: str | None

linkml_meta: ClassVar[LinkMLMeta] = LinkMLMeta(root={'from_schema': 'https://identifiers.org/brain-bican/anatomical-structure-schema', 'slot_usage': {'ordinal': {'description': 'Ordinal of the parcellation term set among other term sets within the context of the associated parcellation terminology.', 'name': 'ordinal'}}})

model_config: ClassVar[ConfigDict] = {'arbitrary_types_allowed': True, 'extra': 'forbid', 'strict': False, 'use_enum_values': True, 'validate_assignment': True, 'validate_default': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

name: str | None

ordinal: int | None

part_of_parcellation_terminology: str

provided_by: list[str] | None

revision_of: str | None

synonym: list[str] | None

type: list[str] | None

version: str

xref: list[str] | None

class bkbit.models.anatomical_structure.ParcellationTerminology(*, id: str, iri: str | None = None, category: list[Literal['https://identifiers.org/brain-bican/vocab/ParcellationTerminology', 'bican:ParcellationTerminology']] = ['bican:ParcellationTerminology'], type: list[str] | None = None, name: str | None = None, description: str | None = None, has_attribute: list[str] | None = None, deprecated: bool | None = None, provided_by: list[str] | None = None, xref: list[str] | None = None, full_name: str | None = None, synonym: list[str] | None = None, version: str, revision_of: str | None = None)[source]

Bases: VersionedNamedThing

A parcellation terminology is a versioned release set of terms that can be used to label annotations in an atlas, providing human readability and context and allowing communication about brain locations and structural properties. Typically, a terminology is a set of descriptive anatomical terms following a specific naming convention and/or approach to organization scheme. The terminology may be a flat list of controlled vocabulary, a taxonomy and partonomy, or an ontology (ref: ILX:0777107, RRID:SCR_023499)

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

category: list[Literal['https://identifiers.org/brain-bican/vocab/ParcellationTerminology', 'bican:ParcellationTerminology']]

deprecated: bool | None

description: str | None

full_name: str | None

has_attribute: list[str] | None

id: str

iri: str | None

linkml_meta: ClassVar[LinkMLMeta] = LinkMLMeta(root={'from_schema': 'https://identifiers.org/brain-bican/anatomical-structure-schema', 'slot_usage': {'revision_of': {'any_of': [{'range': 'ParcellationTerminology'}, {'range': 'string'}], 'name': 'revision_of'}}})

model_config: ClassVar[ConfigDict] = {'arbitrary_types_allowed': True, 'extra': 'forbid', 'strict': False, 'use_enum_values': True, 'validate_assignment': True, 'validate_default': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

name: str | None

provided_by: list[str] | None

revision_of: str | None

synonym: list[str] | None

type: list[str] | None

version: str

xref: list[str] | None

class bkbit.models.anatomical_structure.PhysicalEntity(*, id: str, iri: str | None = None, category: list[Literal['https://w3id.org/biolink/vocab/PhysicalEntity', 'biolink:PhysicalEntity']] = ['biolink:PhysicalEntity'], type: list[str] | None = None, name: str | None = None, description: str | None = None, has_attribute: list[str] | None = None, deprecated: bool | None = None, provided_by: list[str] | None = None, xref: list[str] | None = None, full_name: str | None = None, synonym: list[str] | None = None)[source]

Bases: PhysicalEssence, NamedThing

An entity that has material reality (a.k.a. physical essence).

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

category: list[Literal['https://w3id.org/biolink/vocab/PhysicalEntity', 'biolink:PhysicalEntity']]

deprecated: bool | None

description: str | None

full_name: str | None

has_attribute: list[str] | None

id: str

iri: str | None

linkml_meta: ClassVar[LinkMLMeta] = LinkMLMeta(root={'class_uri': 'biolink:PhysicalEntity', 'definition_uri': 'https://w3id.org/biolink/vocab/PhysicalEntity', 'exact_mappings': ['STY:T072'], 'from_schema': 'https://w3id.org/biolink/bican-biolink-schema', 'mixins': ['physical essence'], 'narrow_mappings': ['STY:T073']})

model_config: ClassVar[ConfigDict] = {'arbitrary_types_allowed': True, 'extra': 'forbid', 'strict': False, 'use_enum_values': True, 'validate_assignment': True, 'validate_default': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

name: str | None

provided_by: list[str] | None

synonym: list[str] | None

type: list[str] | None

xref: list[str] | None

class bkbit.models.anatomical_structure.PhysicalEssence[source]

Bases: PhysicalEssenceOrOccurrent

Semantic mixin concept. Pertains to entities that have physical properties such as mass, volume, or charge.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

linkml_meta: ClassVar[LinkMLMeta] = LinkMLMeta(root={'class_uri': 'biolink:PhysicalEssence', 'definition_uri': 'https://w3id.org/biolink/vocab/PhysicalEssence', 'from_schema': 'https://w3id.org/biolink/bican-biolink-schema', 'mixin': True})

model_config: ClassVar[ConfigDict] = {'arbitrary_types_allowed': True, 'extra': 'forbid', 'strict': False, 'use_enum_values': True, 'validate_assignment': True, 'validate_default': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class bkbit.models.anatomical_structure.PhysicalEssenceOrOccurrent[source]

Bases: ConfiguredBaseModel

Either a physical or processual entity.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

linkml_meta: ClassVar[LinkMLMeta] = LinkMLMeta(root={'class_uri': 'biolink:PhysicalEssenceOrOccurrent', 'definition_uri': 'https://w3id.org/biolink/vocab/PhysicalEssenceOrOccurrent', 'from_schema': 'https://w3id.org/biolink/bican-biolink-schema', 'mixin': True})

model_config: ClassVar[ConfigDict] = {'arbitrary_types_allowed': True, 'extra': 'forbid', 'strict': False, 'use_enum_values': True, 'validate_assignment': True, 'validate_default': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class bkbit.models.anatomical_structure.Procedure(*, id: str, iri: str | None = None, category: list[Literal['https://w3id.org/biolink/vocab/Procedure', 'biolink:Procedure']] = ['biolink:Procedure'], type: list[str] | None = None, name: str | None = None, description: str | None = None, has_attribute: list[str] | None = None, deprecated: bool | None = None, provided_by: list[str] | None = None, xref: list[str] | None = None, full_name: str | None = None, synonym: list[str] | None = None)[source]

Bases: ActivityAndBehavior, NamedThing

A series of actions conducted in a certain order or manner

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

category: list[Literal['https://w3id.org/biolink/vocab/Procedure', 'biolink:Procedure']]

deprecated: bool | None

description: str | None

full_name: str | None

has_attribute: list[str] | None

id: str

iri: str | None

linkml_meta: ClassVar[LinkMLMeta] = LinkMLMeta(root={'class_uri': 'biolink:Procedure', 'definition_uri': 'https://w3id.org/biolink/vocab/Procedure', 'exact_mappings': ['UMLSSG:PROC', 'dcid:MedicalProcedure'], 'from_schema': 'https://w3id.org/biolink/bican-biolink-schema', 'id_prefixes': ['CPT'], 'mixins': ['activity and behavior'], 'narrow_mappings': ['STY:T059', 'STY:T060', 'STY:T061', 'STY:T063']})

model_config: ClassVar[ConfigDict] = {'arbitrary_types_allowed': True, 'extra': 'forbid', 'strict': False, 'use_enum_values': True, 'validate_assignment': True, 'validate_default': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

name: str | None

provided_by: list[str] | None

synonym: list[str] | None

type: list[str] | None

xref: list[str] | None

class bkbit.models.anatomical_structure.QuantityValue(*, has_unit: str | None = None, has_numeric_value: float | None = None)[source]

Bases: Annotation

A value of an attribute that is quantitative and measurable, expressed as a combination of a unit and a numeric value

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

has_numeric_value: float | None

has_unit: str | None

linkml_meta: ClassVar[LinkMLMeta] = LinkMLMeta(root={'class_uri': 'biolink:QuantityValue', 'definition_uri': 'https://w3id.org/biolink/vocab/QuantityValue', 'from_schema': 'https://w3id.org/biolink/bican-biolink-schema'})

model_config: ClassVar[ConfigDict] = {'arbitrary_types_allowed': True, 'extra': 'forbid', 'strict': False, 'use_enum_values': True, 'validate_assignment': True, 'validate_default': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class bkbit.models.anatomical_structure.SubjectOfInvestigation[source]

Bases: ConfiguredBaseModel

An entity that has the role of being studied in an investigation, study, or experiment

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

linkml_meta: ClassVar[LinkMLMeta] = LinkMLMeta(root={'class_uri': 'biolink:SubjectOfInvestigation', 'definition_uri': 'https://w3id.org/biolink/vocab/SubjectOfInvestigation', 'from_schema': 'https://w3id.org/biolink/bican-biolink-schema', 'mixin': True})

model_config: ClassVar[ConfigDict] = {'arbitrary_types_allowed': True, 'extra': 'forbid', 'strict': False, 'use_enum_values': True, 'validate_assignment': True, 'validate_default': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class bkbit.models.anatomical_structure.TaxonomicRank(*, id: str)[source]

Bases: OntologyClass

A descriptor for the rank within a taxonomic classification. Example instance: TAXRANK:0000017 (kingdom)

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

id: str

linkml_meta: ClassVar[LinkMLMeta] = LinkMLMeta(root={'class_uri': 'biolink:TaxonomicRank', 'definition_uri': 'https://w3id.org/biolink/vocab/TaxonomicRank', 'from_schema': 'https://w3id.org/biolink/bican-biolink-schema', 'id_prefixes': ['TAXRANK'], 'mappings': ['WIKIDATA:Q427626']})

model_config: ClassVar[ConfigDict] = {'arbitrary_types_allowed': True, 'extra': 'forbid', 'strict': False, 'use_enum_values': True, 'validate_assignment': True, 'validate_default': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class bkbit.models.anatomical_structure.ThingWithTaxon(*, in_taxon: list[str] | None = None, in_taxon_label: str | None = None)[source]

Bases: ConfiguredBaseModel

A mixin that can be used on any entity that can be taxonomically classified. This includes individual organisms; genes, their products and other molecular entities; body parts; biological processes

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

in_taxon: list[str] | None

in_taxon_label: str | None

linkml_meta: ClassVar[LinkMLMeta] = LinkMLMeta(root={'class_uri': 'biolink:ThingWithTaxon', 'definition_uri': 'https://w3id.org/biolink/vocab/ThingWithTaxon', 'from_schema': 'https://w3id.org/biolink/bican-biolink-schema', 'mixin': True})

model_config: ClassVar[ConfigDict] = {'arbitrary_types_allowed': True, 'extra': 'forbid', 'strict': False, 'use_enum_values': True, 'validate_assignment': True, 'validate_default': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class bkbit.models.anatomical_structure.VersionedNamedThing(*, id: str, iri: str | None = None, category: list[Literal['https://identifiers.org/brain-bican/vocab/VersionedNamedThing', 'bican:VersionedNamedThing']] = ['bican:VersionedNamedThing'], type: list[str] | None = None, name: str | None = None, description: str | None = None, has_attribute: list[str] | None = None, deprecated: bool | None = None, provided_by: list[str] | None = None, xref: list[str] | None = None, full_name: str | None = None, synonym: list[str] | None = None, version: str, revision_of: str | None = None)[source]

Bases: NamedThing

An iteration of the biolink:NamedThing class that stores metadata about the object’s version.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

category: list[Literal['https://identifiers.org/brain-bican/vocab/VersionedNamedThing', 'bican:VersionedNamedThing']]

deprecated: bool | None

description: str | None

full_name: str | None

has_attribute: list[str] | None

id: str

iri: str | None

linkml_meta: ClassVar[LinkMLMeta] = LinkMLMeta(root={'abstract': True, 'from_schema': 'https://identifiers.org/brain-bican/bican-core-schema', 'slot_usage': {'version': {'name': 'version', 'required': True}}})

model_config: ClassVar[ConfigDict] = {'arbitrary_types_allowed': True, 'extra': 'forbid', 'strict': False, 'use_enum_values': True, 'validate_assignment': True, 'validate_default': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

name: str | None

provided_by: list[str] | None

revision_of: str | None

synonym: list[str] | None

type: list[str] | None

version: str

xref: list[str] | None