bkbit.models.library_generation module

class bkbit.models.library_generation.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.library_generation.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.library_generation.AgeAtDeathReferencePoint(value)[source]

Bases: str, Enum

An enumeration.

birth = 'birth': birth

conception = 'conception': conception

class bkbit.models.library_generation.AgeAtDeathUnit(value)[source]

Bases: str, Enum

An enumeration.

day = 'day': day

month = 'month': month

year = 'year': year

class bkbit.models.library_generation.AmplifiedCdna(*, id: str, iri: str | None = None, category: list[Literal['https://identifiers.org/brain-bican/vocab/AmplifiedCdna', 'bican:AmplifiedCdna']] = ['bican:AmplifiedCdna'], 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, amplified_cDNA_quantity_ng: float | None = None, amplified_cDNA_result: AmplifiedCdnaRnaAmplificationPassFail | None = None, percent_cdna_longer_than_400bp: float | None = None, pcr_cycles: int | None = None, preparation_date: date | None = None, cdna_amplification_set: str | None = None)[source]

Bases: ProvEntity, MaterialSample

A collection of cDNA molecules derived and amplified from an input barcoded cell sample. These cDNA molecules represent the gene expression of each cell, with all cDNA molecules from a given cell retaining that cell’s unique barcode from the cell barcoding step. This is a necessary step for GEX methods but is not used for ATAC methods.

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.

amplified_cDNA_quantity_ng: float | None

amplified_cDNA_result: AmplifiedCdnaRnaAmplificationPassFail | None

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

cdna_amplification_set: 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

linkml_meta: ClassVar[LinkMLMeta] = LinkMLMeta(root={'exact_mappings': ['NIMP:Amplified%20cDNA'], 'from_schema': 'https://identifiers.org/brain-bican/library-generation-schema', 'in_subset': ['bican', 'library_generation'], 'mixins': ['ProvEntity'], 'slot_usage': {'name': {'description': "Name of a collection of cDNA molecules derived and amplified from an input barcoded_cell_sample. These cDNA molecules represent the gene expression of each cell, with all cDNA molecules from a given cell retaining that cell's unique barcode from the cell barcoding step. This is a necessary step for GEX methods but is not used for ATAC methods.", 'exact_mappings': ['bican:e2606a11-114e-472f-9e05-33f9b6fc3089', 'NIMP:PD-YAAGGG39'], 'local_names': {'NIMP_resource_type': {'local_name_source': 'NIMP_resource_type', 'local_name_value': 'Amplified cDNA'}, 'NIMP_variable_name': {'local_name_source': 'NIMP_variable_name', 'local_name_value': 'amplified_cdna_local_name'}}, 'name': 'name'}, 'was_derived_from': {'description': 'The input barcoded cell sample from which amplified cDNA was derived from.', 'name': 'was_derived_from', 'range': 'BarcodedCellSample'}, 'was_generated_by': {'description': 'The cDNA amplification process from which the amplified cDNA was generated by.', 'name': 'was_generated_by', 'range': 'CdnaAmplification'}, 'xref': {'local_names': {'NIMP_resource_type': {'local_name_source': 'NIMP_resource_type', 'local_name_value': 'Amplified cDNA'}, 'NIMP_variable_name': {'local_name_source': 'NIMP_variable_name', 'local_name_value': 'amplified_cdna_nhash_id'}}, 'name': 'xref'}}})

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

pcr_cycles: int | None

percent_cdna_longer_than_400bp: float | None

preparation_date: date | 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.library_generation.AmplifiedCdnaRnaAmplificationPassFail(value)[source]

Bases: str, Enum

An enumeration.

Fail = 'Fail': The RNA amplification failed the QA/QC

Low_QC = 'Low QC': The RNA amplification low passed the QA/QC

Not_evaluated = 'Not evaluated': Library Prep not evaluated for QA/QC

Pass = 'Pass': The RNA amplification passed the QA/QC

class bkbit.models.library_generation.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.library_generation.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.library_generation.BarcodedCellSample(*, id: str, iri: str | None = None, category: list[Literal['https://identifiers.org/brain-bican/vocab/BarcodedCellSample', 'bican:BarcodedCellSample']] = ['bican:BarcodedCellSample'], 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, number_of_expected_cells: int | None = None, port_well: str | None = None, input_quantity_count: int | None = None, tag_local_name: str | None = None, preparation_date: date | None = None, technique: BarcodedCellSampleTechnique | None = None)[source]

Bases: ProvEntity, MaterialSample

A collection of molecularly barcoded cells. Input will be either dissociated cell sample or enriched cell sample. Cell barcodes are only guaranteed to be unique within this one collection. One dissociated cell sample or enriched cell sample can lead to multiple barcoded cell samples. The sequences of the molecular barcodes are revealed during alignment of the resulting fastq files for the barcoded cell sample. The barcoded cell sample name and the cell level molecular barcode together uniquely identify a single cell.

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

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

input_quantity_count: int | None

iri: str | None

linkml_meta: ClassVar[LinkMLMeta] = LinkMLMeta(root={'exact_mappings': ['NIMP:Barcoded%20Cell%20Sample'], 'from_schema': 'https://identifiers.org/brain-bican/library-generation-schema', 'in_subset': ['bican', 'library_generation'], 'mixins': ['ProvEntity'], 'slot_usage': {'name': {'description': 'Name of a collection of barcoded cells. Input will be either dissociated_cell_sample or enriched_cell_sample. Cell barcodes are only guaranteed to be unique within this one collection. One dissociated_cell_sample or enriched_cell_sample can lead to multiple barcoded_cell_samples.', 'exact_mappings': ['bican:4c0e6380-e53f-4173-a474-d41e836fefe3', 'NIMP:PD-XEMDJF38'], 'local_names': {'NIMP_resource_type': {'local_name_source': 'NIMP_resource_type', 'local_name_value': 'Barcoded Cell Sample'}, 'NIMP_variable_name': {'local_name_source': 'NIMP_variable_name', 'local_name_value': 'barcoded_cell_sample_local_name'}}, 'name': 'name'}, 'was_derived_from': {'description': 'The input dissociated or enriched cell sample(s) from which the barcoded cell sample was derived from.', 'exactly_one_of': [{'range': 'DissociatedCellSample'}, {'range': 'EnrichedCellSample'}], 'multivalued': True, 'name': 'was_derived_from'}, 'was_generated_by': {'description': 'The barcoding process from which the barcoded cell sample is generated from.', 'name': 'was_generated_by', 'range': 'CellBarcoding'}, 'xref': {'local_names': {'NIMP_resource_type': {'local_name_source': 'NIMP_resource_type', 'local_name_value': 'Barcoded Cell Sample'}, 'NIMP_variable_name': {'local_name_source': 'NIMP_variable_name', 'local_name_value': 'barcoded_cell_sample_nhash_id'}}, 'name': 'xref'}}})

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_expected_cells: int | None

port_well: str | None

preparation_date: date | None

provided_by: list[str] | None

synonym: list[str] | None

tag_local_name: str | None

technique: BarcodedCellSampleTechnique | None

type: list[str] | None

was_derived_from: list[str] | None

was_generated_by: str | None

xref: list[str] | None

class bkbit.models.library_generation.BarcodedCellSampleTechnique(value)[source]

Bases: str, Enum

An enumeration.

ATACOnly = 'ATACOnly': ATACOnly

DBiT_Seq = 'DBiT-Seq': DBiT-Seq

Droplet_Paired_Tag = 'Droplet Paired-Tag': Droplet Paired-Tag

GEXOnly = 'GEXOnly': GEXOnly

Multiome = 'Multiome': Multiome

PatchSeq_SmartSeq = 'PatchSeq-SmartSeq': PatchSeq-SmartSeq

Slide_tag_recon = 'Slide-tag_recon': Slide-tag_recon

Slide_tag_std = 'Slide-tag_std': Slide-tag_std

SmartSeq = 'SmartSeq': SmartSeq

snm3C_seq = 'snm3C-seq': snm3C-seq

snmCT_seq = 'snmCT-seq': snmCT-seq

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

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

Bases: ProvEntity, MaterialSample

A thick flat piece of brain tissue obtained by slicing a whole brain, brain hemisphere or subdivision with a blade at regular interval. When multiple brain slabs are obtained from the slicing process, an ordinal is assigned to provide information about the relative positioning of the slabs.

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

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={'exact_mappings': ['NIMP:Slab'], 'from_schema': 'https://identifiers.org/brain-bican/library-generation-schema', 'in_subset': ['bican', 'tissue_specimen'], 'mixins': ['ProvEntity'], 'slot_usage': {'name': {'description': 'The identifier given to the slab by the brain bank.', 'exact_mappings': ['NIMP:PD-WKWKFB34'], 'local_names': {'NIMP_resource_type': {'local_name_source': 'NIMP_resource_type', 'local_name_value': 'Slab'}, 'NIMP_variable_name': {'local_name_source': 'NIMP_variable_name', 'local_name_value': 'slab_local_name'}}, 'name': 'name'}, 'was_derived_from': {'any_of': [{'range': 'Donor'}, {'range': 'BrainSlab'}], 'description': 'The donor from which the brain slab was derived from.', 'name': 'was_derived_from'}, 'xref': {'local_names': {'NIMP_resource_type': {'local_name_source': 'NIMP_resource_type', 'local_name_value': 'Slab'}, 'NIMP_variable_name': {'local_name_source': 'NIMP_variable_name', 'local_name_value': 'slab_nhash_id'}}, 'name': 'xref'}}})

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.library_generation.CdnaAmplification(*, id: str, iri: str | None = None, category: list[Literal['https://identifiers.org/brain-bican/vocab/CdnaAmplification', 'bican:CdnaAmplification']] = ['bican:CdnaAmplification'], 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, used: str | None = None)[source]

Bases: ProvActivity, Procedure

The process of creating a collection of cDNA molecules derived and amplified from an input barcoded cell sample. A large amount of cDNA is needed to have accurate and reliable sequencing detection of gene expression. This process generates multiple copies of each mRNA transcript (expressed gene) within each cell while retaining the cell’s unique barcode from the barcoding step. This is a necessary step for GEX methods but is not used for ATAC methods.

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

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/library-generation-schema', 'in_subset': ['bican', 'library_generation'], 'mixins': ['ProvActivity'], 'slot_usage': {'used': {'description': 'The input barcoded cell sample from which amplified cDNA was derived from.', 'name': 'used', 'range': 'BarcodedCellSample'}}})

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

used: str | None

xref: list[str] | None

class bkbit.models.library_generation.CellBarcoding(*, id: str, iri: str | None = None, category: list[Literal['https://identifiers.org/brain-bican/vocab/CellBarcoding', 'bican:CellBarcoding']] = ['bican:CellBarcoding'], 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, used: list[str] | None = None)[source]

Bases: ProvActivity, Procedure

The process of adding a molecular barcode to individual cells in a sample. The input will be either dissociated cell sample or enriched cell sample. Cell barcodes are only guaranteed to be unique within this one collection. One dissociated cell sample or enriched cell sample can lead to multiple barcoded cell samples.

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

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/library-generation-schema', 'in_subset': ['bican', 'library_generation'], 'mixins': ['ProvActivity'], 'slot_usage': {'used': {'description': 'The input dissociated or enriched cell sample(s) from which the barcoded cell sample was derived from.', 'exactly_one_of': [{'range': 'DissociatedCellSample'}, {'range': 'EnrichedCellSample'}], 'multivalued': True, 'name': 'used'}}})

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

used: list[str] | None

xref: list[str] | None

class bkbit.models.library_generation.CellDissociation(*, id: str, iri: str | None = None, category: list[Literal['https://identifiers.org/brain-bican/vocab/CellDissociation', 'bican:CellDissociation']] = ['bican:CellDissociation'], 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, used: list[str] | None = None)[source]

Bases: ProvActivity, Procedure

The process of generating dissociated cells from an input tissue sample. This process could also introduce a tissue-source barcode (eg cell hashing), allowing mixing of cell dissociation samples at the cell barcoding step.

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

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/library-generation-schema', 'in_subset': ['bican', 'library_generation'], 'mixins': ['ProvActivity'], 'slot_usage': {'used': {'description': 'The input tissue sample(s) from which the dissociated cell sample was derived from.', 'multivalued': True, 'name': 'used', 'range': 'TissueSample'}}})

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

used: list[str] | None

xref: list[str] | None

class bkbit.models.library_generation.CellEnrichment(*, id: str, iri: str | None = None, category: list[Literal['https://identifiers.org/brain-bican/vocab/CellEnrichment', 'bican:CellEnrichment']] = ['bican:CellEnrichment'], 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, used: list[str] | None = None)[source]

Bases: ProvActivity, Procedure

The process of enriching a dissociated cell sample by including or excluding cells of different types based on an enrichment plan using techniques such as fluorescence-activated cell sorting (FACS). This process could also introduce a tissue-source barcode (eg cell hashing), allowing mixing of cell enriched samples at the cell barcoding step.

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

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/library-generation-schema', 'in_subset': ['bican', 'library_generation'], 'mixins': ['ProvActivity'], 'slot_usage': {'used': {'description': 'The input dissociated cell sample(s) from which the enriched cell sample was derived from.', 'multivalued': True, 'name': 'used', 'range': 'DissociatedCellSample'}}})

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

used: list[str] | None

xref: list[str] | None

class bkbit.models.library_generation.CellLabelBarcode(value)[source]

Bases: str, Enum

An enumeration.

CMO301 = 'CMO301': 10x Cell Plex oligo tag for multiplexing tissue sources into a single 10x load.

CMO302 = 'CMO302': 10x Cell Plex oligo tag for multiplexing tissue sources into a single 10x load.

CMO303 = 'CMO303': 10x Cell Plex oligo tag for multiplexing tissue sources into a single 10x load.

CMO304 = 'CMO304': 10x Cell Plex oligo tag for multiplexing tissue sources into a single 10x load.

CMO305 = 'CMO305': 10x Cell Plex oligo tag for multiplexing tissue sources into a single 10x load.

CMO306 = 'CMO306': 10x Cell Plex oligo tag for multiplexing tissue sources into a single 10x load.

CMO307 = 'CMO307': 10x Cell Plex oligo tag for multiplexing tissue sources into a single 10x load.

CMO308 = 'CMO308': 10x Cell Plex oligo tag for multiplexing tissue sources into a single 10x load.

