bkbit.models.cell_taxonomy module

class bkbit.models.cell_taxonomy.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.cell_taxonomy.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, information_content: float | None = None, equivalent_identifiers: 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

equivalent_identifiers: list[str] | None

full_name: str | None

has_attribute: list[str] | None

id: str

information_content: float | None

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', 'serialize_by_alias': True, 'strict': False, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_name': 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.cell_taxonomy.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', 'serialize_by_alias': True, 'strict': False, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_name': True, 'validate_default': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class bkbit.models.cell_taxonomy.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, information_content: float | None = None, equivalent_identifiers: 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

equivalent_identifiers: list[str] | None

full_name: str | None

has_attribute: list[str] | None

id: str

information_content: float | None

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', 'serialize_by_alias': True, 'strict': False, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_name': 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.cell_taxonomy.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, information_content: float | None = None, equivalent_identifiers: 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

equivalent_identifiers: list[str] | None

full_name: str | None

has_attribute: list[str] | None

id: str

information_content: float | None

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', 'serialize_by_alias': True, 'strict': False, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_name': 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.cell_taxonomy.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', 'serialize_by_alias': True, 'strict': False, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_name': True, 'validate_default': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class bkbit.models.cell_taxonomy.AnnotationCollection(*, annotations: list[GeneAnnotation] | None = None, genome_annotations: list[GenomeAnnotation] | None = None, genome_assemblies: list[GenomeAssembly] | 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.

annotations: list[GeneAnnotation] | None

genome_annotations: list[GenomeAnnotation] | None

genome_assemblies: list[GenomeAssembly] | None

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

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

class bkbit.models.cell_taxonomy.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, information_content: float | None = None, equivalent_identifiers: 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

equivalent_identifiers: list[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

information_content: float | None

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', 'serialize_by_alias': True, 'strict': False, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_name': 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.cell_taxonomy.AuthorityType(value)[source]

Bases: str, Enum

An enumeration.

ENSEMBL = 'ENSEMBL'

NCBI = 'NCBI'

class bkbit.models.cell_taxonomy.BioType(value)[source]

Bases: str, Enum

An enumeration.

noncoding = 'noncoding'

protein_coding = 'protein_coding'

class bkbit.models.cell_taxonomy.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, information_content: float | None = None, equivalent_identifiers: 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

equivalent_identifiers: list[str] | None

full_name: str | None

has_attribute: list[str] | None

id: str

in_taxon: list[str] | None

in_taxon_label: str | None

information_content: float | 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', 'serialize_by_alias': True, 'strict': False, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_name': 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

Bases: ProvEntity, NamedThing

A single cell observation in the taxonomy; corresponds to one row in the obs DataFrame of the h5ad file.

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.

anatomical_region: str | None

anatomical_region_ontology_term_id: str | None

assay: str | None

assay_ontology_term_id: str | None

brain_region_ontology_term_id: str | None

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

cluster_id: str | None

deprecated: bool | None

description: str | None

equivalent_identifiers: list[str] | None

full_name: str | None

has_attribute: list[str] | None

id: str

information_content: float | None

iri: str | None

is_primary_data: bool | None

linkml_meta: ClassVar[LinkMLMeta] = LinkMLMeta(root={'from_schema': 'https://w3id.org/brain-bican/cell-taxonomy', 'mixins': ['ProvEntity'], 'slot_usage': {'id': {'description': 'Unique identifier for each individual cell.', 'from_schema': 'bican_biolink', 'in_subset': ['obs', 'assigned_metadata'], 'name': 'id', 'range': 'string'}}})

load_id: str | None

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

name: str | None

part_of_cluster: str | None

provided_by: list[str] | None

suspension_type: SuspensionType | None

synonym: list[str] | None

type: list[str] | None

was_derived_from: str | None

was_generated_by: str | None

xref: list[str] | None

class bkbit.models.cell_taxonomy.CellTypeSet(*, id: str, iri: str | None = None, category: list[Literal['https://identifiers.org/brain-bican/vocab/CellTypeSet', 'bican:CellTypeSet']] = ['bican:CellTypeSet'], 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, information_content: float | None = None, equivalent_identifiers: list[str] | None = None, was_derived_from: str | None = None, was_generated_by: str | None = None, has_parent: str | None = None, order: int | None = None, part_of_taxonomy: str | None = None, cell_type_set_type: CellTypeSetType | None = None)[source]

Bases: ProvEntity, NamedThing

A named annotation level in the taxonomy hierarchy (e.g. Class, Subclass) grouping cell type taxons. May represent a taxonomic level or a neighborhood.

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/CellTypeSet', 'bican:CellTypeSet']]

cell_type_set_type: CellTypeSetType | None

deprecated: bool | None

description: str | None

equivalent_identifiers: list[str] | None

full_name: str | None

has_attribute: list[str] | None

has_parent: str | None

id: str

information_content: float | None

iri: str | None

linkml_meta: ClassVar[LinkMLMeta] = LinkMLMeta(root={'from_schema': 'https://w3id.org/brain-bican/cell-taxonomy', 'mixins': ['ProvEntity'], 'slot_usage': {'has_parent': {'description': 'The next broader annotation level in the taxonomy hierarchy (e.g. Subclass has_parent Class).', 'in_subset': ['uns', 'annotations'], 'name': 'has_parent', 'range': 'CellTypeSet'}, 'id': {'description': 'Unique identifier for this annotation level.', 'from_schema': 'bican_biolink', 'in_subset': ['uns', 'annotations'], 'name': 'id', 'range': 'string'}, 'name': {'description': 'Name of this annotation level used as column header in obs (e.g. Class, Subclass).', 'from_schema': 'bican_biolink', 'in_subset': ['obs', 'uns', 'annotations'], 'name': 'name', 'range': 'string'}, 'order': {'description': 'Integer rank of this annotation level in the hierarchy; lower values are broader types.', 'in_subset': ['uns', 'annotations'], 'name': 'order', 'range': 'integer'}}})

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

name: str | None

order: int | None

part_of_taxonomy: str | None

provided_by: list[str] | None

synonym: list[str] | None

type: list[str] | None

was_derived_from: str | None

was_generated_by: str | None

xref: list[str] | None

class bkbit.models.cell_taxonomy.CellTypeSetType(value)[source]

Bases: str, Enum

An enumeration.

neighborhood = 'neighborhood': Denotes CellTypeSet is at Neighborhood level.

taxonomic_level = 'taxonomic_level': Denotes CellTypeSet is at Taxonomic level.

class bkbit.models.cell_taxonomy.CellTypeTaxon(*, id: str, iri: str | None = None, category: list[Literal['https://identifiers.org/brain-bican/vocab/CellTypeTaxon', 'bican:CellTypeTaxon']] = ['bican:CellTypeTaxon'], 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, information_content: float | None = None, equivalent_identifiers: list[str] | None = None, was_derived_from: str | None = None, was_generated_by: str | None = None, has_parent: str | None = None, part_of_set: str | None = None, accession_id: str | None = None, order: int | None = None, curated_markers_to_primates: list[str] | None = None, curated_markers_to_mouse: list[str] | None = None, cell_type_ontology_term_id: str | None = None, number_of_cells: int | None = None)[source]

Bases: ProvEntity, NamedThing

A node in the cell type taxonomy representing a unit of cell type classification at a specific annotation level. Taxons may be organized into a hierarchy and grouped into neighborhoods.

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.

accession_id: str | None

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

cell_type_ontology_term_id: str | None

curated_markers_to_mouse: list[str] | None

curated_markers_to_primates: list[str] | None

deprecated: bool | None

description: str | None

equivalent_identifiers: list[str] | None

full_name: str | None

has_attribute: list[str] | None

has_parent: str | None

id: str

information_content: float | None

iri: str | None

linkml_meta: ClassVar[LinkMLMeta] = LinkMLMeta(root={'from_schema': 'https://w3id.org/brain-bican/cell-taxonomy', 'mixins': ['ProvEntity'], 'slot_usage': {'accession_id': {'description': 'Stable cross-version identifier for this cell type taxon (e.g. CS20230722_CLAS_11).', 'in_subset': ['uns', 'annotations'], 'name': 'accession_id', 'range': 'string'}, 'has_parent': {'description': 'Reference to the parent taxon at the next broader annotation level.', 'in_subset': ['uns', 'annotations'], 'name': 'has_parent', 'range': 'CellTypeTaxon'}, 'id': {'description': 'Unique identifier for this cell type taxon.', 'from_schema': 'bican_biolink', 'in_subset': ['uns', 'annotations'], 'name': 'id', 'range': 'string'}, 'name': {'description': 'Human-readable label for this cell type taxon at the given annotation level (e.g. Glutamatergic).', 'from_schema': 'bican_biolink', 'in_subset': ['obs', 'annotations'], 'name': 'name', 'range': 'string'}, 'order': {'description': 'The priority or display order of this taxon among all taxons in the taxonomy.', 'in_subset': ['uns', 'annotations'], 'name': 'order', 'range': 'integer'}, 'part_of_set': {'description': 'The annotation level (CellTypeSet) for which this taxon is a member.', 'in_subset': ['uns', 'annotations'], 'name': 'part_of_set', 'range': 'CellTypeSet'}}})

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

name: str | None

number_of_cells: int | None

order: int | None

part_of_set: str | None

provided_by: list[str] | None

synonym: list[str] | None

type: list[str] | None

was_derived_from: str | None

was_generated_by: str | None

xref: list[str] | None

Bases: ProvEntity, NamedThing

A systematic classification of cell types and their hierarchical relationships in the mammalian brain, including annotation levels and their corresponding cell type nodes.

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.

accession_id: str | None

batch_condition: str | None

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

cellannotation_schema: str | None

cluster_algorithm: str | None

cluster_info: str | None

content_url: list[str] | None

default_embedding: str | None

dendrogram: str | None

deprecated: bool | None

description: str | None

equivalent_identifiers: list[str] | None

filter: bool | None

full_name: str | None

has_attribute: list[str] | None

has_embedding: list[str] | None

has_expression_matrix: list[str] | None

hierarchy: str | None

id: str

information_content: float | None

iri: str | None

linkml_meta: ClassVar[LinkMLMeta] = LinkMLMeta(root={'from_schema': 'https://w3id.org/brain-bican/cell-taxonomy', 'mixins': ['ProvEntity'], 'slot_usage': {'accession_id': {'description': 'Provider-assigned accession identifier for this taxonomy (e.g. CCN20230722).', 'in_subset': ['uns', 'tooling'], 'name': 'accession_id', 'range': 'string'}, 'content_url': {'description': 'Permanent URL to molecular data if the expression matrix is not embedded in the file.', 'from_schema': 'bican_core', 'in_subset': ['uns', 'data'], 'name': 'content_url', 'range': 'uri'}, 'id': {'description': 'Unique identifier for this taxonomy.', 'from_schema': 'bican_biolink', 'name': 'id', 'range': 'string'}, 'was_derived_from': {'description': 'One or more cluster sets from which this taxonomy was derived.', 'multivalued': True, 'name': 'was_derived_from', 'range': 'ClusterSet'}}})

mode: str | None

model_config: ClassVar[ConfigDict] = {'arbitrary_types_allowed': True, 'extra': 'forbid', 'serialize_by_alias': True, 'strict': False, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_name': 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

quality_control_markers: str | None

schema_version: str | None

synonym: list[str] | None

title: str | None

type: list[str] | None

was_derived_from: list[str] | None

was_generated_by: str | None

xref: list[str] | None

class bkbit.models.cell_taxonomy.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', 'serialize_by_alias': True, 'strict': False, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_name': 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.cell_taxonomy.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', 'serialize_by_alias': True, 'strict': False, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_name': True, 'validate_default': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class bkbit.models.cell_taxonomy.Cluster(*, id: str, iri: str | None = None, category: list[Literal['https://identifiers.org/brain-bican/vocab/Cluster', 'bican:Cluster']] = ['bican:Cluster'], 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, information_content: float | None = None, equivalent_identifiers: list[str] | None = None, was_derived_from: str | None = None, was_generated_by: str | None = None, part_of_set: str | None = None, has_parent: list[str] | None = None, number_of_observations: int | None = None)[source]

Bases: ProvEntity, NamedThing

A single cluster resulting from a clustering algorithm; groups cells with similar molecular profiles. Corresponds to one row in cluster_info and one distinct value of cluster_id in obs.

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/Cluster', 'bican:Cluster']]

deprecated: bool | None

description: str | None

equivalent_identifiers: list[str] | None

full_name: str | None

has_attribute: list[str] | None

has_parent: list[str] | None

id: str

information_content: float | None

iri: str | None

linkml_meta: ClassVar[LinkMLMeta] = LinkMLMeta(root={'from_schema': 'https://w3id.org/brain-bican/cell-taxonomy', 'mixins': ['ProvEntity'], 'slot_usage': {'has_parent': {'in_subset': ['obs', 'uns', 'annotations'], 'multivalued': True, 'name': 'has_parent', 'range': 'CellTypeTaxon'}, 'id': {'description': 'Unique identifier for this cluster.', 'from_schema': 'bican_biolink', 'in_subset': ['obs', 'uns', 'annotations'], 'name': 'id', 'range': 'string'}, 'name': {'description': 'Human-readable label for this cluster; corresponds to cluster_id values in obs.', 'from_schema': 'bican_biolink', 'in_subset': ['obs', 'uns', 'annotations'], 'name': 'name', 'range': 'string'}, 'part_of_set': {'description': 'The cluster set to which this cluster belongs.', 'in_subset': ['uns', 'annotations'], 'name': 'part_of_set', 'range': 'ClusterSet'}}})

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

name: str | None

number_of_observations: int | None

part_of_set: str | None

provided_by: list[str] | None

synonym: list[str] | None

type: list[str] | None

was_derived_from: str | None

was_generated_by: str | None

xref: list[str] | None

class bkbit.models.cell_taxonomy.ClusterSet(*, id: str, iri: str | None = None, category: list[Literal['https://identifiers.org/brain-bican/vocab/ClusterSet', 'bican:ClusterSet']] = ['bican:ClusterSet'], 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, information_content: float | None = None, equivalent_identifiers: list[str] | None = None, was_derived_from: list[str] | None = None, was_generated_by: str | None = None)[source]

Bases: ProvEntity, NamedThing

The set of clusters produced by a single clustering run. A CellTypeTaxonomy is derived from one or more ClusterSets.

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/ClusterSet', 'bican:ClusterSet']]

deprecated: bool | None

description: str | None

equivalent_identifiers: list[str] | None

full_name: str | None

has_attribute: list[str] | None

id: str

information_content: float | None

iri: str | None

linkml_meta: ClassVar[LinkMLMeta] = LinkMLMeta(root={'from_schema': 'https://w3id.org/brain-bican/cell-taxonomy', 'mixins': ['ProvEntity'], 'slot_usage': {'id': {'description': 'Unique identifier for this cluster set.', 'from_schema': 'bican_biolink', 'in_subset': ['uns', 'annotations'], 'name': 'id', 'range': 'string'}, 'name': {'description': 'Human-readable name for this cluster set (e.g. the name of the clustering run).', 'from_schema': 'bican_biolink', 'in_subset': ['uns', 'annotations'], 'name': 'name', 'range': 'string'}, 'was_derived_from': {'multivalued': True, 'name': 'was_derived_from', 'range': 'ExpressionMatrix'}}})

model_config: ClassVar[ConfigDict] = {'arbitrary_types_allowed': True, 'extra': 'forbid', 'serialize_by_alias': True, 'strict': False, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_name': 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

was_derived_from: list[str] | None

was_generated_by: str | None

xref: list[str] | None

class bkbit.models.cell_taxonomy.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', 'serialize_by_alias': True, 'strict': False, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_name': True, 'validate_default': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class bkbit.models.cell_taxonomy.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

equivalent_identifiers: list[str] | None

format: str | None

full_name: str | None

has_attribute: list[str] | None

id: str

information_content: float | None

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', 'serialize_by_alias': True, 'strict': False, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_name': 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.cell_taxonomy.DigestType(value)[source]

Bases: str, Enum

An enumeration.

MD5 = 'spdx:checksumAlgorithm_md5'

SHA1 = 'spdx:checksumAlgorithm_sha1'

SHA256 = 'spdx:checksumAlgorithm_sha256'

class bkbit.models.cell_taxonomy.Embedding(*, id: str, iri: str | None = None, category: list[Literal['https://identifiers.org/brain-bican/vocab/Embedding', 'bican:Embedding']] = ['bican:Embedding'], 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, information_content: float | None = None, equivalent_identifiers: list[str] | None = None, was_derived_from: str | None = None, was_generated_by: str | None = None, embedding_key: str | None = None, embedding_matrix: float | None = None)[source]

Bases: ProvEntity, NamedThing

A dimensionality reduction of the cell-by-gene matrix (e.g. UMAP, PCA, tSNE). Stored as a cell × dim matrix in obsm. No BKE equivalent.

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/Embedding', 'bican:Embedding']]

deprecated: bool | None

description: str | None

embedding_key: str | None

embedding_matrix: float | None

equivalent_identifiers: list[str] | None

full_name: str | None

has_attribute: list[str] | None

id: str

information_content: float | None

iri: str | None

linkml_meta: ClassVar[LinkMLMeta] = LinkMLMeta(root={'from_schema': 'https://w3id.org/brain-bican/cell-taxonomy', 'mixins': ['ProvEntity'], 'slot_usage': {'id': {'description': 'Unique identifier for this embedding.', 'from_schema': 'bican_biolink', 'name': 'id', 'range': 'string'}}})

model_config: ClassVar[ConfigDict] = {'arbitrary_types_allowed': True, 'extra': 'forbid', 'serialize_by_alias': True, 'strict': False, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_name': 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

was_derived_from: str | None

was_generated_by: str | None

xref: list[str] | None

class bkbit.models.cell_taxonomy.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', 'serialize_by_alias': True, 'strict': False, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_name': 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.cell_taxonomy.ExpressionMatrix(*, id: str, iri: str | None = None, category: list[Literal['https://identifiers.org/brain-bican/vocab/ExpressionMatrix', 'bican:ExpressionMatrix']] = ['bican:ExpressionMatrix'], 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, information_content: float | None = None, equivalent_identifiers: list[str] | None = None, was_derived_from: str | None = None, was_generated_by: str | None = None, content_url: list[str] | None = None, has_variable: list[str] | None = None, matrix_type: ExpressionMatrixType | None = None)[source]

Bases: ProvEntity, NamedThing

A cell-by-gene matrix of molecular measurements. Each row represents a cell and each column represents a gene. May be normalized (X) or raw counts (raw.X).

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/ExpressionMatrix', 'bican:ExpressionMatrix']]

content_url: list[str] | None

deprecated: bool | None

description: str | None

equivalent_identifiers: list[str] | None

full_name: str | None

has_attribute: list[str] | None

has_variable: list[str] | None

id: str

information_content: float | None

iri: str | None

linkml_meta: ClassVar[LinkMLMeta] = LinkMLMeta(root={'from_schema': 'https://w3id.org/brain-bican/cell-taxonomy', 'mixins': ['ProvEntity'], 'slot_usage': {'content_url': {'description': 'URL to the matrix file if the matrix is not embedded directly in the h5ad file.', 'from_schema': 'bican_core', 'in_subset': ['uns', 'data'], 'name': 'content_url', 'range': 'uri'}, 'id': {'description': 'Unique identifier for this expression matrix.', 'from_schema': 'bican_biolink', 'name': 'id', 'range': 'string'}}})

matrix_type: ExpressionMatrixType | None

model_config: ClassVar[ConfigDict] = {'arbitrary_types_allowed': True, 'extra': 'forbid', 'serialize_by_alias': True, 'strict': False, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_name': 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

was_derived_from: str | None

was_generated_by: str | None

xref: list[str] | None

class bkbit.models.cell_taxonomy.ExpressionMatrixType(value)[source]

Bases: str, Enum

An enumeration.

normalized = 'normalized': Matrix contains normalized expression values.

raw_count = 'raw_count': Matrix contains raw counts.

class bkbit.models.cell_taxonomy.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, information_content: float | None = None, equivalent_identifiers: 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

equivalent_identifiers: list[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

information_content: float | 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', 'serialize_by_alias': True, 'strict': False, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_name': 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

Bases: Gene

Represents a single gene. Includes metadata about the gene, such as its molecular type and the genome annotation it was referenced from.

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/GeneAnnotation', 'bican:GeneAnnotation']]

deprecated: bool | None

description: str | None

equivalent_identifiers: list[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

information_content: float | None

iri: str | None

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

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

molecular_type: BioType | str | None

name: str | None

provided_by: list[str] | None

referenced_in: GenomeAnnotation | str

source_id: str | None

symbol: str | None

synonym: list[str] | None

type: list[str] | None

xref: list[str] | None

class bkbit.models.cell_taxonomy.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', 'serialize_by_alias': True, 'strict': False, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_name': True, 'validate_default': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

name: str | None

class bkbit.models.cell_taxonomy.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, information_content: float | None = None, equivalent_identifiers: 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

equivalent_identifiers: list[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

information_content: float | 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', 'serialize_by_alias': True, 'strict': False, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_name': 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.cell_taxonomy.GenomeAnnotation(*, id: str, iri: str | None = None, category: list[Literal['https://identifiers.org/brain-bican/vocab/GenomeAnnotation', 'bican:GenomeAnnotation']] = ['bican:GenomeAnnotation'], 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, information_content: float | None = None, equivalent_identifiers: list[str] | None = None, in_taxon: list[str] | None = None, in_taxon_label: str | None = None, has_biological_sequence: str | None = None, version: str | None = None, digest: list[Checksum | str] | None = None, content_url: list[str] | None = None, authority: AuthorityType | None = None, reference_assembly: GenomeAssembly | str)[source]

Bases: Genome

Represents a genome annotation. Includes metadata about the genome, such as its version and reference assembly.

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.

authority: AuthorityType | None

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

content_url: list[str] | None

deprecated: bool | None

description: str | None

digest: list[Checksum | str] | None

equivalent_identifiers: list[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

information_content: float | None

iri: str | None

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

model_config: ClassVar[ConfigDict] = {'arbitrary_types_allowed': True, 'extra': 'forbid', 'serialize_by_alias': True, 'strict': False, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_name': 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

reference_assembly: GenomeAssembly | str

synonym: list[str] | None

type: list[str] | None

version: str | None

xref: list[str] | None

class bkbit.models.cell_taxonomy.GenomeAssembly(*, id: str, iri: str | None = None, category: list[Literal['https://identifiers.org/brain-bican/vocab/GenomeAssembly', 'bican:GenomeAssembly']] = ['bican:GenomeAssembly'], 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, information_content: float | None = None, equivalent_identifiers: list[str] | None = None, in_taxon: list[str] | None = None, in_taxon_label: str | None = None, version: str | None = None, strain: str | None = None)[source]

Bases: ThingWithTaxon, NamedThing

Represents a genome assembly. A genome assembly is a computational representation of a genome sequence.

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/GenomeAssembly', 'bican:GenomeAssembly']]

deprecated: bool | None

description: str | None

equivalent_identifiers: list[str] | None

full_name: str | None

has_attribute: list[str] | None

id: str

in_taxon: list[str] | None

in_taxon_label: str | None

information_content: float | None

iri: str | None

linkml_meta: ClassVar[LinkMLMeta] = LinkMLMeta(root={'from_schema': 'https://identifiers.org/brain-bican/genome-annotation-schema', 'mixins': ['thing with taxon']})

model_config: ClassVar[ConfigDict] = {'arbitrary_types_allowed': True, 'extra': 'forbid', 'serialize_by_alias': True, 'strict': False, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_name': 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

strain: str | None

synonym: list[str] | None

type: list[str] | None

version: str | None

xref: list[str] | None

class bkbit.models.cell_taxonomy.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', 'serialize_by_alias': True, 'strict': False, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_name': True, 'validate_default': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class bkbit.models.cell_taxonomy.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, information_content: float | None = None, equivalent_identifiers: 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

equivalent_identifiers: list[str] | None

full_name: str | None

has_attribute: list[str] | None

id: str

information_content: float | None

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', 'serialize_by_alias': True, 'strict': False, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_name': 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.cell_taxonomy.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, information_content: float | None = None, equivalent_identifiers: 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

equivalent_identifiers: list[str] | None

format: str | None

full_name: str | None

has_attribute: list[str] | None

id: str

information_content: float | None

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', 'serialize_by_alias': True, 'strict': False, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_name': 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.cell_taxonomy.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.cell_taxonomy.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, 'slot_usage': {'name': {'description': 'genes are typically designated by a short symbol and a full name. We map the symbol to the default display name and use an additional slot for full name', 'name': 'name', 'range': 'symbol type'}}})

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

name: str | None

class bkbit.models.cell_taxonomy.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, information_content: float | None = None, equivalent_identifiers: 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

equivalent_identifiers: list[str] | None

full_name: str | None

has_attribute: list[str] | None

id: str

information_content: float | None

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', 'serialize_by_alias': True, 'strict': False, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_name': 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.cell_taxonomy.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, information_content: float | None = None, equivalent_identifiers: 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

equivalent_identifiers: list[str] | None

full_name: str | None

has_attribute: list[str] | None

id: str

information_content: float | None

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', 'slot_usage': {'category': {'name': 'category', 'required': True}}})

model_config: ClassVar[ConfigDict] = {'arbitrary_types_allowed': True, 'extra': 'forbid', 'serialize_by_alias': True, 'strict': False, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_name': 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.cell_taxonomy.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', 'serialize_by_alias': True, 'strict': False, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_name': True, 'validate_default': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class bkbit.models.cell_taxonomy.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', 'serialize_by_alias': True, 'strict': False, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_name': True, 'validate_default': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class bkbit.models.cell_taxonomy.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, information_content: float | None = None, equivalent_identifiers: 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

equivalent_identifiers: list[str] | None

full_name: str | None

has_attribute: list[str] | None

has_taxonomic_rank: str | None

id: str

information_content: float | None

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'], 'slot_usage': {'has taxonomic rank': {'mappings': ['WIKIDATA:P105'], 'multivalued': False, 'name': 'has taxonomic rank', 'range': 'taxonomic rank'}}, 'values_from': ['NCBITaxon']})

model_config: ClassVar[ConfigDict] = {'arbitrary_types_allowed': True, 'extra': 'forbid', 'serialize_by_alias': True, 'strict': False, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_name': 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.cell_taxonomy.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', 'serialize_by_alias': True, 'strict': False, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_name': 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.cell_taxonomy.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', 'serialize_by_alias': True, 'strict': False, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_name': 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.cell_taxonomy.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, information_content: float | None = None, equivalent_identifiers: 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

equivalent_identifiers: list[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

information_content: float | None

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', 'serialize_by_alias': True, 'strict': False, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_name': 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.cell_taxonomy.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', 'serialize_by_alias': True, 'strict': False, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_name': 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.cell_taxonomy.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, information_content: float | None = None, equivalent_identifiers: 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

equivalent_identifiers: list[str] | None

full_name: str | None

has_attribute: list[str] | None

id: str

information_content: float | None

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', 'serialize_by_alias': True, 'strict': False, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_name': 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.cell_taxonomy.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, information_content: float | None = None, equivalent_identifiers: 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

equivalent_identifiers: list[str] | None

full_name: str | None

has_attribute: list[str] | None

has_parent_parcellation_term: str | None

id: str

information_content: float | None

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', 'serialize_by_alias': True, 'strict': False, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_name': 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.cell_taxonomy.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, information_content: float | None = None, equivalent_identifiers: 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

equivalent_identifiers: list[str] | None

full_name: str | None

has_attribute: list[str] | None

has_parent_parcellation_term_set: str | None

id: str

information_content: float | None

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', 'serialize_by_alias': True, 'strict': False, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_name': 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.cell_taxonomy.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, information_content: float | None = None, equivalent_identifiers: 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

equivalent_identifiers: list[str] | None

full_name: str | None

has_attribute: list[str] | None

id: str

information_content: float | None

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', 'serialize_by_alias': True, 'strict': False, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_name': 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.cell_taxonomy.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, information_content: float | None = None, equivalent_identifiers: 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

equivalent_identifiers: list[str] | None

full_name: str | None

has_attribute: list[str] | None

id: str

information_content: float | None

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', 'serialize_by_alias': True, 'strict': False, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_name': 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.cell_taxonomy.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', 'serialize_by_alias': True, 'strict': False, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_name': True, 'validate_default': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class bkbit.models.cell_taxonomy.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', 'serialize_by_alias': True, 'strict': False, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_name': True, 'validate_default': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class bkbit.models.cell_taxonomy.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, information_content: float | None = None, equivalent_identifiers: 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

equivalent_identifiers: list[str] | None

full_name: str | None

has_attribute: list[str] | None

id: str

information_content: float | None

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', 'serialize_by_alias': True, 'strict': False, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_name': 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.cell_taxonomy.ProvActivity(*, used: str | None = None)[source]

Bases: ConfiguredBaseModel

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.

linkml_meta: ClassVar[LinkMLMeta] = LinkMLMeta(root={'class_uri': 'prov:Activity', 'from_schema': 'https://identifiers.org/brain-bican/bican-prov-schema', 'mixin': True})

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

used: str | None

class bkbit.models.cell_taxonomy.ProvEntity(*, was_derived_from: str | None = None, was_generated_by: str | None = None)[source]

Bases: ConfiguredBaseModel

An entity is a physical, digital, conceptual, or other kind of thing with some fixed aspects; entities may be real or imaginary.

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': 'prov:Entity', 'from_schema': 'https://identifiers.org/brain-bican/bican-prov-schema', 'mixin': True})

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

was_derived_from: str | None

was_generated_by: str | None

class bkbit.models.cell_taxonomy.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', 'serialize_by_alias': True, 'strict': False, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_name': True, 'validate_default': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class bkbit.models.cell_taxonomy.RelativeFrequencyAnalysisResult(*, id: str, iri: str | None = None, category: list[Literal['https://w3id.org/biolink/vocab/RelativeFrequencyAnalysisResult', 'biolink:RelativeFrequencyAnalysisResult']] = ['biolink:RelativeFrequencyAnalysisResult'], 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, information_content: float | None = None, equivalent_identifiers: list[str] | None = None, license: str | None = None, rights: str | None = None, format: str | None = None, creation_date: date | None = None)[source]

Bases: StudyResult

A result of a relative frequency analysis.

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/RelativeFrequencyAnalysisResult', 'biolink:RelativeFrequencyAnalysisResult']]

creation_date: date | None

deprecated: bool | None

description: str | None

equivalent_identifiers: list[str] | None

format: str | None

full_name: str | None

has_attribute: list[str] | None

id: str

information_content: float | None

iri: str | None

license: str | None

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

model_config: ClassVar[ConfigDict] = {'arbitrary_types_allowed': True, 'extra': 'forbid', 'serialize_by_alias': True, 'strict': False, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_name': 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.cell_taxonomy.StudyResult(*, id: str, iri: str | None = None, category: list[Literal['https://w3id.org/biolink/vocab/StudyResult', 'biolink:StudyResult']] = ['biolink:StudyResult'], 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, information_content: float | None = None, equivalent_identifiers: list[str] | None = None, license: str | None = None, rights: str | None = None, format: str | None = None, creation_date: date | None = None)[source]

Bases: InformationContentEntity

A collection of data items from a study that are about a particular study subject or experimental unit (the ‘focus’ of the Result) - optionally with context/provenance metadata that may be relevant to the interpretation of this data as evidence.

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/StudyResult', 'biolink:StudyResult']]

creation_date: date | None

deprecated: bool | None

description: str | None

equivalent_identifiers: list[str] | None

format: str | None

full_name: str | None

has_attribute: list[str] | None

id: str

information_content: float | None

iri: str | None

license: str | None

linkml_meta: ClassVar[LinkMLMeta] = LinkMLMeta(root={'abstract': True, 'class_uri': 'biolink:StudyResult', 'definition_uri': 'https://w3id.org/biolink/vocab/StudyResult', 'from_schema': 'https://w3id.org/biolink/bican-biolink-schema', 'notes': ["The data/metadata included in a Study Result object are typically a subset of data from a larger study data set, that are selected by a curator because they may be useful as evidence for deriving knowledge about a specific focus of the study. The notion of a 'study' here is defined broadly to include any research activity at any scale that is aimed at generating knowledge or hypotheses. This may include a single assay or computational analyses, or a larger scale clinical trial or experimental research investigation."]})

model_config: ClassVar[ConfigDict] = {'arbitrary_types_allowed': True, 'extra': 'forbid', 'serialize_by_alias': True, 'strict': False, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_name': 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.cell_taxonomy.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', 'serialize_by_alias': True, 'strict': False, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_name': True, 'validate_default': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class bkbit.models.cell_taxonomy.SuspensionType(value)[source]

Bases: str, Enum

An enumeration.

cell = 'cell'

na = 'na'

nucleus = 'nucleus'

class bkbit.models.cell_taxonomy.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', 'serialize_by_alias': True, 'strict': False, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_name': True, 'validate_default': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class bkbit.models.cell_taxonomy.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', 'serialize_by_alias': True, 'strict': False, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_name': True, 'validate_default': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class bkbit.models.cell_taxonomy.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, information_content: float | None = None, equivalent_identifiers: 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

equivalent_identifiers: list[str] | None

full_name: str | None

has_attribute: list[str] | None

id: str

information_content: float | None

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', 'serialize_by_alias': True, 'strict': False, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_name': 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