CMO309 = 'CMO309': 10x Cell Plex oligo tag for multiplexing tissue sources into a single 10x load.

CMO310 = 'CMO310': 10x Cell Plex oligo tag for multiplexing tissue sources into a single 10x load.

CMO311 = 'CMO311': 10x Cell Plex oligo tag for multiplexing tissue sources into a single 10x load.

CMO312 = 'CMO312': 10x Cell Plex oligo tag for multiplexing tissue sources into a single 10x load.

number_2nt_001 = '2nt-001': Used in conjunction with Histone antibody to capture and tag separate subcomponents of the epigenome. Allows for pooling of enriched cell samples into a single 10x load.

number_2nt_002 = '2nt-002': Used in conjunction with Histone antibody to capture and tag separate subcomponents of the epigenome. Allows for pooling of enriched cell samples into a single 10x load.

number_2nt_003 = '2nt-003': Used in conjunction with Histone antibody to capture and tag separate subcomponents of the epigenome. Allows for pooling of enriched cell samples into a single 10x load.

number_2nt_004 = '2nt-004': Used in conjunction with Histone antibody to capture and tag separate subcomponents of the epigenome. Allows for pooling of enriched cell samples into a single 10x load.

number_3nt_001 = '3nt-001': Used in conjunction with Histone antibody to capture and tag separate subcomponents of the epigenome. Allows for pooling of enriched cell samples into a single 10x load.

number_3nt_002 = '3nt-002': Used in conjunction with Histone antibody to capture and tag separate subcomponents of the epigenome. Allows for pooling of enriched cell samples into a single 10x load.

number_3nt_003 = '3nt-003': Used in conjunction with Histone antibody to capture and tag separate subcomponents of the epigenome. Allows for pooling of enriched cell samples into a single 10x load.

number_3nt_004 = '3nt-004': Used in conjunction with Histone antibody to capture and tag separate subcomponents of the epigenome. Allows for pooling of enriched cell samples into a single 10x load.

number_3nt_005 = '3nt-005': Used in conjunction with Histone antibody to capture and tag separate subcomponents of the epigenome. Allows for pooling of enriched cell samples into a single 10x load.

number_3nt_006 = '3nt-006': Used in conjunction with Histone antibody to capture and tag separate subcomponents of the epigenome. Allows for pooling of enriched cell samples into a single 10x load.

class bkbit.models.library_generation.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.library_generation.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.library_generation.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].

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.library_generation.DigestType(value)[source]

Bases: str, Enum

An enumeration.

MD5 = 'spdx:checksumAlgorithm_md5'

SHA1 = 'spdx:checksumAlgorithm_sha1'

SHA256 = 'spdx:checksumAlgorithm_sha256'

Bases: ProvEntity, Dataset

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

content_url: list[str] | None

creation_date: date | None

data_type: str | None

deprecated: bool | None

description: str | None

digest: list[Checksum | 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={'from_schema': 'https://identifiers.org/brain-bican/library-generation-schema', 'mixins': ['ProvEntity'], 'slot_usage': {'content_url': {'exact_mappings': ['NIMP:PD-DADALW44'], 'local_names': {'NIMP_resource_type': {'local_name_source': 'NIMP_resource_type', 'local_name_value': 'Library Aliquot'}, 'NIMP_variable_name': {'local_name_source': 'NIMP_variable_name', 'local_name_value': 'nemo_aliquot_fastq_public_url'}}, 'name': 'content_url'}, 'digest': {'description': 'NeMO Aliquot Fastq Public URL', 'name': 'digest'}, 'was_derived_from': {'name': 'was_derived_from', 'range': 'LibraryAliquot'}}})

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

was_derived_from: str | None

was_generated_by: str | None

xref: list[str] | None

class bkbit.models.library_generation.DissectionRoiDelineation(*, id: str, iri: str | None = None, category: list[Literal['https://identifiers.org/brain-bican/vocab/DissectionRoiDelineation', 'bican:DissectionRoiDelineation']] = ['bican:DissectionRoiDelineation'], 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, used: str | None = None)[source]

Bases: ProvActivity, Procedure

The process of outlining a region of interest on a brain slab image to guide the dissection and generation of a tissue sample.

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

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/library-generation-schema', 'in_subset': ['bican', 'library_generation'], 'mixins': ['ProvActivity'], 'slot_usage': {'used': {'description': 'The brain slab that was annotated by the delineation process.', 'name': 'used', 'range': 'BrainSlab'}}})

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

used: str | None

xref: list[str] | None

class bkbit.models.library_generation.DissectionRoiPolygon(*, id: str, iri: str | None = None, category: list[Literal['https://identifiers.org/brain-bican/vocab/DissectionRoiPolygon', 'bican:DissectionRoiPolygon']] = ['bican:DissectionRoiPolygon'], type: list[str] | None = None, name: str | None = None, description: str | None = None, has_attribute: list[str] | None = None, deprecated: bool | None = None, was_derived_from: str | None = None, was_generated_by: str | None = None, xref: list[str] | None = None, annotates: str | None = None)[source]

Bases: ProvEntity, Entity

A polygon annotated on a brain slab image delineating a region of interest (ROI) for a tissue sample dissectioning.

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.

annotates: str | None

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

deprecated: bool | None

description: str | None

has_attribute: list[str] | None

id: str

iri: str | None

linkml_meta: ClassVar[LinkMLMeta] = LinkMLMeta(root={'exact_mappings': ['NIMP:ROI'], 'from_schema': 'https://identifiers.org/brain-bican/library-generation-schema', 'in_subset': ['bican', 'tissue_specimen'], 'mixins': ['ProvEntity'], 'slot_usage': {'name': {'description': 'Name of a polygon annotated on a brain slab image delineating a region of interest (ROI) for a tissue sample dissectioning.', 'exact_mappings': ['NIMP:PD-RPRPTM41'], 'local_names': {'NIMP_resource_type': {'local_name_source': 'NIMP_resource_type', 'local_name_value': 'ROI'}, 'NIMP_variable_name': {'local_name_source': 'NIMP_variable_name', 'local_name_value': 'local_name'}}, 'name': 'name'}, 'was_generated_by': {'description': 'The delineation process from which the dissection ROI polygon was generated by.', 'name': 'was_generated_by', 'range': 'DissectionRoiDelineation'}, 'xref': {'local_names': {'NIMP_resource_type': {'local_name_source': 'NIMP_resource_type', 'local_name_value': 'ROI'}, 'NIMP_variable_name': {'local_name_source': 'NIMP_variable_name', 'local_name_value': 'roi_nhash_id'}}, 'name': 'xref'}}})

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

was_derived_from: str | None

was_generated_by: str | None

xref: list[str] | None

class bkbit.models.library_generation.DissociatedCellSample(*, id: str, iri: str | None = None, category: list[Literal['https://identifiers.org/brain-bican/vocab/DissociatedCellSample', 'bican:DissociatedCellSample']] = ['bican:DissociatedCellSample'], 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, preparation_date: date | None = None, cell_prep_type: DissociatedCellSampleCellPrepType | None = None, cell_label_barcode: CellLabelBarcode | None = None, patched_cell_structure: str | None = None)[source]

Bases: ProvEntity, MaterialSample

A collection of dissociated cells or nuclei derived from dissociation of a tissue sample.

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

cell_label_barcode: CellLabelBarcode | None

cell_prep_type: DissociatedCellSampleCellPrepType | 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

linkml_meta: ClassVar[LinkMLMeta] = LinkMLMeta(root={'exact_mappings': ['NIMP:Dissociated%20Cell%20Sample'], 'from_schema': 'https://identifiers.org/brain-bican/library-generation-schema', 'in_subset': ['bican', 'library_generation'], 'mixins': ['ProvEntity'], 'slot_usage': {'name': {'description': 'Name of a collection of dissociated cells or nuclei derived from dissociation of a tissue sample.', 'exact_mappings': ['bican:65e2c7da-9eb4-45b2-8ccb-d69ef9785ee2', 'NIMP:PD-RQRWHS40'], 'local_names': {'NIMP_resource_type': {'local_name_source': 'NIMP_resource_type', 'local_name_value': 'Dissociated Cell Sample'}, 'NIMP_variable_name': {'local_name_source': 'NIMP_variable_name', 'local_name_value': 'dissociated_cell_sample_local_name'}}, 'name': 'name'}, 'was_derived_from': {'description': 'The input tissue sample(s) from which dissociated cell sample was derived from.', 'multivalued': True, 'name': 'was_derived_from', 'range': 'TissueSample'}, 'was_generated_by': {'description': 'The cell dissociation process from which the dissociated cell sample was generated by.', 'name': 'was_generated_by', 'range': 'CellDissociation'}, 'xref': {'local_names': {'NIMP_resource_type': {'local_name_source': 'NIMP_resource_type', 'local_name_value': 'Dissociated Cell Sample'}, 'NIMP_variable_name': {'local_name_source': 'NIMP_variable_name', 'local_name_value': 'dissociated_cell_sample_nhash_id'}}, 'name': 'xref'}}})

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

patched_cell_structure: str | None

preparation_date: date | 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.library_generation.DissociatedCellSampleCellPrepType(value)[source]

Bases: str, Enum

An enumeration.

Cells = 'Cells': isolated whole cells

Nuclei = 'Nuclei': isolated nuclei

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

Bases: ProvEntity, ThingWithTaxon, PhysicalEntity

A person or organism that is the source of a biological sample for scientific study. Many biological samples are generated from a single donor.

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

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={'exact_mappings': ['NIMP:Donor'], 'from_schema': 'https://identifiers.org/brain-bican/library-generation-schema', 'mixins': ['thing with taxon', 'ProvEntity']})

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.library_generation.EnrichedCellSample(*, id: str, iri: str | None = None, category: list[Literal['https://identifiers.org/brain-bican/vocab/EnrichedCellSample', 'bican:EnrichedCellSample']] = ['bican:EnrichedCellSample'], 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, preparation_date: date | None = None, enrichment_population: str | None = None, cell_label_barcode: CellLabelBarcode | None = None, histone_modification_marker: str | None = None)[source]

Bases: ProvEntity, MaterialSample

A collection of enriched cells or nuclei after enrichment process, usually via fluorescence-activated cell sorting (FACS) using the enrichment plan, is applied to dissociated cell sample.

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

cell_label_barcode: CellLabelBarcode | None

deprecated: bool | None

description: str | None

enrichment_population: str | None

equivalent_identifiers: list[str] | None

full_name: str | None

has_attribute: list[str] | None

histone_modification_marker: str | None

id: str

information_content: float | None

iri: str | None

linkml_meta: ClassVar[LinkMLMeta] = LinkMLMeta(root={'exact_mappings': ['NIMP:Enriched%20Cell%20Sample'], 'from_schema': 'https://identifiers.org/brain-bican/library-generation-schema', 'in_subset': ['bican', 'library_generation'], 'mixins': ['ProvEntity'], 'slot_usage': {'name': {'description': 'Name of collection of enriched cells or nuclei after enrichment process (usually via FACS using the Enrichment Plan) applied to dissociated_cell_sample.', 'exact_mappings': ['bican:bb3fc701-23a7-45c1-890d-7471730e0ec1', 'NIMP:PD-BERWTM41'], 'local_names': {'NIMP_resource_type': {'local_name_source': 'NIMP_resource_type', 'local_name_value': 'Enriched Cell Sample'}, 'NIMP_variable_name': {'local_name_source': 'NIMP_variable_name', 'local_name_value': 'enriched_cell_sample_local_name'}}, 'name': 'name'}, 'was_derived_from': {'description': 'The dissociated or enriched cell sample(s) from which the enriched cell sample was derived from.', 'exactly_one_of': [{'range': 'DissociatedCellSample'}, {'range': 'EnrichedCellSample'}], 'multivalued': True, 'name': 'was_derived_from'}, 'was_generated_by': {'any_of': [{'range': 'CellEnrichment'}, {'range': 'EnrichedCellSampleSplitting'}], 'description': 'The cell enrichment or sample splitting process from which the enriched cell sample was generated by.', 'name': 'was_generated_by'}, 'xref': {'local_names': {'NIMP_resource_type': {'local_name_source': 'NIMP_resource_type', 'local_name_value': 'Enriched Cell Sample'}, 'NIMP_variable_name': {'local_name_source': 'NIMP_variable_name', 'local_name_value': 'enriched_cell_sample_nhash_id'}}, 'name': 'xref'}}})

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

preparation_date: date | 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.library_generation.EnrichedCellSampleSplitting(*, id: str, iri: str | None = None, category: list[Literal['https://identifiers.org/brain-bican/vocab/EnrichedCellSampleSplitting', 'bican:EnrichedCellSampleSplitting']] = ['bican:EnrichedCellSampleSplitting'], 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, used: str | None = None)[source]

Bases: ProvActivity, Procedure

The process of splitting an enriched cell sample into several portions. Each portion may be used by the same or different groups for different scientific studies.

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

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/library-generation-schema', 'in_subset': ['bican', 'library_generation'], 'mixins': ['ProvActivity'], 'slot_usage': {'used': {'description': 'The enrichment cell sample splitting process from which the enriched cell sample was generated by.', 'name': 'used', 'range': 'EnrichedCellSample'}}})

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

used: str | None

xref: list[str] | None

class bkbit.models.library_generation.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.library_generation.FastqFileAlignmentStatus(value)[source]

Bases: str, Enum

An enumeration.

number_1 = '1': Pass

number_2 = '2': Pass-Flag

number_3 = '3': Fail_Withhold

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

class bkbit.models.library_generation.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.library_generation.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.library_generation.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.library_generation.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.library_generation.Library(*, id: str, iri: str | None = None, category: list[Literal['https://identifiers.org/brain-bican/vocab/Library', 'bican:Library']] = ['bican:Library'], 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, average_size_bp: int | None = None, concentration_nm: float | None = None, library_result: LibraryPrepPassFail | None = None, quantity_fmol: float | None = None, library_quantity_ng: float | None = None, r1_r2_index: LibraryR1R2Index | None = None, technique: LibraryTechnique | None = None, preparation_date: date | None = None, input_ng: float | None = None, prep_set: str | None = None)[source]

Bases: ProvEntity, MaterialSample

A collection of fragmented and barcode-indexed DNA molecules for sequencing. An index or barcode is typically introduced to enable identification of library origin to allow libraries to be pooled together for sequencing.

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.

average_size_bp: int | None

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

concentration_nm: float | 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

input_ng: float | None

iri: str | None

library_quantity_ng: float | None

library_result: LibraryPrepPassFail | None

linkml_meta: ClassVar[LinkMLMeta] = LinkMLMeta(root={'exact_mappings': ['NIMP:Library'], 'from_schema': 'https://identifiers.org/brain-bican/library-generation-schema', 'in_subset': ['bican', 'library_generation'], 'mixins': ['ProvEntity'], 'slot_usage': {'name': {'description': 'Name of a library, which is a collection of fragmented and barcode-indexed DNA molecules for sequencing. An index or barcode is typically introduced to enable identification of library origin to allow libraries to be pooled together for sequencing.', 'exact_mappings': ['bican:f717e254-3630-4342-be7b-4d56376e7afe', 'NIMP:PD-AJJUCC35'], 'local_names': {'NIMP_resource_type': {'local_name_source': 'NIMP_resource_type', 'local_name_value': 'Library'}, 'NIMP_variable_name': {'local_name_source': 'NIMP_variable_name', 'local_name_value': 'library_local_name'}}, 'name': 'name'}, 'was_derived_from': {'any_of': [{'range': 'BarcodedCellSample'}, {'range': 'AmplifiedCdna'}], 'description': 'The input barcoded cell sample or amplified cDNA from which the library was derived from.', 'name': 'was_derived_from'}, 'was_generated_by': {'description': 'The library construction process from which the library was generated by.', 'name': 'was_generated_by', 'range': 'LibraryConstruction'}, 'xref': {'local_names': {'NIMP_resource_type': {'local_name_source': 'NIMP_resource_type', 'local_name_value': 'Library'}, 'NIMP_variable_name': {'local_name_source': 'NIMP_variable_name', 'local_name_value': 'library_nhash_id'}}, 'name': 'xref'}}})

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

prep_set: str | None

preparation_date: date | None

provided_by: list[str] | None

quantity_fmol: float | None

r1_r2_index: LibraryR1R2Index | None

synonym: list[str] | None

technique: LibraryTechnique | None

type: list[str] | None

was_derived_from: str | None

was_generated_by: str | None

xref: list[str] | None

class bkbit.models.library_generation.LibraryAliquot(*, id: str, iri: str | None = None, category: list[Literal['https://identifiers.org/brain-bican/vocab/LibraryAliquot', 'bican:LibraryAliquot']] = ['bican:LibraryAliquot'], 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, fastq_file_alignment_status: FastqFileAlignmentStatus | None = None)[source]

Bases: ProvEntity, MaterialSample

One library in the library pool. Each library aliquot in a library pool will have a unique R1/R2 index to allow for sequencing together then separating the sequencing output by originating library aliquot through the process of demultiplexing. The resulting demultiplexed fastq files will include the library aliquot name. A given library may produce multiple library aliquots, which is done in the case of resequencing. Each library aliquot will produce a set of fastq files.

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

deprecated: bool | None

description: str | None

equivalent_identifiers: list[str] | None

fastq_file_alignment_status: FastqFileAlignmentStatus | 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={'exact_mappings': ['NIMP:Library%20Aliquot'], 'from_schema': 'https://identifiers.org/brain-bican/library-generation-schema', 'in_subset': ['bican', 'library_generation'], 'mixins': ['ProvEntity'], 'slot_usage': {'name': {'description': 'One library in the library pool. Each Library_aliquot_name in a library pool will have a unique R1/R2 index to allow for sequencing together then separating the sequencing output by originating library aliquot through the process of demultiplexing. The resulting demultiplexed fastq files will include the library_aliquot_name.', 'exact_mappings': ['bican:34191bad-d167-4335-8224-ade897d3728e', 'NIMP:PD-XCXCCC35'], 'local_names': {'NIMP_resource_type': {'local_name_source': 'NIMP_resource_type', 'local_name_value': 'Library Aliquot'}, 'NIMP_variable_name': {'local_name_source': 'NIMP_variable_name', 'local_name_value': 'library_aliquot_local_name'}}, 'name': 'name'}, 'was_derived_from': {'description': 'The input library from which the library aliquot was derived from.', 'name': 'was_derived_from', 'range': 'Library'}, 'xref': {'local_names': {'NIMP_resource_type': {'local_name_source': 'NIMP_resource_type', 'local_name_value': 'Library Aliquot'}, 'NIMP_variable_name': {'local_name_source': 'NIMP_variable_name', 'local_name_value': 'library_aliquot_nhash_id'}}, 'name': 'xref'}}})

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.library_generation.LibraryConstruction(*, id: str, iri: str | None = None, category: list[Literal['https://identifiers.org/brain-bican/vocab/LibraryConstruction', 'bican:LibraryConstruction']] = ['bican:LibraryConstruction'], 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, used: str | None = None)[source]

Bases: ProvActivity, Procedure

The process of constructing a library from input material (such as amplified cDNA or barcoded cell sample) derived from one or more cell samples. cDNA is fragmented into smaller pieces appropriate for sequencing and at the same time a library index barcode is incorporated to enable identification of library origin, allowing libraries to be pooled together for sequencing.

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

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/library-generation-schema', 'in_subset': ['bican', 'library_generation'], 'mixins': ['ProvActivity'], 'slot_usage': {'used': {'any_of': [{'range': 'BarcodedCellSample'}, {'range': 'AmplifiedCdna'}], 'description': 'The input barcoded cell sample or amplified cDNA from which the library was derived from.', 'name': 'used'}}})

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

used: str | None

xref: list[str] | None

class bkbit.models.library_generation.LibraryPool(*, id: str, iri: str | None = None, category: list[Literal['https://identifiers.org/brain-bican/vocab/LibraryPool', 'bican:LibraryPool']] = ['bican:LibraryPool'], 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, local_tube_id: str | None = None, preparation_date: date | None = None, tube_barcode: str | None = None, flowcell: str | None = None)[source]

Bases: ProvEntity, MaterialSample

A library pool is made up of library aliquots from multiple libraries. Each library aliquot in a library pool will have a unique R1/R2 index to allow for sequencing together then separating the sequencing output by originating library aliquot through the process of demultiplexing.

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

deprecated: bool | None

description: str | None

equivalent_identifiers: list[str] | None

flowcell: 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={'exact_mappings': ['NIMP:Library%20Pool'], 'from_schema': 'https://identifiers.org/brain-bican/library-generation-schema', 'in_subset': ['bican', 'library_generation'], 'mixins': ['ProvEntity'], 'slot_usage': {'name': {'description': 'Library lab\'s library pool name. For some labs this may be the same as "Library pool tube local name". Other labs distinguish between the local tube label of the library pool and the library pool name provided to SeqCore for tracking. Local Pool Name is used to communicate sequencing status between SeqCore and Library Labs.', 'exact_mappings': ['bican:29e0578b-6427-4c93-b29b-bde27fbadeec', 'NIMP:PD-KKIAPA48'], 'local_names': {'NIMP_resource_type': {'local_name_source': 'NIMP_resource_type', 'local_name_value': 'Library Pool'}, 'NIMP_variable_name': {'local_name_source': 'NIMP_variable_name', 'local_name_value': 'library_pool_local_name'}}, 'name': 'name'}, 'was_derived_from': {'description': 'The input aliquot(s) from which the library pool was derived from.', 'multivalued': True, 'name': 'was_derived_from', 'range': 'LibraryAliquot'}, 'was_generated_by': {'description': 'The pooling process from which the library pool was generated by.', 'name': 'was_generated_by', 'range': 'LibraryPooling'}, 'xref': {'local_names': {'NIMP_resource_type': {'local_name_source': 'NIMP_resource_type', 'local_name_value': 'Library Pool'}, 'NIMP_variable_name': {'local_name_source': 'NIMP_variable_name', 'local_name_value': 'library_pool_nhash_id'}}, 'name': 'xref'}}})

local_tube_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

preparation_date: date | None

provided_by: list[str] | None

synonym: list[str] | None

tube_barcode: str | None

type: list[str] | None

was_derived_from: list[str] | None

was_generated_by: str | None

xref: list[str] | None

class bkbit.models.library_generation.LibraryPooling(*, id: str, iri: str | None = None, category: list[Literal['https://identifiers.org/brain-bican/vocab/LibraryPooling', 'bican:LibraryPooling']] = ['bican:LibraryPooling'], 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, used: list[str] | None = None)[source]

Bases: ProvActivity, Procedure

The process of constructing of a library pool by combining library aliquots from a set of input libraries. Each library aliquot in a library pool will have a unique R1/R2 index to allow for sequencing together then separating the sequencing output by originating library aliquot through the process of demultiplexing.

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

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/library-generation-schema', 'in_subset': ['bican', 'library_generation'], 'mixins': ['ProvActivity'], 'slot_usage': {'used': {'description': 'The input aliquot(s) from which the library pool was derived from.', 'multivalued': True, 'name': 'used', 'range': 'LibraryAliquot'}}})

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

used: list[str] | None

xref: list[str] | None

class bkbit.models.library_generation.LibraryPrepPassFail(value)[source]

Bases: str, Enum

An enumeration.

Fail = 'Fail': Library Prep failed the QA/QC

Low_QC = 'Low QC': Library Prep low passed the QA/QC

Not_evaluated = 'Not evaluated': Library Prep not evaluated for QA/QC

Pass = 'Pass': Library Prep passed the QA/QC

class bkbit.models.library_generation.LibraryR1R2Index(value)[source]

Bases: str, Enum

An enumeration.

SI_NA_A1 = 'SI-NA-A1': 10x Single Index N Set A. Used with 10xATAC_v2.0 and 10xMultiome;ATAC

SI_NA_A10 = 'SI-NA-A10': 10x Single Index N Set A. Used with 10xATAC_v2.0 and 10xMultiome;ATAC

SI_NA_A11 = 'SI-NA-A11': 10x Single Index N Set A. Used with 10xATAC_v2.0 and 10xMultiome;ATAC

SI_NA_A12 = 'SI-NA-A12': 10x Single Index N Set A. Used with 10xATAC_v2.0 and 10xMultiome;ATAC

SI_NA_A2 = 'SI-NA-A2': 10x Single Index N Set A. Used with 10xATAC_v2.0 and 10xMultiome;ATAC

SI_NA_A3 = 'SI-NA-A3': 10x Single Index N Set A. Used with 10xATAC_v2.0 and 10xMultiome;ATAC

SI_NA_A4 = 'SI-NA-A4': 10x Single Index N Set A. Used with 10xATAC_v2.0 and 10xMultiome;ATAC

SI_NA_A5 = 'SI-NA-A5': 10x Single Index N Set A. Used with 10xATAC_v2.0 and 10xMultiome;ATAC

SI_NA_A6 = 'SI-NA-A6': 10x Single Index N Set A. Used with 10xATAC_v2.0 and 10xMultiome;ATAC

SI_NA_A7 = 'SI-NA-A7': 10x Single Index N Set A. Used with 10xATAC_v2.0 and 10xMultiome;ATAC

SI_NA_A8 = 'SI-NA-A8': 10x Single Index N Set A. Used with 10xATAC_v2.0 and 10xMultiome;ATAC

SI_NA_A9 = 'SI-NA-A9': 10x Single Index N Set A. Used with 10xATAC_v2.0 and 10xMultiome;ATAC

SI_NA_B1 = 'SI-NA-B1': 10x Single Index N Set A. Used with 10xATAC_v2.0 and 10xMultiome;ATAC

SI_NA_B10 = 'SI-NA-B10': 10x Single Index N Set A. Used with 10xATAC_v2.0 and 10xMultiome;ATAC

SI_NA_B11 = 'SI-NA-B11': 10x Single Index N Set A. Used with 10xATAC_v2.0 and 10xMultiome;ATAC

SI_NA_B12 = 'SI-NA-B12': 10x Single Index N Set A. Used with 10xATAC_v2.0 and 10xMultiome;ATAC

SI_NA_B2 = 'SI-NA-B2': 10x Single Index N Set A. Used with 10xATAC_v2.0 and 10xMultiome;ATAC

SI_NA_B3 = 'SI-NA-B3': 10x Single Index N Set A. Used with 10xATAC_v2.0 and 10xMultiome;ATAC

SI_NA_B4 = 'SI-NA-B4': 10x Single Index N Set A. Used with 10xATAC_v2.0 and 10xMultiome;ATAC

SI_NA_B5 = 'SI-NA-B5': 10x Single Index N Set A. Used with 10xATAC_v2.0 and 10xMultiome;ATAC

SI_NA_B6 = 'SI-NA-B6': 10x Single Index N Set A. Used with 10xATAC_v2.0 and 10xMultiome;ATAC

SI_NA_B7 = 'SI-NA-B7': 10x Single Index N Set A. Used with 10xATAC_v2.0 and 10xMultiome;ATAC

SI_NA_B8 = 'SI-NA-B8': 10x Single Index N Set A. Used with 10xATAC_v2.0 and 10xMultiome;ATAC

SI_NA_B9 = 'SI-NA-B9': 10x Single Index N Set A. Used with 10xATAC_v2.0 and 10xMultiome;ATAC

SI_NA_C1 = 'SI-NA-C1': 10x Single Index N Set A. Used with 10xATAC_v2.0 and 10xMultiome;ATAC

SI_NA_C10 = 'SI-NA-C10': 10x Single Index N Set A. Used with 10xATAC_v2.0 and 10xMultiome;ATAC

SI_NA_C11 = 'SI-NA-C11': 10x Single Index N Set A. Used with 10xATAC_v2.0 and 10xMultiome;ATAC

SI_NA_C12 = 'SI-NA-C12': 10x Single Index N Set A. Used with 10xATAC_v2.0 and 10xMultiome;ATAC

SI_NA_C2 = 'SI-NA-C2': 10x Single Index N Set A. Used with 10xATAC_v2.0 and 10xMultiome;ATAC

SI_NA_C3 = 'SI-NA-C3': 10x Single Index N Set A. Used with 10xATAC_v2.0 and 10xMultiome;ATAC

SI_NA_C4 = 'SI-NA-C4': 10x Single Index N Set A. Used with 10xATAC_v2.0 and 10xMultiome;ATAC

SI_NA_C5 = 'SI-NA-C5': 10x Single Index N Set A. Used with 10xATAC_v2.0 and 10xMultiome;ATAC

SI_NA_C6 = 'SI-NA-C6': 10x Single Index N Set A. Used with 10xATAC_v2.0 and 10xMultiome;ATAC

SI_NA_C7 = 'SI-NA-C7': 10x Single Index N Set A. Used with 10xATAC_v2.0 and 10xMultiome;ATAC

SI_NA_C8 = 'SI-NA-C8': 10x Single Index N Set A. Used with 10xATAC_v2.0 and 10xMultiome;ATAC

SI_NA_C9 = 'SI-NA-C9': 10x Single Index N Set A. Used with 10xATAC_v2.0 and 10xMultiome;ATAC

SI_NA_D1 = 'SI-NA-D1': 10x Single Index N Set A. Used with 10xATAC_v2.0 and 10xMultiome;ATAC

SI_NA_D10 = 'SI-NA-D10': 10x Single Index N Set A. Used with 10xATAC_v2.0 and 10xMultiome;ATAC

SI_NA_D11 = 'SI-NA-D11': 10x Single Index N Set A. Used with 10xATAC_v2.0 and 10xMultiome;ATAC

SI_NA_D12 = 'SI-NA-D12': 10x Single Index N Set A. Used with 10xATAC_v2.0 and 10xMultiome;ATAC

SI_NA_D2 = 'SI-NA-D2': 10x Single Index N Set A. Used with 10xATAC_v2.0 and 10xMultiome;ATAC

SI_NA_D3 = 'SI-NA-D3': 10x Single Index N Set A. Used with 10xATAC_v2.0 and 10xMultiome;ATAC

SI_NA_D4 = 'SI-NA-D4': 10x Single Index N Set A. Used with 10xATAC_v2.0 and 10xMultiome;ATAC

SI_NA_D5 = 'SI-NA-D5': 10x Single Index N Set A. Used with 10xATAC_v2.0 and 10xMultiome;ATAC

SI_NA_D6 = 'SI-NA-D6': 10x Single Index N Set A. Used with 10xATAC_v2.0 and 10xMultiome;ATAC

SI_NA_D7 = 'SI-NA-D7': 10x Single Index N Set A. Used with 10xATAC_v2.0 and 10xMultiome;ATAC

SI_NA_D8 = 'SI-NA-D8': 10x Single Index N Set A. Used with 10xATAC_v2.0 and 10xMultiome;ATAC

SI_NA_D9 = 'SI-NA-D9': 10x Single Index N Set A. Used with 10xATAC_v2.0 and 10xMultiome;ATAC

SI_NA_E1 = 'SI-NA-E1': 10x Single Index N Set A. Used with 10xATAC_v2.0 and 10xMultiome;ATAC

SI_NA_E10 = 'SI-NA-E10': 10x Single Index N Set A. Used with 10xATAC_v2.0 and 10xMultiome;ATAC

SI_NA_E11 = 'SI-NA-E11': 10x Single Index N Set A. Used with 10xATAC_v2.0 and 10xMultiome;ATAC

SI_NA_E12 = 'SI-NA-E12': 10x Single Index N Set A. Used with 10xATAC_v2.0 and 10xMultiome;ATAC

SI_NA_E2 = 'SI-NA-E2': 10x Single Index N Set A. Used with 10xATAC_v2.0 and 10xMultiome;ATAC

SI_NA_E3 = 'SI-NA-E3': 10x Single Index N Set A. Used with 10xATAC_v2.0 and 10xMultiome;ATAC

SI_NA_E4 = 'SI-NA-E4': 10x Single Index N Set A. Used with 10xATAC_v2.0 and 10xMultiome;ATAC

SI_NA_E5 = 'SI-NA-E5': 10x Single Index N Set A. Used with 10xATAC_v2.0 and 10xMultiome;ATAC

SI_NA_E6 = 'SI-NA-E6': 10x Single Index N Set A. Used with 10xATAC_v2.0 and 10xMultiome;ATAC

SI_NA_E7 = 'SI-NA-E7': 10x Single Index N Set A. Used with 10xATAC_v2.0 and 10xMultiome;ATAC

SI_NA_E8 = 'SI-NA-E8': 10x Single Index N Set A. Used with 10xATAC_v2.0 and 10xMultiome;ATAC

SI_NA_E9 = 'SI-NA-E9': 10x Single Index N Set A. Used with 10xATAC_v2.0 and 10xMultiome;ATAC

SI_NA_F1 = 'SI-NA-F1': 10x Single Index N Set A. Used with 10xATAC_v2.0 and 10xMultiome;ATAC

SI_NA_F10 = 'SI-NA-F10': 10x Single Index N Set A. Used with 10xATAC_v2.0 and 10xMultiome;ATAC

SI_NA_F11 = 'SI-NA-F11': 10x Single Index N Set A. Used with 10xATAC_v2.0 and 10xMultiome;ATAC

SI_NA_F12 = 'SI-NA-F12': 10x Single Index N Set A. Used with 10xATAC_v2.0 and 10xMultiome;ATAC

SI_NA_F2 = 'SI-NA-F2': 10x Single Index N Set A. Used with 10xATAC_v2.0 and 10xMultiome;ATAC

SI_NA_F3 = 'SI-NA-F3': 10x Single Index N Set A. Used with 10xATAC_v2.0 and 10xMultiome;ATAC

SI_NA_F4 = 'SI-NA-F4': 10x Single Index N Set A. Used with 10xATAC_v2.0 and 10xMultiome;ATAC

SI_NA_F5 = 'SI-NA-F5': 10x Single Index N Set A. Used with 10xATAC_v2.0 and 10xMultiome;ATAC

SI_NA_F6 = 'SI-NA-F6': 10x Single Index N Set A. Used with 10xATAC_v2.0 and 10xMultiome;ATAC

SI_NA_F7 = 'SI-NA-F7': 10x Single Index N Set A. Used with 10xATAC_v2.0 and 10xMultiome;ATAC

SI_NA_F8 = 'SI-NA-F8': 10x Single Index N Set A. Used with 10xATAC_v2.0 and 10xMultiome;ATAC

SI_NA_F9 = 'SI-NA-F9': 10x Single Index N Set A. Used with 10xATAC_v2.0 and 10xMultiome;ATAC

SI_NA_G1 = 'SI-NA-G1': 10x Single Index N Set A. Used with 10xATAC_v2.0 and 10xMultiome;ATAC

SI_NA_G10 = 'SI-NA-G10': 10x Single Index N Set A. Used with 10xATAC_v2.0 and 10xMultiome;ATAC

SI_NA_G11 = 'SI-NA-G11': 10x Single Index N Set A. Used with 10xATAC_v2.0 and 10xMultiome;ATAC

SI_NA_G12 = 'SI-NA-G12': 10x Single Index N Set A. Used with 10xATAC_v2.0 and 10xMultiome;ATAC

SI_NA_G2 = 'SI-NA-G2': 10x Single Index N Set A. Used with 10xATAC_v2.0 and 10xMultiome;ATAC

SI_NA_G3 = 'SI-NA-G3': 10x Single Index N Set A. Used with 10xATAC_v2.0 and 10xMultiome;ATAC

SI_NA_G4 = 'SI-NA-G4': 10x Single Index N Set A. Used with 10xATAC_v2.0 and 10xMultiome;ATAC

SI_NA_G5 = 'SI-NA-G5': 10x Single Index N Set A. Used with 10xATAC_v2.0 and 10xMultiome;ATAC

SI_NA_G6 = 'SI-NA-G6': 10x Single Index N Set A. Used with 10xATAC_v2.0 and 10xMultiome;ATAC

SI_NA_G7 = 'SI-NA-G7': 10x Single Index N Set A. Used with 10xATAC_v2.0 and 10xMultiome;ATAC

SI_NA_G8 = 'SI-NA-G8': 10x Single Index N Set A. Used with 10xATAC_v2.0 and 10xMultiome;ATAC

SI_NA_G9 = 'SI-NA-G9': 10x Single Index N Set A. Used with 10xATAC_v2.0 and 10xMultiome;ATAC

SI_NA_H1 = 'SI-NA-H1': 10x Single Index N Set A. Used with 10xATAC_v2.0 and 10xMultiome;ATAC

SI_NA_H10 = 'SI-NA-H10': 10x Single Index N Set A. Used with 10xATAC_v2.0 and 10xMultiome;ATAC

SI_NA_H11 = 'SI-NA-H11': 10x Single Index N Set A. Used with 10xATAC_v2.0 and 10xMultiome;ATAC

SI_NA_H12 = 'SI-NA-H12': 10x Single Index N Set A. Used with 10xATAC_v2.0 and 10xMultiome;ATAC

SI_NA_H2 = 'SI-NA-H2': 10x Single Index N Set A. Used with 10xATAC_v2.0 and 10xMultiome;ATAC

SI_NA_H3 = 'SI-NA-H3': 10x Single Index N Set A. Used with 10xATAC_v2.0 and 10xMultiome;ATAC

SI_NA_H4 = 'SI-NA-H4': 10x Single Index N Set A. Used with 10xATAC_v2.0 and 10xMultiome;ATAC

SI_NA_H5 = 'SI-NA-H5': 10x Single Index N Set A. Used with 10xATAC_v2.0 and 10xMultiome;ATAC

SI_NA_H6 = 'SI-NA-H6': 10x Single Index N Set A. Used with 10xATAC_v2.0 and 10xMultiome;ATAC

SI_NA_H7 = 'SI-NA-H7': 10x Single Index N Set A. Used with 10xATAC_v2.0 and 10xMultiome;ATAC

SI_NA_H8 = 'SI-NA-H8': 10x Single Index N Set A. Used with 10xATAC_v2.0 and 10xMultiome;ATAC

SI_NA_H9 = 'SI-NA-H9': 10x Single Index N Set A. Used with 10xATAC_v2.0 and 10xMultiome;ATAC

SI_NN_A1 = 'SI-NN-A1': 10x Dual Index NN Set A. Used with 10xV3.1_CellPlex;GEX and 10xV3.1-HT_CellPlex;GEX

SI_NN_A10 = 'SI-NN-A10': 10x Dual Index NN Set A. Used with 10xV3.1_CellPlex;GEX and 10xV3.1-HT_CellPlex;GEX

SI_NN_A11 = 'SI-NN-A11': 10x Dual Index NN Set A. Used with 10xV3.1_CellPlex;GEX and 10xV3.1-HT_CellPlex;GEX

SI_NN_A12 = 'SI-NN-A12': 10x Dual Index NN Set A. Used with 10xV3.1_CellPlex;GEX and 10xV3.1-HT_CellPlex;GEX

SI_NN_A2 = 'SI-NN-A2': 10x Dual Index NN Set A. Used with 10xV3.1_CellPlex;GEX and 10xV3.1-HT_CellPlex;GEX

SI_NN_A3 = 'SI-NN-A3': 10x Dual Index NN Set A. Used with 10xV3.1_CellPlex;GEX and 10xV3.1-HT_CellPlex;GEX

SI_NN_A4 = 'SI-NN-A4': 10x Dual Index NN Set A. Used with 10xV3.1_CellPlex;GEX and 10xV3.1-HT_CellPlex;GEX

SI_NN_A5 = 'SI-NN-A5': 10x Dual Index NN Set A. Used with 10xV3.1_CellPlex;GEX and 10xV3.1-HT_CellPlex;GEX

SI_NN_A6 = 'SI-NN-A6': 10x Dual Index NN Set A. Used with 10xV3.1_CellPlex;GEX and 10xV3.1-HT_CellPlex;GEX

SI_NN_A7 = 'SI-NN-A7': 10x Dual Index NN Set A. Used with 10xV3.1_CellPlex;GEX and 10xV3.1-HT_CellPlex;GEX

SI_NN_A8 = 'SI-NN-A8': 10x Dual Index NN Set A. Used with 10xV3.1_CellPlex;GEX and 10xV3.1-HT_CellPlex;GEX

SI_NN_A9 = 'SI-NN-A9': 10x Dual Index NN Set A. Used with 10xV3.1_CellPlex;GEX and 10xV3.1-HT_CellPlex;GEX

SI_NN_B1 = 'SI-NN-B1': 10x Dual Index NN Set A. Used with 10xV3.1_CellPlex;GEX and 10xV3.1-HT_CellPlex;GEX

SI_NN_B10 = 'SI-NN-B10': 10x Dual Index NN Set A. Used with 10xV3.1_CellPlex;GEX and 10xV3.1-HT_CellPlex;GEX

SI_NN_B11 = 'SI-NN-B11': 10x Dual Index NN Set A. Used with 10xV3.1_CellPlex;GEX and 10xV3.1-HT_CellPlex;GEX

SI_NN_B12 = 'SI-NN-B12': 10x Dual Index NN Set A. Used with 10xV3.1_CellPlex;GEX and 10xV3.1-HT_CellPlex;GEX

SI_NN_B2 = 'SI-NN-B2': 10x Dual Index NN Set A. Used with 10xV3.1_CellPlex;GEX and 10xV3.1-HT_CellPlex;GEX

SI_NN_B3 = 'SI-NN-B3': 10x Dual Index NN Set A. Used with 10xV3.1_CellPlex;GEX and 10xV3.1-HT_CellPlex;GEX

SI_NN_B4 = 'SI-NN-B4': 10x Dual Index NN Set A. Used with 10xV3.1_CellPlex;GEX and 10xV3.1-HT_CellPlex;GEX

SI_NN_B5 = 'SI-NN-B5': 10x Dual Index NN Set A. Used with 10xV3.1_CellPlex;GEX and 10xV3.1-HT_CellPlex;GEX

SI_NN_B6 = 'SI-NN-B6': 10x Dual Index NN Set A. Used with 10xV3.1_CellPlex;GEX and 10xV3.1-HT_CellPlex;GEX

SI_NN_B7 = 'SI-NN-B7': 10x Dual Index NN Set A. Used with 10xV3.1_CellPlex;GEX and 10xV3.1-HT_CellPlex;GEX

SI_NN_B8 = 'SI-NN-B8': 10x Dual Index NN Set A. Used with 10xV3.1_CellPlex;GEX and 10xV3.1-HT_CellPlex;GEX

SI_NN_B9 = 'SI-NN-B9': 10x Dual Index NN Set A. Used with 10xV3.1_CellPlex;GEX and 10xV3.1-HT_CellPlex;GEX

SI_NN_C1 = 'SI-NN-C1': 10x Dual Index NN Set A. Used with 10xV3.1_CellPlex;GEX and 10xV3.1-HT_CellPlex;GEX

SI_NN_C10 = 'SI-NN-C10': 10x Dual Index NN Set A. Used with 10xV3.1_CellPlex;GEX and 10xV3.1-HT_CellPlex;GEX

SI_NN_C11 = 'SI-NN-C11': 10x Dual Index NN Set A. Used with 10xV3.1_CellPlex;GEX and 10xV3.1-HT_CellPlex;GEX

SI_NN_C12 = 'SI-NN-C12': 10x Dual Index NN Set A. Used with 10xV3.1_CellPlex;GEX and 10xV3.1-HT_CellPlex;GEX

SI_NN_C2 = 'SI-NN-C2': 10x Dual Index NN Set A. Used with 10xV3.1_CellPlex;GEX and 10xV3.1-HT_CellPlex;GEX

SI_NN_C3 = 'SI-NN-C3': 10x Dual Index NN Set A. Used with 10xV3.1_CellPlex;GEX and 10xV3.1-HT_CellPlex;GEX

SI_NN_C4 = 'SI-NN-C4': 10x Dual Index NN Set A. Used with 10xV3.1_CellPlex;GEX and 10xV3.1-HT_CellPlex;GEX

SI_NN_C5 = 'SI-NN-C5': 10x Dual Index NN Set A. Used with 10xV3.1_CellPlex;GEX and 10xV3.1-HT_CellPlex;GEX

SI_NN_C6 = 'SI-NN-C6': 10x Dual Index NN Set A. Used with 10xV3.1_CellPlex;GEX and 10xV3.1-HT_CellPlex;GEX

SI_NN_C7 = 'SI-NN-C7': 10x Dual Index NN Set A. Used with 10xV3.1_CellPlex;GEX and 10xV3.1-HT_CellPlex;GEX

SI_NN_C8 = 'SI-NN-C8': 10x Dual Index NN Set A. Used with 10xV3.1_CellPlex;GEX and 10xV3.1-HT_CellPlex;GEX

SI_NN_C9 = 'SI-NN-C9': 10x Dual Index NN Set A. Used with 10xV3.1_CellPlex;GEX and 10xV3.1-HT_CellPlex;GEX

SI_NN_D1 = 'SI-NN-D1': 10x Dual Index NN Set A. Used with 10xV3.1_CellPlex;GEX and 10xV3.1-HT_CellPlex;GEX

SI_NN_D10 = 'SI-NN-D10': 10x Dual Index NN Set A. Used with 10xV3.1_CellPlex;GEX and 10xV3.1-HT_CellPlex;GEX

SI_NN_D11 = 'SI-NN-D11': 10x Dual Index NN Set A. Used with 10xV3.1_CellPlex;GEX and 10xV3.1-HT_CellPlex;GEX

SI_NN_D12 = 'SI-NN-D12': 10x Dual Index NN Set A. Used with 10xV3.1_CellPlex;GEX and 10xV3.1-HT_CellPlex;GEX

SI_NN_D2 = 'SI-NN-D2': 10x Dual Index NN Set A. Used with 10xV3.1_CellPlex;GEX and 10xV3.1-HT_CellPlex;GEX

SI_NN_D3 = 'SI-NN-D3': 10x Dual Index NN Set A. Used with 10xV3.1_CellPlex;GEX and 10xV3.1-HT_CellPlex;GEX

SI_NN_D4 = 'SI-NN-D4': 10x Dual Index NN Set A. Used with 10xV3.1_CellPlex;GEX and 10xV3.1-HT_CellPlex;GEX

SI_NN_D5 = 'SI-NN-D5': 10x Dual Index NN Set A. Used with 10xV3.1_CellPlex;GEX and 10xV3.1-HT_CellPlex;GEX

SI_NN_D6 = 'SI-NN-D6': 10x Dual Index NN Set A. Used with 10xV3.1_CellPlex;GEX and 10xV3.1-HT_CellPlex;GEX

SI_NN_D7 = 'SI-NN-D7': 10x Dual Index NN Set A. Used with 10xV3.1_CellPlex;GEX and 10xV3.1-HT_CellPlex;GEX

SI_NN_D8 = 'SI-NN-D8': 10x Dual Index NN Set A. Used with 10xV3.1_CellPlex;GEX and 10xV3.1-HT_CellPlex;GEX

SI_NN_D9 = 'SI-NN-D9': 10x Dual Index NN Set A. Used with 10xV3.1_CellPlex;GEX and 10xV3.1-HT_CellPlex;GEX

SI_NN_E1 = 'SI-NN-E1': 10x Dual Index NN Set A. Used with 10xV3.1_CellPlex;GEX and 10xV3.1-HT_CellPlex;GEX

SI_NN_E10 = 'SI-NN-E10': 10x Dual Index NN Set A. Used with 10xV3.1_CellPlex;GEX and 10xV3.1-HT_CellPlex;GEX

SI_NN_E11 = 'SI-NN-E11': 10x Dual Index NN Set A. Used with 10xV3.1_CellPlex;GEX and 10xV3.1-HT_CellPlex;GEX

SI_NN_E12 = 'SI-NN-E12': 10x Dual Index NN Set A. Used with 10xV3.1_CellPlex;GEX and 10xV3.1-HT_CellPlex;GEX

SI_NN_E2 = 'SI-NN-E2': 10x Dual Index NN Set A. Used with 10xV3.1_CellPlex;GEX and 10xV3.1-HT_CellPlex;GEX

SI_NN_E3 = 'SI-NN-E3': 10x Dual Index NN Set A. Used with 10xV3.1_CellPlex;GEX and 10xV3.1-HT_CellPlex;GEX

SI_NN_E4 = 'SI-NN-E4': 10x Dual Index NN Set A. Used with 10xV3.1_CellPlex;GEX and 10xV3.1-HT_CellPlex;GEX

SI_NN_E5 = 'SI-NN-E5': 10x Dual Index NN Set A. Used with 10xV3.1_CellPlex;GEX and 10xV3.1-HT_CellPlex;GEX

SI_NN_E6 = 'SI-NN-E6': 10x Dual Index NN Set A. Used with 10xV3.1_CellPlex;GEX and 10xV3.1-HT_CellPlex;GEX

SI_NN_E7 = 'SI-NN-E7': 10x Dual Index NN Set A. Used with 10xV3.1_CellPlex;GEX and 10xV3.1-HT_CellPlex;GEX

SI_NN_E8 = 'SI-NN-E8': 10x Dual Index NN Set A. Used with 10xV3.1_CellPlex;GEX and 10xV3.1-HT_CellPlex;GEX

SI_NN_E9 = 'SI-NN-E9': 10x Dual Index NN Set A. Used with 10xV3.1_CellPlex;GEX and 10xV3.1-HT_CellPlex;GEX

SI_NN_F1 = 'SI-NN-F1': 10x Dual Index NN Set A. Used with 10xV3.1_CellPlex;GEX and 10xV3.1-HT_CellPlex;GEX

SI_NN_F10 = 'SI-NN-F10': 10x Dual Index NN Set A. Used with 10xV3.1_CellPlex;GEX and 10xV3.1-HT_CellPlex;GEX

SI_NN_F11 = 'SI-NN-F11': 10x Dual Index NN Set A. Used with 10xV3.1_CellPlex;GEX and 10xV3.1-HT_CellPlex;GEX

SI_NN_F12 = 'SI-NN-F12': 10x Dual Index NN Set A. Used with 10xV3.1_CellPlex;GEX and 10xV3.1-HT_CellPlex;GEX

SI_NN_F2 = 'SI-NN-F2': 10x Dual Index NN Set A. Used with 10xV3.1_CellPlex;GEX and 10xV3.1-HT_CellPlex;GEX

SI_NN_F3 = 'SI-NN-F3': 10x Dual Index NN Set A. Used with 10xV3.1_CellPlex;GEX and 10xV3.1-HT_CellPlex;GEX

SI_NN_F4 = 'SI-NN-F4': 10x Dual Index NN Set A. Used with 10xV3.1_CellPlex;GEX and 10xV3.1-HT_CellPlex;GEX

SI_NN_F5 = 'SI-NN-F5': 10x Dual Index NN Set A. Used with 10xV3.1_CellPlex;GEX and 10xV3.1-HT_CellPlex;GEX

SI_NN_F6 = 'SI-NN-F6': 10x Dual Index NN Set A. Used with 10xV3.1_CellPlex;GEX and 10xV3.1-HT_CellPlex;GEX

SI_NN_F7 = 'SI-NN-F7': 10x Dual Index NN Set A. Used with 10xV3.1_CellPlex;GEX and 10xV3.1-HT_CellPlex;GEX

SI_NN_F8 = 'SI-NN-F8': 10x Dual Index NN Set A. Used with 10xV3.1_CellPlex;GEX and 10xV3.1-HT_CellPlex;GEX

SI_NN_F9 = 'SI-NN-F9': 10x Dual Index NN Set A. Used with 10xV3.1_CellPlex;GEX and 10xV3.1-HT_CellPlex;GEX

SI_NN_G1 = 'SI-NN-G1': 10x Dual Index NN Set A. Used with 10xV3.1_CellPlex;GEX and 10xV3.1-HT_CellPlex;GEX

SI_NN_G10 = 'SI-NN-G10': 10x Dual Index NN Set A. Used with 10xV3.1_CellPlex;GEX and 10xV3.1-HT_CellPlex;GEX

SI_NN_G11 = 'SI-NN-G11': 10x Dual Index NN Set A. Used with 10xV3.1_CellPlex;GEX and 10xV3.1-HT_CellPlex;GEX

SI_NN_G12 = 'SI-NN-G12': 10x Dual Index NN Set A. Used with 10xV3.1_CellPlex;GEX and 10xV3.1-HT_CellPlex;GEX

SI_NN_G2 = 'SI-NN-G2': 10x Dual Index NN Set A. Used with 10xV3.1_CellPlex;GEX and 10xV3.1-HT_CellPlex;GEX

SI_NN_G3 = 'SI-NN-G3': 10x Dual Index NN Set A. Used with 10xV3.1_CellPlex;GEX and 10xV3.1-HT_CellPlex;GEX

SI_NN_G4 = 'SI-NN-G4': 10x Dual Index NN Set A. Used with 10xV3.1_CellPlex;GEX and 10xV3.1-HT_CellPlex;GEX

SI_NN_G5 = 'SI-NN-G5': 10x Dual Index NN Set A. Used with 10xV3.1_CellPlex;GEX and 10xV3.1-HT_CellPlex;GEX

SI_NN_G6 = 'SI-NN-G6': 10x Dual Index NN Set A. Used with 10xV3.1_CellPlex;GEX and 10xV3.1-HT_CellPlex;GEX

SI_NN_G7 = 'SI-NN-G7': 10x Dual Index NN Set A. Used with 10xV3.1_CellPlex;GEX and 10xV3.1-HT_CellPlex;GEX

SI_NN_G8 = 'SI-NN-G8': 10x Dual Index NN Set A. Used with 10xV3.1_CellPlex;GEX and 10xV3.1-HT_CellPlex;GEX

SI_NN_G9 = 'SI-NN-G9': 10x Dual Index NN Set A. Used with 10xV3.1_CellPlex;GEX and 10xV3.1-HT_CellPlex;GEX

SI_NN_H1 = 'SI-NN-H1': 10x Dual Index NN Set A. Used with 10xV3.1_CellPlex;GEX and 10xV3.1-HT_CellPlex;GEX

SI_NN_H10 = 'SI-NN-H10': 10x Dual Index NN Set A. Used with 10xV3.1_CellPlex;GEX and 10xV3.1-HT_CellPlex;GEX

SI_NN_H11 = 'SI-NN-H11': 10x Dual Index NN Set A. Used with 10xV3.1_CellPlex;GEX and 10xV3.1-HT_CellPlex;GEX

SI_NN_H12 = 'SI-NN-H12': 10x Dual Index NN Set A. Used with 10xV3.1_CellPlex;GEX and 10xV3.1-HT_CellPlex;GEX

SI_NN_H2 = 'SI-NN-H2': 10x Dual Index NN Set A. Used with 10xV3.1_CellPlex;GEX and 10xV3.1-HT_CellPlex;GEX

SI_NN_H3 = 'SI-NN-H3': 10x Dual Index NN Set A. Used with 10xV3.1_CellPlex;GEX and 10xV3.1-HT_CellPlex;GEX

SI_NN_H4 = 'SI-NN-H4': 10x Dual Index NN Set A. Used with 10xV3.1_CellPlex;GEX and 10xV3.1-HT_CellPlex;GEX

SI_NN_H5 = 'SI-NN-H5': 10x Dual Index NN Set A. Used with 10xV3.1_CellPlex;GEX and 10xV3.1-HT_CellPlex;GEX

SI_NN_H6 = 'SI-NN-H6': 10x Dual Index NN Set A. Used with 10xV3.1_CellPlex;GEX and 10xV3.1-HT_CellPlex;GEX

SI_NN_H7 = 'SI-NN-H7': 10x Dual Index NN Set A. Used with 10xV3.1_CellPlex;GEX and 10xV3.1-HT_CellPlex;GEX

SI_NN_H8 = 'SI-NN-H8': 10x Dual Index NN Set A. Used with 10xV3.1_CellPlex;GEX and 10xV3.1-HT_CellPlex;GEX

SI_NN_H9 = 'SI-NN-H9': 10x Dual Index NN Set A. Used with 10xV3.1_CellPlex;GEX and 10xV3.1-HT_CellPlex;GEX

SI_TT_A1 = 'SI-TT-A1': 10x Dual Index TT Set A. Used with 10xV3.1, 10xV3.1_HT, and 10xMultiome;GEX

SI_TT_A10 = 'SI-TT-A10': 10x Dual Index TT Set A. Used with 10xV3.1, 10xV3.1_HT, and 10xMultiome;GEX

SI_TT_A11 = 'SI-TT-A11': 10x Dual Index TT Set A. Used with 10xV3.1, 10xV3.1_HT, and 10xMultiome;GEX

SI_TT_A12 = 'SI-TT-A12': 10x Dual Index TT Set A. Used with 10xV3.1, 10xV3.1_HT, and 10xMultiome;GEX

SI_TT_A2 = 'SI-TT-A2': 10x Dual Index TT Set A. Used with 10xV3.1, 10xV3.1_HT, and 10xMultiome;GEX

SI_TT_A3 = 'SI-TT-A3': 10x Dual Index TT Set A. Used with 10xV3.1, 10xV3.1_HT, and 10xMultiome;GEX

SI_TT_A4 = 'SI-TT-A4': 10x Dual Index TT Set A. Used with 10xV3.1, 10xV3.1_HT, and 10xMultiome;GEX

SI_TT_A5 = 'SI-TT-A5': 10x Dual Index TT Set A. Used with 10xV3.1, 10xV3.1_HT, and 10xMultiome;GEX

SI_TT_A6 = 'SI-TT-A6': 10x Dual Index TT Set A. Used with 10xV3.1, 10xV3.1_HT, and 10xMultiome;GEX

SI_TT_A7 = 'SI-TT-A7': 10x Dual Index TT Set A. Used with 10xV3.1, 10xV3.1_HT, and 10xMultiome;GEX

SI_TT_A8 = 'SI-TT-A8': 10x Dual Index TT Set A. Used with 10xV3.1, 10xV3.1_HT, and 10xMultiome;GEX

SI_TT_A9 = 'SI-TT-A9': 10x Dual Index TT Set A. Used with 10xV3.1, 10xV3.1_HT, and 10xMultiome;GEX

SI_TT_B1 = 'SI-TT-B1': 10x Dual Index TT Set A. Used with 10xV3.1, 10xV3.1_HT, and 10xMultiome;GEX

SI_TT_B10 = 'SI-TT-B10': 10x Dual Index TT Set A. Used with 10xV3.1, 10xV3.1_HT, and 10xMultiome;GEX

SI_TT_B11 = 'SI-TT-B11': 10x Dual Index TT Set A. Used with 10xV3.1, 10xV3.1_HT, and 10xMultiome;GEX

SI_TT_B12 = 'SI-TT-B12': 10x Dual Index TT Set A. Used with 10xV3.1, 10xV3.1_HT, and 10xMultiome;GEX

SI_TT_B2 = 'SI-TT-B2': 10x Dual Index TT Set A. Used with 10xV3.1, 10xV3.1_HT, and 10xMultiome;GEX

SI_TT_B3 = 'SI-TT-B3': 10x Dual Index TT Set A. Used with 10xV3.1, 10xV3.1_HT, and 10xMultiome;GEX

SI_TT_B4 = 'SI-TT-B4': 10x Dual Index TT Set A. Used with 10xV3.1, 10xV3.1_HT, and 10xMultiome;GEX

SI_TT_B5 = 'SI-TT-B5': 10x Dual Index TT Set A. Used with 10xV3.1, 10xV3.1_HT, and 10xMultiome;GEX

SI_TT_B6 = 'SI-TT-B6': 10x Dual Index TT Set A. Used with 10xV3.1, 10xV3.1_HT, and 10xMultiome;GEX

SI_TT_B7 = 'SI-TT-B7': 10x Dual Index TT Set A. Used with 10xV3.1, 10xV3.1_HT, and 10xMultiome;GEX

SI_TT_B8 = 'SI-TT-B8': 10x Dual Index TT Set A. Used with 10xV3.1, 10xV3.1_HT, and 10xMultiome;GEX

SI_TT_B9 = 'SI-TT-B9': 10x Dual Index TT Set A. Used with 10xV3.1, 10xV3.1_HT, and 10xMultiome;GEX

SI_TT_C1 = 'SI-TT-C1': 10x Dual Index TT Set A. Used with 10xV3.1, 10xV3.1_HT, and 10xMultiome;GEX

SI_TT_C10 = 'SI-TT-C10': 10x Dual Index TT Set A. Used with 10xV3.1, 10xV3.1_HT, and 10xMultiome;GEX

SI_TT_C11 = 'SI-TT-C11': 10x Dual Index TT Set A. Used with 10xV3.1, 10xV3.1_HT, and 10xMultiome;GEX

SI_TT_C12 = 'SI-TT-C12': 10x Dual Index TT Set A. Used with 10xV3.1, 10xV3.1_HT, and 10xMultiome;GEX

SI_TT_C2 = 'SI-TT-C2': 10x Dual Index TT Set A. Used with 10xV3.1, 10xV3.1_HT, and 10xMultiome;GEX

SI_TT_C3 = 'SI-TT-C3': 10x Dual Index TT Set A. Used with 10xV3.1, 10xV3.1_HT, and 10xMultiome;GEX

SI_TT_C4 = 'SI-TT-C4': 10x Dual Index TT Set A. Used with 10xV3.1, 10xV3.1_HT, and 10xMultiome;GEX

SI_TT_C5 = 'SI-TT-C5': 10x Dual Index TT Set A. Used with 10xV3.1, 10xV3.1_HT, and 10xMultiome;GEX

SI_TT_C6 = 'SI-TT-C6': 10x Dual Index TT Set A. Used with 10xV3.1, 10xV3.1_HT, and 10xMultiome;GEX

SI_TT_C7 = 'SI-TT-C7': 10x Dual Index TT Set A. Used with 10xV3.1, 10xV3.1_HT, and 10xMultiome;GEX

SI_TT_C8 = 'SI-TT-C8': 10x Dual Index TT Set A. Used with 10xV3.1, 10xV3.1_HT, and 10xMultiome;GEX

SI_TT_C9 = 'SI-TT-C9': 10x Dual Index TT Set A. Used with 10xV3.1, 10xV3.1_HT, and 10xMultiome;GEX

SI_TT_D1 = 'SI-TT-D1': 10x Dual Index TT Set A. Used with 10xV3.1, 10xV3.1_HT, and 10xMultiome;GEX

SI_TT_D10 = 'SI-TT-D10': 10x Dual Index TT Set A. Used with 10xV3.1, 10xV3.1_HT, and 10xMultiome;GEX

SI_TT_D11 = 'SI-TT-D11': 10x Dual Index TT Set A. Used with 10xV3.1, 10xV3.1_HT, and 10xMultiome;GEX

SI_TT_D12 = 'SI-TT-D12': 10x Dual Index TT Set A. Used with 10xV3.1, 10xV3.1_HT, and 10xMultiome;GEX

SI_TT_D2 = 'SI-TT-D2': 10x Dual Index TT Set A. Used with 10xV3.1, 10xV3.1_HT, and 10xMultiome;GEX

SI_TT_D3 = 'SI-TT-D3': 10x Dual Index TT Set A. Used with 10xV3.1, 10xV3.1_HT, and 10xMultiome;GEX

SI_TT_D4 = 'SI-TT-D4': 10x Dual Index TT Set A. Used with 10xV3.1, 10xV3.1_HT, and 10xMultiome;GEX

SI_TT_D5 = 'SI-TT-D5': 10x Dual Index TT Set A. Used with 10xV3.1, 10xV3.1_HT, and 10xMultiome;GEX

SI_TT_D6 = 'SI-TT-D6': 10x Dual Index TT Set A. Used with 10xV3.1, 10xV3.1_HT, and 10xMultiome;GEX

SI_TT_D7 = 'SI-TT-D7': 10x Dual Index TT Set A. Used with 10xV3.1, 10xV3.1_HT, and 10xMultiome;GEX

SI_TT_D8 = 'SI-TT-D8': 10x Dual Index TT Set A. Used with 10xV3.1, 10xV3.1_HT, and 10xMultiome;GEX

SI_TT_D9 = 'SI-TT-D9': 10x Dual Index TT Set A. Used with 10xV3.1, 10xV3.1_HT, and 10xMultiome;GEX

SI_TT_E1 = 'SI-TT-E1': 10x Dual Index TT Set A. Used with 10xV3.1, 10xV3.1_HT, and 10xMultiome;GEX

SI_TT_E10 = 'SI-TT-E10': 10x Dual Index TT Set A. Used with 10xV3.1, 10xV3.1_HT, and 10xMultiome;GEX

SI_TT_E11 = 'SI-TT-E11': 10x Dual Index TT Set A. Used with 10xV3.1, 10xV3.1_HT, and 10xMultiome;GEX

SI_TT_E12 = 'SI-TT-E12': 10x Dual Index TT Set A. Used with 10xV3.1, 10xV3.1_HT, and 10xMultiome;GEX

SI_TT_E2 = 'SI-TT-E2': 10x Dual Index TT Set A. Used with 10xV3.1, 10xV3.1_HT, and 10xMultiome;GEX

SI_TT_E3 = 'SI-TT-E3': 10x Dual Index TT Set A. Used with 10xV3.1, 10xV3.1_HT, and 10xMultiome;GEX

SI_TT_E4 = 'SI-TT-E4': 10x Dual Index TT Set A. Used with 10xV3.1, 10xV3.1_HT, and 10xMultiome;GEX

SI_TT_E5 = 'SI-TT-E5': 10x Dual Index TT Set A. Used with 10xV3.1, 10xV3.1_HT, and 10xMultiome;GEX

SI_TT_E6 = 'SI-TT-E6': 10x Dual Index TT Set A. Used with 10xV3.1, 10xV3.1_HT, and 10xMultiome;GEX

SI_TT_E7 = 'SI-TT-E7': 10x Dual Index TT Set A. Used with 10xV3.1, 10xV3.1_HT, and 10xMultiome;GEX

SI_TT_E8 = 'SI-TT-E8': 10x Dual Index TT Set A. Used with 10xV3.1, 10xV3.1_HT, and 10xMultiome;GEX

SI_TT_E9 = 'SI-TT-E9': 10x Dual Index TT Set A. Used with 10xV3.1, 10xV3.1_HT, and 10xMultiome;GEX

SI_TT_F1 = 'SI-TT-F1': 10x Dual Index TT Set A. Used with 10xV3.1, 10xV3.1_HT, and 10xMultiome;GEX

SI_TT_F10 = 'SI-TT-F10': 10x Dual Index TT Set A. Used with 10xV3.1, 10xV3.1_HT, and 10xMultiome;GEX

SI_TT_F11 = 'SI-TT-F11': 10x Dual Index TT Set A. Used with 10xV3.1, 10xV3.1_HT, and 10xMultiome;GEX

SI_TT_F12 = 'SI-TT-F12': 10x Dual Index TT Set A. Used with 10xV3.1, 10xV3.1_HT, and 10xMultiome;GEX

SI_TT_F2 = 'SI-TT-F2': 10x Dual Index TT Set A. Used with 10xV3.1, 10xV3.1_HT, and 10xMultiome;GEX

SI_TT_F3 = 'SI-TT-F3': 10x Dual Index TT Set A. Used with 10xV3.1, 10xV3.1_HT, and 10xMultiome;GEX

SI_TT_F4 = 'SI-TT-F4': 10x Dual Index TT Set A. Used with 10xV3.1, 10xV3.1_HT, and 10xMultiome;GEX

SI_TT_F5 = 'SI-TT-F5': 10x Dual Index TT Set A. Used with 10xV3.1, 10xV3.1_HT, and 10xMultiome;GEX

SI_TT_F6 = 'SI-TT-F6': 10x Dual Index TT Set A. Used with 10xV3.1, 10xV3.1_HT, and 10xMultiome;GEX

SI_TT_F7 = 'SI-TT-F7': 10x Dual Index TT Set A. Used with 10xV3.1, 10xV3.1_HT, and 10xMultiome;GEX

SI_TT_F8 = 'SI-TT-F8': 10x Dual Index TT Set A. Used with 10xV3.1, 10xV3.1_HT, and 10xMultiome;GEX

SI_TT_F9 = 'SI-TT-F9': 10x Dual Index TT Set A. Used with 10xV3.1, 10xV3.1_HT, and 10xMultiome;GEX

SI_TT_G1 = 'SI-TT-G1': 10x Dual Index TT Set A. Used with 10xV3.1, 10xV3.1_HT, and 10xMultiome;GEX

SI_TT_G10 = 'SI-TT-G10': 10x Dual Index TT Set A. Used with 10xV3.1, 10xV3.1_HT, and 10xMultiome;GEX

SI_TT_G11 = 'SI-TT-G11': 10x Dual Index TT Set A. Used with 10xV3.1, 10xV3.1_HT, and 10xMultiome;GEX

SI_TT_G12 = 'SI-TT-G12': 10x Dual Index TT Set A. Used with 10xV3.1, 10xV3.1_HT, and 10xMultiome;GEX

SI_TT_G2 = 'SI-TT-G2': 10x Dual Index TT Set A. Used with 10xV3.1, 10xV3.1_HT, and 10xMultiome;GEX

SI_TT_G3 = 'SI-TT-G3': 10x Dual Index TT Set A. Used with 10xV3.1, 10xV3.1_HT, and 10xMultiome;GEX

SI_TT_G4 = 'SI-TT-G4': 10x Dual Index TT Set A. Used with 10xV3.1, 10xV3.1_HT, and 10xMultiome;GEX

SI_TT_G5 = 'SI-TT-G5': 10x Dual Index TT Set A. Used with 10xV3.1, 10xV3.1_HT, and 10xMultiome;GEX

SI_TT_G6 = 'SI-TT-G6': 10x Dual Index TT Set A. Used with 10xV3.1, 10xV3.1_HT, and 10xMultiome;GEX

SI_TT_G7 = 'SI-TT-G7': 10x Dual Index TT Set A. Used with 10xV3.1, 10xV3.1_HT, and 10xMultiome;GEX

SI_TT_G8 = 'SI-TT-G8': 10x Dual Index TT Set A. Used with 10xV3.1, 10xV3.1_HT, and 10xMultiome;GEX

SI_TT_G9 = 'SI-TT-G9': 10x Dual Index TT Set A. Used with 10xV3.1, 10xV3.1_HT, and 10xMultiome;GEX

SI_TT_H1 = 'SI-TT-H1': 10x Dual Index TT Set A. Used with 10xV3.1, 10xV3.1_HT, and 10xMultiome;GEX

SI_TT_H10 = 'SI-TT-H10': 10x Dual Index TT Set A. Used with 10xV3.1, 10xV3.1_HT, and 10xMultiome;GEX

SI_TT_H11 = 'SI-TT-H11': 10x Dual Index TT Set A. Used with 10xV3.1, 10xV3.1_HT, and 10xMultiome;GEX

SI_TT_H12 = 'SI-TT-H12': 10x Dual Index TT Set A. Used with 10xV3.1, 10xV3.1_HT, and 10xMultiome;GEX

SI_TT_H2 = 'SI-TT-H2': 10x Dual Index TT Set A. Used with 10xV3.1, 10xV3.1_HT, and 10xMultiome;GEX

SI_TT_H3 = 'SI-TT-H3': 10x Dual Index TT Set A. Used with 10xV3.1, 10xV3.1_HT, and 10xMultiome;GEX

SI_TT_H4 = 'SI-TT-H4': 10x Dual Index TT Set A. Used with 10xV3.1, 10xV3.1_HT, and 10xMultiome;GEX

SI_TT_H5 = 'SI-TT-H5': 10x Dual Index TT Set A. Used with 10xV3.1, 10xV3.1_HT, and 10xMultiome;GEX

SI_TT_H6 = 'SI-TT-H6': 10x Dual Index TT Set A. Used with 10xV3.1, 10xV3.1_HT, and 10xMultiome;GEX

SI_TT_H7 = 'SI-TT-H7': 10x Dual Index TT Set A. Used with 10xV3.1, 10xV3.1_HT, and 10xMultiome;GEX

SI_TT_H8 = 'SI-TT-H8': 10x Dual Index TT Set A. Used with 10xV3.1, 10xV3.1_HT, and 10xMultiome;GEX

SI_TT_H9 = 'SI-TT-H9': 10x Dual Index TT Set A. Used with 10xV3.1, 10xV3.1_HT, and 10xMultiome;GEX

SetB_A1 = 'SetB-A1': NeryLab 384_SetB

SetB_A10 = 'SetB-A10': NeryLab 384_SetB

SetB_A11 = 'SetB-A11': NeryLab 384_SetB

SetB_A12 = 'SetB-A12': NeryLab 384_SetB

SetB_A13 = 'SetB-A13': NeryLab 384_SetB

SetB_A14 = 'SetB-A14': NeryLab 384_SetB

SetB_A15 = 'SetB-A15': NeryLab 384_SetB

SetB_A16 = 'SetB-A16': NeryLab 384_SetB

SetB_A17 = 'SetB-A17': NeryLab 384_SetB

SetB_A18 = 'SetB-A18': NeryLab 384_SetB

SetB_A19 = 'SetB-A19': NeryLab 384_SetB

SetB_A2 = 'SetB-A2': NeryLab 384_SetB

SetB_A20 = 'SetB-A20': NeryLab 384_SetB

SetB_A21 = 'SetB-A21': NeryLab 384_SetB

SetB_A22 = 'SetB-A22': NeryLab 384_SetB

SetB_A23 = 'SetB-A23': NeryLab 384_SetB

SetB_A24 = 'SetB-A24': NeryLab 384_SetB

SetB_A3 = 'SetB-A3': NeryLab 384_SetB

SetB_A4 = 'SetB-A4': NeryLab 384_SetB

SetB_A5 = 'SetB-A5': NeryLab 384_SetB

SetB_A6 = 'SetB-A6': NeryLab 384_SetB

SetB_A7 = 'SetB-A7': NeryLab 384_SetB

SetB_A8 = 'SetB-A8': NeryLab 384_SetB

SetB_A9 = 'SetB-A9': NeryLab 384_SetB

SetB_B1 = 'SetB-B1': NeryLab 384_SetB

SetB_B10 = 'SetB-B10': NeryLab 384_SetB

SetB_B11 = 'SetB-B11': NeryLab 384_SetB

SetB_B12 = 'SetB-B12': NeryLab 384_SetB

SetB_B13 = 'SetB-B13': NeryLab 384_SetB

SetB_B14 = 'SetB-B14': NeryLab 384_SetB

SetB_B15 = 'SetB-B15': NeryLab 384_SetB

SetB_B16 = 'SetB-B16': NeryLab 384_SetB

SetB_B17 = 'SetB-B17': NeryLab 384_SetB

SetB_B18 = 'SetB-B18': NeryLab 384_SetB

SetB_B19 = 'SetB-B19': NeryLab 384_SetB

SetB_B2 = 'SetB-B2': NeryLab 384_SetB

SetB_B20 = 'SetB-B20': NeryLab 384_SetB

SetB_B21 = 'SetB-B21': NeryLab 384_SetB

SetB_B22 = 'SetB-B22': NeryLab 384_SetB

SetB_B23 = 'SetB-B23': NeryLab 384_SetB

SetB_B24 = 'SetB-B24': NeryLab 384_SetB

SetB_B3 = 'SetB-B3': NeryLab 384_SetB

SetB_B4 = 'SetB-B4': NeryLab 384_SetB

SetB_B5 = 'SetB-B5': NeryLab 384_SetB

SetB_B6 = 'SetB-B6': NeryLab 384_SetB

SetB_B7 = 'SetB-B7': NeryLab 384_SetB

SetB_B8 = 'SetB-B8': NeryLab 384_SetB

SetB_B9 = 'SetB-B9': NeryLab 384_SetB

SetB_C1 = 'SetB-C1': NeryLab 384_SetB

SetB_C10 = 'SetB-C10': NeryLab 384_SetB

SetB_C11 = 'SetB-C11': NeryLab 384_SetB

SetB_C12 = 'SetB-C12': NeryLab 384_SetB

SetB_C13 = 'SetB-C13': NeryLab 384_SetB

SetB_C14 = 'SetB-C14': NeryLab 384_SetB

SetB_C15 = 'SetB-C15': NeryLab 384_SetB

SetB_C16 = 'SetB-C16': NeryLab 384_SetB

SetB_C17 = 'SetB-C17': NeryLab 384_SetB

SetB_C18 = 'SetB-C18': NeryLab 384_SetB

SetB_C19 = 'SetB-C19': NeryLab 384_SetB

SetB_C2 = 'SetB-C2': NeryLab 384_SetB

SetB_C20 = 'SetB-C20': NeryLab 384_SetB

SetB_C21 = 'SetB-C21': NeryLab 384_SetB

SetB_C22 = 'SetB-C22': NeryLab 384_SetB

SetB_C23 = 'SetB-C23': NeryLab 384_SetB

SetB_C24 = 'SetB-C24': NeryLab 384_SetB

SetB_C3 = 'SetB-C3': NeryLab 384_SetB

SetB_C4 = 'SetB-C4': NeryLab 384_SetB

SetB_C5 = 'SetB-C5': NeryLab 384_SetB

SetB_C6 = 'SetB-C6': NeryLab 384_SetB

SetB_C7 = 'SetB-C7': NeryLab 384_SetB

SetB_C8 = 'SetB-C8': NeryLab 384_SetB

SetB_C9 = 'SetB-C9': NeryLab 384_SetB

SetB_D1 = 'SetB-D1': NeryLab 384_SetB

SetB_D10 = 'SetB-D10': NeryLab 384_SetB

SetB_D11 = 'SetB-D11': NeryLab 384_SetB

SetB_D12 = 'SetB-D12': NeryLab 384_SetB

SetB_D13 = 'SetB-D13': NeryLab 384_SetB

SetB_D14 = 'SetB-D14': NeryLab 384_SetB

SetB_D15 = 'SetB-D15': NeryLab 384_SetB

SetB_D16 = 'SetB-D16': NeryLab 384_SetB

SetB_D17 = 'SetB-D17': NeryLab 384_SetB

SetB_D18 = 'SetB-D18': NeryLab 384_SetB

SetB_D19 = 'SetB-D19': NeryLab 384_SetB

SetB_D2 = 'SetB-D2': NeryLab 384_SetB

SetB_D20 = 'SetB-D20': NeryLab 384_SetB

SetB_D21 = 'SetB-D21': NeryLab 384_SetB

SetB_D22 = 'SetB-D22': NeryLab 384_SetB

SetB_D23 = 'SetB-D23': NeryLab 384_SetB

SetB_D24 = 'SetB-D24': NeryLab 384_SetB

SetB_D3 = 'SetB-D3': NeryLab 384_SetB

SetB_D4 = 'SetB-D4': NeryLab 384_SetB

SetB_D5 = 'SetB-D5': NeryLab 384_SetB

SetB_D6 = 'SetB-D6': NeryLab 384_SetB

SetB_D7 = 'SetB-D7': NeryLab 384_SetB

SetB_D8 = 'SetB-D8': NeryLab 384_SetB

SetB_D9 = 'SetB-D9': NeryLab 384_SetB

SetB_E1 = 'SetB-E1': NeryLab 384_SetB

SetB_E10 = 'SetB-E10': NeryLab 384_SetB

SetB_E11 = 'SetB-E11': NeryLab 384_SetB

SetB_E12 = 'SetB-E12': NeryLab 384_SetB

SetB_E13 = 'SetB-E13': NeryLab 384_SetB

SetB_E14 = 'SetB-E14': NeryLab 384_SetB

SetB_E15 = 'SetB-E15': NeryLab 384_SetB

SetB_E16 = 'SetB-E16': NeryLab 384_SetB

SetB_E17 = 'SetB-E17': NeryLab 384_SetB

SetB_E18 = 'SetB-E18': NeryLab 384_SetB

SetB_E19 = 'SetB-E19': NeryLab 384_SetB

SetB_E2 = 'SetB-E2': NeryLab 384_SetB

SetB_E20 = 'SetB-E20': NeryLab 384_SetB

SetB_E21 = 'SetB-E21': NeryLab 384_SetB

SetB_E22 = 'SetB-E22': NeryLab 384_SetB

SetB_E23 = 'SetB-E23': NeryLab 384_SetB

SetB_E24 = 'SetB-E24': NeryLab 384_SetB

SetB_E3 = 'SetB-E3': NeryLab 384_SetB

SetB_E4 = 'SetB-E4': NeryLab 384_SetB

SetB_E5 = 'SetB-E5': NeryLab 384_SetB

SetB_E6 = 'SetB-E6': NeryLab 384_SetB

SetB_E7 = 'SetB-E7': NeryLab 384_SetB

SetB_E8 = 'SetB-E8': NeryLab 384_SetB

SetB_E9 = 'SetB-E9': NeryLab 384_SetB

SetB_F1 = 'SetB-F1': NeryLab 384_SetB

SetB_F10 = 'SetB-F10': NeryLab 384_SetB

SetB_F11 = 'SetB-F11': NeryLab 384_SetB

SetB_F12 = 'SetB-F12': NeryLab 384_SetB

SetB_F13 = 'SetB-F13': NeryLab 384_SetB

SetB_F14 = 'SetB-F14': NeryLab 384_SetB

SetB_F15 = 'SetB-F15': NeryLab 384_SetB

SetB_F16 = 'SetB-F16': NeryLab 384_SetB

SetB_F17 = 'SetB-F17': NeryLab 384_SetB

SetB_F18 = 'SetB-F18': NeryLab 384_SetB

SetB_F19 = 'SetB-F19': NeryLab 384_SetB

SetB_F2 = 'SetB-F2': NeryLab 384_SetB

SetB_F20 = 'SetB-F20': NeryLab 384_SetB

SetB_F21 = 'SetB-F21': NeryLab 384_SetB

SetB_F22 = 'SetB-F22': NeryLab 384_SetB

SetB_F23 = 'SetB-F23': NeryLab 384_SetB

SetB_F24 = 'SetB-F24': NeryLab 384_SetB

SetB_F3 = 'SetB-F3': NeryLab 384_SetB

SetB_F4 = 'SetB-F4': NeryLab 384_SetB

SetB_F5 = 'SetB-F5': NeryLab 384_SetB

SetB_F6 = 'SetB-F6': NeryLab 384_SetB

SetB_F7 = 'SetB-F7': NeryLab 384_SetB

SetB_F8 = 'SetB-F8': NeryLab 384_SetB

SetB_F9 = 'SetB-F9': NeryLab 384_SetB

SetB_G1 = 'SetB-G1': NeryLab 384_SetB

SetB_G10 = 'SetB-G10': NeryLab 384_SetB

SetB_G11 = 'SetB-G11': NeryLab 384_SetB

SetB_G12 = 'SetB-G12': NeryLab 384_SetB

SetB_G13 = 'SetB-G13': NeryLab 384_SetB

SetB_G14 = 'SetB-G14': NeryLab 384_SetB

SetB_G15 = 'SetB-G15': NeryLab 384_SetB

SetB_G16 = 'SetB-G16': NeryLab 384_SetB

SetB_G17 = 'SetB-G17': NeryLab 384_SetB

SetB_G18 = 'SetB-G18': NeryLab 384_SetB

SetB_G19 = 'SetB-G19': NeryLab 384_SetB

SetB_G2 = 'SetB-G2': NeryLab 384_SetB

SetB_G20 = 'SetB-G20': NeryLab 384_SetB

SetB_G21 = 'SetB-G21': NeryLab 384_SetB

SetB_G22 = 'SetB-G22': NeryLab 384_SetB

SetB_G23 = 'SetB-G23': NeryLab 384_SetB

SetB_G24 = 'SetB-G24': NeryLab 384_SetB

SetB_G3 = 'SetB-G3': NeryLab 384_SetB

SetB_G4 = 'SetB-G4': NeryLab 384_SetB

SetB_G5 = 'SetB-G5': NeryLab 384_SetB

SetB_G6 = 'SetB-G6': NeryLab 384_SetB

SetB_G7 = 'SetB-G7': NeryLab 384_SetB

SetB_G8 = 'SetB-G8': NeryLab 384_SetB

SetB_G9 = 'SetB-G9': NeryLab 384_SetB

SetB_H1 = 'SetB-H1': NeryLab 384_SetB

SetB_H10 = 'SetB-H10': NeryLab 384_SetB

SetB_H11 = 'SetB-H11': NeryLab 384_SetB

SetB_H12 = 'SetB-H12': NeryLab 384_SetB

SetB_H13 = 'SetB-H13': NeryLab 384_SetB

SetB_H14 = 'SetB-H14': NeryLab 384_SetB

SetB_H15 = 'SetB-H15': NeryLab 384_SetB

SetB_H16 = 'SetB-H16': NeryLab 384_SetB

SetB_H17 = 'SetB-H17': NeryLab 384_SetB

SetB_H18 = 'SetB-H18': NeryLab 384_SetB

SetB_H19 = 'SetB-H19': NeryLab 384_SetB

SetB_H2 = 'SetB-H2': NeryLab 384_SetB

SetB_H20 = 'SetB-H20': NeryLab 384_SetB

SetB_H21 = 'SetB-H21': NeryLab 384_SetB

SetB_H22 = 'SetB-H22': NeryLab 384_SetB

SetB_H23 = 'SetB-H23': NeryLab 384_SetB

SetB_H24 = 'SetB-H24': NeryLab 384_SetB

SetB_H3 = 'SetB-H3': NeryLab 384_SetB

SetB_H4 = 'SetB-H4': NeryLab 384_SetB

SetB_H5 = 'SetB-H5': NeryLab 384_SetB

SetB_H6 = 'SetB-H6': NeryLab 384_SetB

SetB_H7 = 'SetB-H7': NeryLab 384_SetB

SetB_H8 = 'SetB-H8': NeryLab 384_SetB

SetB_H9 = 'SetB-H9': NeryLab 384_SetB

SetB_I1 = 'SetB-I1': NeryLab 384_SetB

SetB_I10 = 'SetB-I10': NeryLab 384_SetB

SetB_I11 = 'SetB-I11': NeryLab 384_SetB

SetB_I12 = 'SetB-I12': NeryLab 384_SetB

SetB_I13 = 'SetB-I13': NeryLab 384_SetB

SetB_I14 = 'SetB-I14': NeryLab 384_SetB

SetB_I15 = 'SetB-I15': NeryLab 384_SetB

SetB_I16 = 'SetB-I16': NeryLab 384_SetB

SetB_I17 = 'SetB-I17': NeryLab 384_SetB

SetB_I18 = 'SetB-I18': NeryLab 384_SetB

SetB_I19 = 'SetB-I19': NeryLab 384_SetB

SetB_I2 = 'SetB-I2': NeryLab 384_SetB

SetB_I20 = 'SetB-I20': NeryLab 384_SetB

SetB_I21 = 'SetB-I21': NeryLab 384_SetB

SetB_I22 = 'SetB-I22': NeryLab 384_SetB

SetB_I23 = 'SetB-I23': NeryLab 384_SetB

SetB_I24 = 'SetB-I24': NeryLab 384_SetB

SetB_I3 = 'SetB-I3': NeryLab 384_SetB

SetB_I4 = 'SetB-I4': NeryLab 384_SetB

SetB_I5 = 'SetB-I5': NeryLab 384_SetB

SetB_I6 = 'SetB-I6': NeryLab 384_SetB

SetB_I7 = 'SetB-I7': NeryLab 384_SetB

SetB_I8 = 'SetB-I8': NeryLab 384_SetB/#

class bkbit.models.library_generation.LibraryTechnique(value)[source]

Bases: str, Enum

An enumeration.

DBiT_ATAC_seq = 'DBiT ATAC-seq': DBiT ATAC-seq

DBiT_RNA_seq = 'DBiT RNA-seq': DBiT RNA-seq

Droplet_Paired_TagSEMICOLON_DNA = 'Droplet Paired-Tag; DNA': Droplet Paired-Tag; DNA

Droplet_Paired_TagSEMICOLON_RNA = 'Droplet Paired-Tag; RNA': Droplet Paired-Tag; RNA

MERFISH = 'MERFISH': MERFISH

MethylC_Seq = 'MethylC-Seq': MethylC-Seq

Multiplex_Droplet_Paired_TagSEMICOLON_DNA = 'Multiplex Droplet Paired-Tag; DNA': Multiplex Droplet Paired-Tag; DNA

Multiplex_Droplet_Paired_TagSEMICOLON_RNA = 'Multiplex Droplet Paired-Tag; RNA': Multiplex Droplet Paired-Tag; RNA

PIPSeq_T20_3P_v4PLUS_SIGN = 'PIPSeq_T20_3P_v4+': PIPSeq_T20_3P_v4+

PIPSeq_T2_3P_v4PLUS_SIGN = 'PIPSeq_T2_3P_v4+': PIPSeq_T2_3P_v4+

SMARTSeqSC = 'SMARTSeqSC': SMARTSeqSC

SMARTSeqV4 = 'SMARTSeqV4': SMARTSeqV4

Slide_seq_MERFISH = 'Slide-seq MERFISH': Slide-seq MERFISH

Slide_tag_10x5Pv2SEMICOLONGEX = 'Slide-tag_10x5Pv2;GEX': Slide-tag_10x5Pv2;GEX

Slide_tag_10x5Pv2SEMICOLONSpatial = 'Slide-tag_10x5Pv2;Spatial': Slide-tag_10x5Pv2;Spatial

Slide_tag_10xV4SEMICOLONGEX = 'Slide-tag_10xV4;GEX': Slide-tag_10xV4;GEX

Slide_tag_10xV4SEMICOLONSpatial = 'Slide-tag_10xV4;Spatial': Slide-tag_10xV4;Spatial

Slide_tag_PIPSeq_T100_3P_v4PLUS_SIGNSEMICOLONGEX = 'Slide-tag_PIPSeq_T100_3P_v4+;GEX': Slide-tag_PIPSeq_T100_3P_v4+;GEX

Slide_tag_PIPSeq_T100_3P_v4PLUS_SIGNSEMICOLONSpatial = 'Slide-tag_PIPSeq_T100_3P_v4+;Spatial': Slide-tag_PIPSeq_T100_3P_v4+;Spatial

Slide_tag_PIPSeq_T20_3P_v4PLUS_SIGNSEMICOLONGEX = 'Slide-tag_PIPSeq_T20_3P_v4+;GEX': Slide-tag_PIPSeq_T20_3P_v4+;GEX

Slide_tag_PIPSeq_T20_3P_v4PLUS_SIGNSEMICOLONSpatial = 'Slide-tag_PIPSeq_T20_3P_v4+;Spatial': Slide-tag_PIPSeq_T20_3P_v4+;Spatial

Slide_tag_TruSeqSEMICOLONRecon = 'Slide-tag_TruSeq;Recon': Slide-tag_TruSeq;Recon

SmartSeq3 = 'SmartSeq3': SmartSeq3

number_10XMultiome_CellHashingSEMICOLONATAC = '10XMultiome-CellHashing;ATAC': 10XMultiome-CellHashing;ATAC

number_10XMultiome_CellHashingSEMICOLONGEX = '10XMultiome-CellHashing;GEX': 10XMultiome-CellHashing;GEX

number_10XMultiome_Cell_HashingSEMICOLONBarcode = '10XMultiome-Cell Hashing;Barcode': 10XMultiome-Cell Hashing;Barcode

number_10x5Pv3 = '10x5Pv3': 10x5Pv3

number_10xATAC_V2FULL_STOP0 = '10xATAC_V2.0': 10xATAC_V2.0

number_10xMultiomeSEMICOLONATAC = '10xMultiome;ATAC': 10xMultiome;ATAC

number_10xMultiomeSEMICOLONGEX = '10xMultiome;GEX': 10xMultiome;GEX

number_10xV3FULL_STOP1 = '10xV3.1': 10xV3.1

number_10xV3FULL_STOP1_CellPlexSEMICOLONBarcode = '10xV3.1_CellPlex;Barcode': 10xV3.1_CellPlex;Barcode

number_10xV3FULL_STOP1_CellPlexSEMICOLONGEX = '10xV3.1_CellPlex;GEX': 10xV3.1_CellPlex;GEX

number_10xV3FULL_STOP1_HT = '10xV3.1_HT': 10xV3.1_HT

number_10xV3FULL_STOP1_HT_CellPlexSEMICOLONBarcode = '10xV3.1_HT_CellPlex;Barcode': 10xV3.1_HT_CellPlex;Barcode

number_10xV3FULL_STOP1_HT_CellPlexSEMICOLONGEX = '10xV3.1_HT_CellPlex;GEX': 10xV3.1_HT_CellPlex;GEX

number_10xV4 = '10xV4': 10xV4

number_10xV4_OCM = '10xV4_OCM': 10xV4_OCM

number_10x_5P_v5FULL_STOP2 = '10x_5P_v5.2': 10x_5P_v5.2

scATAC_seq = 'scATAC-seq': scATAC-seq

snm3C_seq = 'snm3C-seq': snm3C-seq

snmCT_seq = 'snmCT-seq': snmCT-seq

whole_brain_MERFISH = 'whole brain MERFISH': whole brain MERFISH

class bkbit.models.library_generation.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.library_generation.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.library_generation.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.library_generation.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.library_generation.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.library_generation.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.library_generation.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, exact_match: list[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

exact_match: 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.library_generation.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.library_generation.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.library_generation.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.library_generation.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.library_generation.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.library_generation.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.library_generation.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.library_generation.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.library_generation.Sex(value)[source]

Bases: str, Enum

An enumeration.

number_1 = '1': Male

number_2 = '2': Female

number_7 = '7': Other

number_8 = '8': Unknown

number_9 = '9': Not Reported

class bkbit.models.library_generation.Species(value)[source]

Bases: str, Enum

An enumeration.

NCBITaxonCOLON10090 = 'NCBITaxon:10090': Mus musculus

NCBITaxonCOLON10116 = 'NCBITaxon:10116': Rattus norvegicus

NCBITaxonCOLON10181 = 'NCBITaxon:10181': Heterocephalus glaber

NCBITaxonCOLON13616 = 'NCBITaxon:13616': Monodelphis domestica

NCBITaxonCOLON27679 = 'NCBITaxon:27679': Saimiri boliviensis

NCBITaxonCOLON30608 = 'NCBITaxon:30608': Microcebus murinus

NCBITaxonCOLON37293 = 'NCBITaxon:37293': Aotus nancymaae

NCBITaxonCOLON37347 = 'NCBITaxon:37347': Tupaia belangeri

NCBITaxonCOLON60711 = 'NCBITaxon:60711': Chlorocebus sabaeus

NCBITaxonCOLON9361 = 'NCBITaxon:9361': Dasypus novemcinctus

NCBITaxonCOLON9483 = 'NCBITaxon:9483': Callithrix jacchus

NCBITaxonCOLON9521 = 'NCBITaxon:9521': Saimiri sciureus

NCBITaxonCOLON9534 = 'NCBITaxon:9534': Chlorocebus aethiops

NCBITaxonCOLON9541 = 'NCBITaxon:9541': Macaca fascicularis

NCBITaxonCOLON9544 = 'NCBITaxon:9544': Macaca mulatta

NCBITaxonCOLON9545 = 'NCBITaxon:9545': Macaca nemestrina

NCBITaxonCOLON9555 = 'NCBITaxon:9555': Papio anubis

NCBITaxonCOLON9593 = 'NCBITaxon:9593': Gorilla gorilla

NCBITaxonCOLON9598 = 'NCBITaxon:9598': Pan troglodytes

NCBITaxonCOLON9606 = 'NCBITaxon:9606': Homo sapiens

NCBITaxonCOLON9614 = 'NCBITaxon:9614': Canis latrans

NCBITaxonCOLON9669 = 'NCBITaxon:9669': Mustela putorius furo

NCBITaxonCOLON9685 = 'NCBITaxon:9685': Felis catus

NCBITaxonCOLON9742 = 'NCBITaxon:9742': Phocoena phocoena

NCBITaxonCOLON9823 = 'NCBITaxon:9823': Sus scrofa

NCBITaxonCOLON9986 = 'NCBITaxon:9986': Oryctolagus cuniculus

NCBITaxonCOLON9999 = 'NCBITaxon:9999': Urocitellus parryii

class bkbit.models.library_generation.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.library_generation.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.library_generation.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.library_generation.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.library_generation.TissueDissection(*, id: str, iri: str | None = None, category: list[Literal['https://identifiers.org/brain-bican/vocab/TissueDissection', 'bican:TissueDissection']] = ['bican:TissueDissection'], 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, used: str | None = None, was_guided_by: str | None = None)[source]

Bases: ProvActivity, Procedure

The process of dissecting a tissue sample from a brain slab guided by a dissection region of interest (ROI) delineation.

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

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/library-generation-schema', 'in_subset': ['bican', 'library_generation'], 'mixins': ['ProvActivity'], 'slot_usage': {'used': {'description': 'The brain slab from which the tissue sample was dissected from.', 'name': 'used', 'range': 'BrainSlab'}}})

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

used: str | None

was_guided_by: str | None

xref: list[str] | None

class bkbit.models.library_generation.TissueSample(*, id: str, iri: str | None = None, category: list[Literal['https://identifiers.org/brain-bican/vocab/TissueSample', 'bican:TissueSample']] = ['bican:TissueSample'], 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, dissection_was_guided_by: str | None = None, structure: list[str] | None = None)[source]

Bases: ProvEntity, MaterialSample

The final intact piece of tissue before cell or nuclei prep. This piece of tissue will be used in dissociation and has an region of interest polygon (ROI) associated with it.

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

deprecated: bool | None

description: str | None

dissection_was_guided_by: 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={'exact_mappings': ['NIMP:Tissue'], 'from_schema': 'https://identifiers.org/brain-bican/library-generation-schema', 'in_subset': ['bican', 'library_generation'], 'mixins': ['ProvEntity'], 'slot_usage': {'name': {'description': 'Identifier name for final intact piece of tissue before cell or nuclei prep. This piece of tissue will be used in dissociation and has an ROI associated with it.', 'exact_mappings': ['bican:2e4ca2fc-2d77-4d19-af45-d0fb7bbc2269', 'NIMP:PD-LJCRCC35'], 'local_names': {'NIMP_resource_type': {'local_name_source': 'NIMP_resource_type', 'local_name_value': 'Tissue'}, 'NIMP_variable_name': {'local_name_source': 'NIMP_variable_name', 'local_name_value': 'tissue_sample_local_name'}}, 'name': 'name'}, 'was_derived_from': {'description': 'The donor or brain slab from which the tissue sample was derived from.', 'name': 'was_derived_from', 'range': 'Donor'}, 'was_generated_by': {'description': 'The dissection process from which the tissue sample was generated by.', 'name': 'was_generated_by', 'range': 'TissueDissection'}, 'xref': {'local_names': {'NIMP_resource_type': {'local_name_source': 'NIMP_resource_type', 'local_name_value': 'Tissue'}, 'NIMP_variable_name': {'local_name_source': 'NIMP_variable_name', 'local_name_value': 'tissue_nhash_id'}}, 'name': 'xref'}}})

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

structure: 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.library_generation.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