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)

Bases: ActivityAndBehavior, NamedThing

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

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

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

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

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

deprecated: bool | None

description: str | None

full_name: str | None

has_attribute: List[str] | None

id: str

iri: str | None

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

model_config: ClassVar[ConfigDict] = {'arbitrary_types_allowed': True, 'extra': 'forbid', 'strict': False, 'use_enum_values': True, 'validate_assignment': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

name: str | None

provided_by: List[str] | None

synonym: List[str] | None

type: List[str] | None

xref: List[str] | None

class bkbit.models.library_generation.ActivityAndBehavior

Bases: Occurrent

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

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

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

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

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

model_config: ClassVar[ConfigDict] = {'arbitrary_types_allowed': True, 'extra': 'forbid', 'strict': False, 'use_enum_values': True, 'validate_assignment': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class bkbit.models.library_generation.AgeAtDeathReferencePoint(value)

Bases: str, Enum

An enumeration.

birth = 'birth'

conception = 'conception'

class bkbit.models.library_generation.AgeAtDeathUnit(value)

Bases: str, Enum

An enumeration.

days = 'days'

months = 'months'

years = 'years'

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, was_derived_from: str | None = None, was_generated_by: str | None = None, amplified_cDNA_amplified_quantity_ng: float | None = None, amplified_cDNA_RNA_amplification_pass_fail: AmplifiedCdnaRnaAmplificationPassFail | None = None, amplified_cDNA_percent_cDNA_longer_than_400bp: float | None = None)

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_RNA_amplification_pass_fail: AmplifiedCdnaRnaAmplificationPassFail | None

amplified_cDNA_amplified_quantity_ng: float | None

amplified_cDNA_percent_cDNA_longer_than_400bp: float | None

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

deprecated: bool | None

description: str | None

full_name: str | None

has_attribute: List[str] | None

id: str

iri: str | None

linkml_meta: ClassVar[LinkMLMeta] = LinkMLMeta(root={'exact_mappings': ['NIMP:Amplified%20cDNA'], 'from_schema': 'https://identifiers.org/brain-bican/library-generation-schema', 'in_subset': ['bican', 'library_generation'], 'mixins': ['ProvEntity'], 'slot_usage': {'category': {'name': 'category', 'pattern': '^bican:[A-Z][A-Za-z]+$'}, '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': ['NIMP:PD-YAAGGG39'], 'local_names': {'NIMP': {'local_name_source': 'NIMP', 'local_name_value': 'amplified_cdna_local_name'}}, 'name': 'name', 'slot_uri': 'bican:e2606a11-114e-472f-9e05-33f9b6fc3089'}, 'was_derived_from': {'description': 'The input barcoded cell sample from which amplified cDNA was derived from.', 'exact_mappings': ['NIMP:has_parent'], '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'}}})

model_config: ClassVar[ConfigDict] = {'arbitrary_types_allowed': True, 'extra': 'forbid', 'strict': False, 'use_enum_values': True, 'validate_assignment': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

name: str | None

classmethod pattern_category(v)

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)

Bases: str, Enum

An enumeration.

Fail = 'Fail'

Low_QC = 'Low QC'

Not_evaluated = 'Not evaluated'

Pass = 'Pass'

class bkbit.models.library_generation.Annotation

Bases: ConfiguredBaseModel

Biolink Model root class for entity annotations.

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

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

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

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

model_config: ClassVar[ConfigDict] = {'arbitrary_types_allowed': True, 'extra': 'forbid', 'strict': False, 'use_enum_values': True, 'validate_assignment': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class bkbit.models.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, has_attribute_type: str, has_quantitative_value: List[QuantityValue] | None = None, has_qualitative_value: str | None = None)

Bases: NamedThing, OntologyClass

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

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

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

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

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

deprecated: bool | None

description: str | None

full_name: str | None

has_attribute: List[str] | None

has_attribute_type: str

has_qualitative_value: str | None

has_quantitative_value: List[QuantityValue] | None

id: str

iri: str | None

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

model_config: ClassVar[ConfigDict] = {'arbitrary_types_allowed': True, 'extra': 'forbid', 'strict': False, 'use_enum_values': True, 'validate_assignment': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

name: str | None

provided_by: List[str] | None

synonym: List[str] | None

type: List[str] | None

xref: List[str] | None

class bkbit.models.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, was_derived_from: List[str] | None = None, was_generated_by: str | None = None, expected_cell_capture: int | None = None)

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

expected_cell_capture: int | None

full_name: str | None

has_attribute: List[str] | None

id: str

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': {'category': {'name': 'category', 'pattern': '^bican:[A-Z][A-Za-z]+$'}, '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': ['NIMP:PD-XEMDJF38'], 'local_names': {'NIMP': {'local_name_source': 'NIMP', 'local_name_value': 'barcoded_cell_sample_local_name'}}, 'name': 'name', 'slot_uri': 'bican:4c0e6380-e53f-4173-a474-d41e836fefe3'}, 'was_derived_from': {'description': 'The input dissociated or enriched cell sample(s) from which the barcoded cell sample was derived from.', 'exact_mappings': ['NIMP:has_parent'], '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'}}})

model_config: ClassVar[ConfigDict] = {'arbitrary_types_allowed': True, 'extra': 'forbid', 'strict': False, 'use_enum_values': True, 'validate_assignment': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

name: str | None

classmethod pattern_category(v)

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.BarcodedCellSampleTechnique(value)

Bases: str, Enum

An enumeration.

ATACOnly = 'ATACOnly'

GEXOnly = 'GEXOnly'

Multiome = 'Multiome'

snm3C_seq = 'snm3C-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, in_taxon: List[str] | None = None, in_taxon_label: str | None = None)

Bases: ThingWithTaxon, NamedThing

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

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

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

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

deprecated: bool | None

description: str | None

full_name: str | None

has_attribute: List[str] | None

id: str

in_taxon: List[str] | None

in_taxon_label: str | None

iri: str | None

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

model_config: ClassVar[ConfigDict] = {'arbitrary_types_allowed': True, 'extra': 'forbid', 'strict': False, 'use_enum_values': True, 'validate_assignment': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

name: str | None

provided_by: List[str] | None

synonym: List[str] | None

type: List[str] | None

xref: List[str] | None

class bkbit.models.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, was_derived_from: str | None = None, was_generated_by: str | None = None)

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

full_name: str | None

has_attribute: List[str] | None

id: str

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': {'category': {'name': 'category', 'pattern': '^bican:[A-Z][A-Za-z]+$'}, 'name': {'description': 'Name of 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.', 'local_names': {'NIMP': {'local_name_source': 'NIMP', 'local_name_value': 'local_name'}}, 'name': 'name'}, 'was_derived_from': {'any_of': [{'range': 'Donor'}, {'range': 'BrainSlab'}], 'description': 'The donor from which the brain slab was derived from.', 'exact_mappings': ['NIMP:has_parent'], 'name': 'was_derived_from'}}})

model_config: ClassVar[ConfigDict] = {'arbitrary_types_allowed': True, 'extra': 'forbid', 'strict': False, 'use_enum_values': True, 'validate_assignment': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

name: str | None

classmethod pattern_category(v)

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, used: str | None = None, amplified_cDNA_PCR_cycles: int | None = None, cDNA_amplification_process_date: date | None = None, cDNA_amplification_set: str | None = None)

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.

amplified_cDNA_PCR_cycles: int | None

cDNA_amplification_process_date: date | None

cDNA_amplification_set: str | None

category: List[Literal['https://identifiers.org/brain-bican/vocab/CdnaAmplification', 'bican:CdnaAmplification']]

deprecated: bool | None

description: str | None

full_name: str | None

has_attribute: List[str] | None

id: str

iri: str | None

linkml_meta: ClassVar[LinkMLMeta] = LinkMLMeta(root={'from_schema': 'https://identifiers.org/brain-bican/library-generation-schema', 'in_subset': ['bican', 'library_generation'], 'mixins': ['ProvActivity'], 'slot_usage': {'category': {'name': 'category', 'pattern': '^bican:[A-Z][A-Za-z]+$'}, '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', 'strict': False, 'use_enum_values': True, 'validate_assignment': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

name: str | None

classmethod pattern_category(v)

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, used: List[str] | None = None, barcoded_cell_sample_port_well: str | None = None, barcoded_cell_input_quantity_count: int | None = None, process_date: str | None = None, method: BarcodedCellSampleTechnique | None = None)

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.

barcoded_cell_input_quantity_count: int | None

barcoded_cell_sample_port_well: str | None

category: List[Literal['https://identifiers.org/brain-bican/vocab/CellBarcoding', 'bican:CellBarcoding']]

deprecated: bool | None

description: str | None

full_name: str | None

has_attribute: List[str] | None

id: str

iri: str | None

linkml_meta: ClassVar[LinkMLMeta] = LinkMLMeta(root={'from_schema': 'https://identifiers.org/brain-bican/library-generation-schema', 'in_subset': ['bican', 'library_generation'], 'mixins': ['ProvActivity'], 'slot_usage': {'category': {'name': 'category', 'pattern': '^bican:[A-Z][A-Za-z]+$'}, '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'}}})

method: BarcodedCellSampleTechnique | None

model_config: ClassVar[ConfigDict] = {'arbitrary_types_allowed': True, 'extra': 'forbid', 'strict': False, 'use_enum_values': True, 'validate_assignment': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

name: str | None

classmethod pattern_category(v)

process_date: 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, used: List[str] | None = None, process_date: str | None = None)

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

full_name: str | None

has_attribute: List[str] | None

id: str

iri: str | None

linkml_meta: ClassVar[LinkMLMeta] = LinkMLMeta(root={'from_schema': 'https://identifiers.org/brain-bican/library-generation-schema', 'in_subset': ['bican', 'library_generation'], 'mixins': ['ProvActivity'], 'slot_usage': {'category': {'name': 'category', 'pattern': '^bican:[A-Z][A-Za-z]+$'}, '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', 'strict': False, 'use_enum_values': True, 'validate_assignment': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

name: str | None

classmethod pattern_category(v)

process_date: 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, used: List[str] | None = None, process_date: str | None = None)

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

full_name: str | None

has_attribute: List[str] | None

id: str

iri: str | None

linkml_meta: ClassVar[LinkMLMeta] = LinkMLMeta(root={'from_schema': 'https://identifiers.org/brain-bican/library-generation-schema', 'in_subset': ['bican', 'library_generation'], 'mixins': ['ProvActivity'], 'slot_usage': {'category': {'name': 'category', 'pattern': '^bican:[A-Z][A-Za-z]+$'}, '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', 'strict': False, 'use_enum_values': True, 'validate_assignment': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

name: str | None

classmethod pattern_category(v)

process_date: 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.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)

Bases: Entity

Checksum values associated with digital entities.

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

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

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

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

checksum_algorithm: DigestType | None

deprecated: bool | None

description: str | None

has_attribute: List[str] | None

id: str

iri: str | None

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

model_config: ClassVar[ConfigDict] = {'arbitrary_types_allowed': True, 'extra': 'forbid', 'strict': False, 'use_enum_values': True, 'validate_assignment': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

name: str | None

type: List[str] | None

value: str | None

class bkbit.models.library_generation.ChemicalEntityOrGeneOrGeneProduct

Bases: ConfiguredBaseModel

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

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

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

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

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

model_config: ClassVar[ConfigDict] = {'arbitrary_types_allowed': True, 'extra': 'forbid', 'strict': False, 'use_enum_values': True, 'validate_assignment': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class bkbit.models.library_generation.ConfiguredBaseModel

Bases: BaseModel

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

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

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

model_config: ClassVar[ConfigDict] = {'arbitrary_types_allowed': True, 'extra': 'forbid', 'strict': False, 'use_enum_values': True, 'validate_assignment': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

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

Bases: InformationContentEntity

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

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

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

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

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

creation_date: date | None

deprecated: bool | None

description: str | None

format: str | None

full_name: str | None

has_attribute: List[str] | None

id: str

iri: str | None

license: str | None

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

model_config: ClassVar[ConfigDict] = {'arbitrary_types_allowed': True, 'extra': 'forbid', 'strict': False, 'use_enum_values': True, 'validate_assignment': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

name: str | None

provided_by: List[str] | None

rights: str | None

synonym: List[str] | None

type: List[str] | None

xref: List[str] | None

class bkbit.models.library_generation.DigestType(value)

Bases: str, Enum

An enumeration.

MD5 = 'spdx:checksumAlgorithm_md5'

SHA1 = 'spdx:checksumAlgorithm_sha1'

SHA256 = 'spdx:checksumAlgorithm_sha256'

class bkbit.models.library_generation.DigitalAsset(*, id: str, iri: str | None = None, category: List[Literal['https://identifiers.org/brain-bican/vocab/DigitalAsset', 'bican:DigitalAsset']] = ['bican:DigitalAsset'], type: List[str] | None = None, name: str | None = None, description: str | None = None, has_attribute: List[str] | None = None, deprecated: bool | None = None, provided_by: List[str] | None = None, xref: List[str] | None = None, full_name: str | None = None, synonym: List[str] | None = None, license: str | None = None, rights: str | None = None, format: str | None = None, creation_date: date | None = None, was_derived_from: str | None = None, was_generated_by: str | None = None, digest: List[Checksum | str] | None = None, content_url: str | None = None, data_type: str | None = None)

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: str | None

creation_date: date | None

data_type: str | None

deprecated: bool | None

description: str | None

digest: List[Checksum | str] | None

format: str | None

full_name: str | None

has_attribute: List[str] | None

id: str

iri: str | None

license: str | None

linkml_meta: ClassVar[LinkMLMeta] = LinkMLMeta(root={'from_schema': 'https://identifiers.org/brain-bican/library-generation-schema', 'mixins': ['ProvEntity'], 'slot_usage': {'category': {'name': 'category', 'pattern': '^bican:[A-Z][A-Za-z]+$'}, 'content_url': {'name': 'content_url'}, 'digest': {'name': 'digest'}, 'was_derived_from': {'name': 'was_derived_from', 'range': 'LibraryPool'}}})

model_config: ClassVar[ConfigDict] = {'arbitrary_types_allowed': True, 'extra': 'forbid', 'strict': False, 'use_enum_values': True, 'validate_assignment': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

name: str | None

classmethod pattern_category(v)

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, used: str | None = None)

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

full_name: str | None

has_attribute: List[str] | None

id: str

iri: str | None

linkml_meta: ClassVar[LinkMLMeta] = LinkMLMeta(root={'from_schema': 'https://identifiers.org/brain-bican/library-generation-schema', 'in_subset': ['bican', 'library_generation'], 'mixins': ['ProvActivity'], 'slot_usage': {'category': {'name': 'category', 'pattern': '^bican:[A-Z][A-Za-z]+$'}, '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', 'strict': False, 'use_enum_values': True, 'validate_assignment': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

name: str | None

classmethod pattern_category(v)

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, annotates: str | None = None)

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:Specimen%20Dissected%20ROI'], 'from_schema': 'https://identifiers.org/brain-bican/library-generation-schema', 'in_subset': ['bican', 'tissue_specimen'], 'mixins': ['ProvEntity'], 'slot_usage': {'category': {'name': 'category', 'pattern': '^bican:[A-Z][A-Za-z]+$'}, 'name': {'description': 'Name of a polygon annotated on a brain slab image delineating a region of interest (ROI) for a tissue sample dissectioning.', 'local_names': {'NIMP': {'local_name_source': 'NIMP', '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'}}})

model_config: ClassVar[ConfigDict] = {'arbitrary_types_allowed': True, 'extra': 'forbid', 'strict': False, 'use_enum_values': True, 'validate_assignment': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

name: str | None

classmethod pattern_category(v)

type: List[str] | None

was_derived_from: str | None

was_generated_by: 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, was_derived_from: List[str] | None = None, was_generated_by: str | None = None, dissociated_cell_sample_cell_prep_type: DissociatedCellSampleCellPrepType | None = None, dissociated_cell_oligo_tag_name: DissociatedCellSampleCellLabelBarcode | None = None)

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']]

deprecated: bool | None

description: str | None

dissociated_cell_oligo_tag_name: DissociatedCellSampleCellLabelBarcode | None

dissociated_cell_sample_cell_prep_type: DissociatedCellSampleCellPrepType | None

full_name: str | None

has_attribute: List[str] | None

id: str

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': {'category': {'name': 'category', 'pattern': '^bican:[A-Z][A-Za-z]+$'}, 'name': {'description': 'Name of a collection of dissociated cells or nuclei derived from dissociation of a tissue sample.', 'exact_mappings': ['NIMP:PD-RQRWHS40'], 'local_names': {'NIMP': {'local_name_source': 'NIMP', 'local_name_value': 'dissociated_cell_sample_local_name'}}, 'name': 'name', 'slot_uri': 'bican:65e2c7da-9eb4-45b2-8ccb-d69ef9785ee2'}, 'was_derived_from': {'description': 'The input tissue sample(s) from which dissociated cell sample was derived from.', 'exact_mappings': ['NIMP:has_parent'], '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'}}})

model_config: ClassVar[ConfigDict] = {'arbitrary_types_allowed': True, 'extra': 'forbid', 'strict': False, 'use_enum_values': True, 'validate_assignment': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

name: str | None

classmethod pattern_category(v)

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.DissociatedCellSampleCellLabelBarcode(value)

Bases: str, Enum

An enumeration.

CMO301 = 'CMO301'

CMO302 = 'CMO302'

CMO303 = 'CMO303'

CMO304 = 'CMO304'

CMO305 = 'CMO305'

CMO306 = 'CMO306'

CMO307 = 'CMO307'

CMO308 = 'CMO308'

CMO309 = 'CMO309'

CMO310 = 'CMO310'

CMO311 = 'CMO311'

CMO312 = 'CMO312'

number_2nt_001 = '2nt-001'

number_2nt_002 = '2nt-002'

number_2nt_003 = '2nt-003'

number_2nt_004 = '2nt-004'

number_3nt_001 = '3nt-001'

number_3nt_002 = '3nt-002'

number_3nt_003 = '3nt-003'

number_3nt_004 = '3nt-004'

number_3nt_005 = '3nt-005'

number_3nt_006 = '3nt-006'

class bkbit.models.library_generation.DissociatedCellSampleCellPrepType(value)

Bases: str, Enum

An enumeration.

Cells = 'Cells'

Nuclei = '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, in_taxon: List[str] | None = None, in_taxon_label: str | None = None, was_derived_from: str | None = None, was_generated_by: str | None = None, biological_sex: Sex | None = None, age_at_death_description: str | None = None, age_at_death_reference_point: AgeAtDeathReferencePoint | None = None, age_at_death_unit: AgeAtDeathUnit | None = None, age_at_death_value: float | None = None, donor_species: str | None = None)

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.

age_at_death_description: str | None

age_at_death_reference_point: AgeAtDeathReferencePoint | None

age_at_death_unit: AgeAtDeathUnit | None

age_at_death_value: float | None

biological_sex: Sex | None

category: List[Literal['https://identifiers.org/brain-bican/vocab/Donor', 'bican:Donor']]

deprecated: bool | None

description: str | None

donor_species: str | None

full_name: str | None

has_attribute: List[str] | None

id: str

in_taxon: List[str] | None

in_taxon_label: str | None

iri: str | None

linkml_meta: ClassVar[LinkMLMeta] = LinkMLMeta(root={'exact_mappings': ['NIMP:Donor'], 'from_schema': 'https://identifiers.org/brain-bican/library-generation-schema', 'mixins': ['thing with taxon', 'ProvEntity'], 'slot_usage': {'category': {'name': 'category', 'pattern': '^bican:[A-Z][A-Za-z]+$'}, 'name': {'description': 'Name of person or organism that is the source of a biological sample for scientific study.  Many biological samples are generated from a single donor.', 'local_names': {'NIMP': {'local_name_source': 'NIMP', 'local_name_value': 'donor_local_id'}}, 'name': 'name'}}})

model_config: ClassVar[ConfigDict] = {'arbitrary_types_allowed': True, 'extra': 'forbid', 'strict': False, 'use_enum_values': True, 'validate_assignment': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

name: str | None

classmethod pattern_category(v)

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, was_derived_from: List[str] | None = None, was_generated_by: str | None = None, enrichment_population: str | None = None, cell_source_oligo_name: str | None = None, histone_modification_marker: str | None = None)

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_source_oligo_name: str | None

deprecated: bool | None

description: str | None

enrichment_population: str | None

full_name: str | None

has_attribute: List[str] | None

histone_modification_marker: str | None

id: str

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': {'category': {'name': 'category', 'pattern': '^bican:[A-Z][A-Za-z]+$'}, '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': ['NIMP:PD-BERWTM41'], 'local_names': {'NIMP': {'local_name_source': 'NIMP', 'local_name_value': 'enriched_cell_sample_local_name'}}, 'name': 'name', 'slot_uri': 'bican:bb3fc701-23a7-45c1-890d-7471730e0ec1'}, 'was_derived_from': {'description': 'The dissociated or enriched cell sample(s) from which the enriched cell sample was derived from.', 'exact_mappings': ['NIMP:has_parent'], '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'}}})

model_config: ClassVar[ConfigDict] = {'arbitrary_types_allowed': True, 'extra': 'forbid', 'strict': False, 'use_enum_values': True, 'validate_assignment': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

name: str | None

classmethod pattern_category(v)

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, used: str | None = None)

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

full_name: str | None

has_attribute: List[str] | None

id: str

iri: str | None

linkml_meta: ClassVar[LinkMLMeta] = LinkMLMeta(root={'from_schema': 'https://identifiers.org/brain-bican/library-generation-schema', 'in_subset': ['bican', 'library_generation'], 'mixins': ['ProvActivity'], 'slot_usage': {'category': {'name': 'category', 'pattern': '^bican:[A-Z][A-Za-z]+$'}, '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', 'strict': False, 'use_enum_values': True, 'validate_assignment': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

name: str | None

classmethod pattern_category(v)

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)

Bases: ConfiguredBaseModel

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

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

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

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

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

deprecated: bool | None

description: str | None

has_attribute: List[str] | None

id: str

iri: str | None

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

model_config: ClassVar[ConfigDict] = {'arbitrary_types_allowed': True, 'extra': 'forbid', 'strict': False, 'use_enum_values': True, 'validate_assignment': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

name: str | None

type: List[str] | None

class bkbit.models.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, in_taxon: List[str] | None = None, in_taxon_label: str | None = None, has_biological_sequence: str | None = None, symbol: str | None = None)

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

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

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

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

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

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

deprecated: bool | None

description: str | None

full_name: str | None

has_attribute: List[str] | None

has_biological_sequence: str | None

id: str

in_taxon: List[str] | None

in_taxon_label: str | None

iri: str | None

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

model_config: ClassVar[ConfigDict] = {'arbitrary_types_allowed': True, 'extra': 'forbid', 'strict': False, 'use_enum_values': True, 'validate_assignment': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

name: str | None

provided_by: List[str] | None

symbol: str | None

synonym: List[str] | None

type: List[str] | None

xref: List[str] | None

class bkbit.models.library_generation.GeneOrGeneProduct(*, name: str | None = None)

Bases: MacromolecularMachineMixin

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

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

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

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

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

model_config: ClassVar[ConfigDict] = {'arbitrary_types_allowed': True, 'extra': 'forbid', 'strict': False, 'use_enum_values': True, 'validate_assignment': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

name: str | None

class bkbit.models.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, in_taxon: List[str] | None = None, in_taxon_label: str | None = None, has_biological_sequence: str | None = None)

Bases: GenomicEntity, BiologicalEntity, PhysicalEssence, OntologyClass

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

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

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

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

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

deprecated: bool | None

description: str | None

full_name: str | None

has_attribute: List[str] | None

has_biological_sequence: str | None

id: str

in_taxon: List[str] | None

in_taxon_label: str | None

iri: str | None

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

model_config: ClassVar[ConfigDict] = {'arbitrary_types_allowed': True, 'extra': 'forbid', 'strict': False, 'use_enum_values': True, 'validate_assignment': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

name: str | None

provided_by: List[str] | None

synonym: List[str] | None

type: List[str] | None

xref: List[str] | None

class bkbit.models.library_generation.GenomicEntity(*, has_biological_sequence: str | None = None)

Bases: ConfiguredBaseModel

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

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

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

has_biological_sequence: str | None

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

model_config: ClassVar[ConfigDict] = {'arbitrary_types_allowed': True, 'extra': 'forbid', 'strict': False, 'use_enum_values': True, 'validate_assignment': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class bkbit.models.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, license: str | None = None, rights: str | None = None, format: str | None = None, creation_date: date | None = None)

Bases: NamedThing

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

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

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

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

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

creation_date: date | None

deprecated: bool | None

description: str | None

format: str | None

full_name: str | None

has_attribute: List[str] | None

id: str

iri: str | None

license: str | None

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

model_config: ClassVar[ConfigDict] = {'arbitrary_types_allowed': True, 'extra': 'forbid', 'strict': False, 'use_enum_values': True, 'validate_assignment': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

name: str | None

provided_by: List[str] | None

rights: str | None

synonym: List[str] | None

type: List[str] | None

xref: List[str] | None

class bkbit.models.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, was_derived_from: str | None = None, was_generated_by: str | None = None, library_avg_size_bp: int | None = None, library_concentration_nm: float | None = None, library_prep_pass_fail: LibraryPrepPassFail | None = None, library_quantification_fmol: float | None = None, library_quantification_ng: float | None = None, R1_R2_index_name: LibraryR1R2Index | None = None)

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.

R1_R2_index_name: LibraryR1R2Index | None

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

deprecated: bool | None

description: str | None

full_name: str | None

has_attribute: List[str] | None

id: str

iri: str | None

library_avg_size_bp: int | None

library_concentration_nm: float | None

library_prep_pass_fail: LibraryPrepPassFail | None

library_quantification_fmol: float | None

library_quantification_ng: float | 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': {'category': {'name': 'category', 'pattern': '^bican:[A-Z][A-Za-z]+$'}, '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': ['NIMP:PD-AJJUCC35'], 'local_names': {'NIMP': {'local_name_source': 'NIMP', 'local_name_value': 'library_local_name'}}, 'name': 'name', 'slot_uri': 'bican:f717e254-3630-4342-be7b-4d56376e7afe'}, '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.', 'exact_mappings': ['NIMP:has_parent'], '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'}}})

model_config: ClassVar[ConfigDict] = {'arbitrary_types_allowed': True, 'extra': 'forbid', 'strict': False, 'use_enum_values': True, 'validate_assignment': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

name: str | None

classmethod pattern_category(v)

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.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, was_derived_from: str | None = None, was_generated_by: str | None = None)

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

full_name: str | None

has_attribute: List[str] | None

id: str

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': {'category': {'name': 'category', 'pattern': '^bican:[A-Z][A-Za-z]+$'}, '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': ['NIMP:PD-XCXCCC35'], 'local_names': {'NIMP': {'local_name_source': 'NIMP', 'local_name_value': 'library_aliquot_local_name'}}, 'name': 'name', 'slot_uri': 'bican:34191bad-d167-4335-8224-ade897d3728e'}, 'was_derived_from': {'description': 'The input library from which the library aliquot was derived from.', 'exact_mappings': ['NIMP:has_parent'], 'name': 'was_derived_from', 'range': 'Library'}}})

model_config: ClassVar[ConfigDict] = {'arbitrary_types_allowed': True, 'extra': 'forbid', 'strict': False, 'use_enum_values': True, 'validate_assignment': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

name: str | None

classmethod pattern_category(v)

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, used: str | None = None, library_method: LibraryTechnique | None = None, library_creation_date: date | None = None, library_input_ng: float | None = None, library_prep_set: str | None = None)

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

full_name: str | None

has_attribute: List[str] | None

id: str

iri: str | None

library_creation_date: date | None

library_input_ng: float | None

library_method: LibraryTechnique | None

library_prep_set: 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': {'category': {'name': 'category', 'pattern': '^bican:[A-Z][A-Za-z]+$'}, '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', 'strict': False, 'use_enum_values': True, 'validate_assignment': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

name: str | None

classmethod pattern_category(v)

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, was_derived_from: List[str] | None = None, was_generated_by: str | None = None, library_pool_tube_internal_label: str | None = None)

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

full_name: str | None

has_attribute: List[str] | None

id: str

iri: str | None

library_pool_tube_internal_label: 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': {'category': {'name': 'category', 'pattern': '^bican:[A-Z][A-Za-z]+$'}, 'name': {'description': 'Library lab\'s library pool name.  For some labs this may be the same as "Libray 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': ['NIMP:PD-KKIAPA48'], 'local_names': {'NIMP': {'local_name_source': 'NIMP', 'local_name_value': 'library_pool_local_name'}}, 'name': 'name', 'slot_uri': 'bican:29e0578b-6427-4c93-b29b-bde27fbadeec'}, 'was_derived_from': {'description': 'The input aliquot(s) from which the library pool was derived from.', 'exact_mappings': ['NIMP:has_parent'], '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'}}})

model_config: ClassVar[ConfigDict] = {'arbitrary_types_allowed': True, 'extra': 'forbid', 'strict': False, 'use_enum_values': True, 'validate_assignment': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

name: str | None

classmethod pattern_category(v)

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.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, used: List[str] | None = None, process_date: str | None = None)

Bases: ProvActivity, Procedure

The process of constructing of a libray 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

full_name: str | None

has_attribute: List[str] | None

id: str

iri: str | None

linkml_meta: ClassVar[LinkMLMeta] = LinkMLMeta(root={'from_schema': 'https://identifiers.org/brain-bican/library-generation-schema', 'in_subset': ['bican', 'library_generation'], 'mixins': ['ProvActivity'], 'slot_usage': {'category': {'name': 'category', 'pattern': '^bican:[A-Z][A-Za-z]+$'}, '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', 'strict': False, 'use_enum_values': True, 'validate_assignment': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

name: str | None

classmethod pattern_category(v)

process_date: 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)

Bases: str, Enum

An enumeration.

Fail = 'Fail'

Low_QC = 'Low QC'

Not_evaluated = 'Not evaluated'

Pass = 'Pass'

class bkbit.models.library_generation.LibraryR1R2Index(value)

Bases: str, Enum

An enumeration.

SI_NA_A1 = 'SI-NA-A1'

SI_NA_A10 = 'SI-NA-A10'

SI_NA_A11 = 'SI-NA-A11'

SI_NA_A12 = 'SI-NA-A12'

SI_NA_A2 = 'SI-NA-A2'

SI_NA_A3 = 'SI-NA-A3'

SI_NA_A4 = 'SI-NA-A4'

SI_NA_A5 = 'SI-NA-A5'

SI_NA_A6 = 'SI-NA-A6'

SI_NA_A7 = 'SI-NA-A7'

SI_NA_A8 = 'SI-NA-A8'

SI_NA_A9 = 'SI-NA-A9'

SI_NA_B1 = 'SI-NA-B1'

SI_NA_B10 = 'SI-NA-B10'

SI_NA_B11 = 'SI-NA-B11'

SI_NA_B12 = 'SI-NA-B12'

SI_NA_B2 = 'SI-NA-B2'

SI_NA_B3 = 'SI-NA-B3'

SI_NA_B4 = 'SI-NA-B4'

SI_NA_B5 = 'SI-NA-B5'

SI_NA_B6 = 'SI-NA-B6'

SI_NA_B7 = 'SI-NA-B7'

SI_NA_B8 = 'SI-NA-B8'

SI_NA_B9 = 'SI-NA-B9'

SI_NA_C1 = 'SI-NA-C1'

SI_NA_C10 = 'SI-NA-C10'

SI_NA_C11 = 'SI-NA-C11'

SI_NA_C12 = 'SI-NA-C12'

SI_NA_C2 = 'SI-NA-C2'

SI_NA_C3 = 'SI-NA-C3'

SI_NA_C4 = 'SI-NA-C4'

SI_NA_C5 = 'SI-NA-C5'

SI_NA_C6 = 'SI-NA-C6'

SI_NA_C7 = 'SI-NA-C7'

SI_NA_C8 = 'SI-NA-C8'

SI_NA_C9 = 'SI-NA-C9'

SI_NA_D1 = 'SI-NA-D1'

SI_NA_D10 = 'SI-NA-D10'

SI_NA_D11 = 'SI-NA-D11'

SI_NA_D12 = 'SI-NA-D12'

SI_NA_D2 = 'SI-NA-D2'

SI_NA_D3 = 'SI-NA-D3'

SI_NA_D4 = 'SI-NA-D4'

SI_NA_D5 = 'SI-NA-D5'

SI_NA_D6 = 'SI-NA-D6'

SI_NA_D7 = 'SI-NA-D7'

SI_NA_D8 = 'SI-NA-D8'

SI_NA_D9 = 'SI-NA-D9'

SI_NA_E1 = 'SI-NA-E1'

SI_NA_E10 = 'SI-NA-E10'

SI_NA_E11 = 'SI-NA-E11'

SI_NA_E12 = 'SI-NA-E12'

SI_NA_E2 = 'SI-NA-E2'

SI_NA_E3 = 'SI-NA-E3'

SI_NA_E4 = 'SI-NA-E4'

SI_NA_E5 = 'SI-NA-E5'

SI_NA_E6 = 'SI-NA-E6'

SI_NA_E7 = 'SI-NA-E7'

SI_NA_E8 = 'SI-NA-E8'

SI_NA_E9 = 'SI-NA-E9'

SI_NA_F1 = 'SI-NA-F1'

SI_NA_F10 = 'SI-NA-F10'

SI_NA_F11 = 'SI-NA-F11'

SI_NA_F12 = 'SI-NA-F12'

SI_NA_F2 = 'SI-NA-F2'

SI_NA_F3 = 'SI-NA-F3'

SI_NA_F4 = 'SI-NA-F4'

SI_NA_F5 = 'SI-NA-F5'

SI_NA_F6 = 'SI-NA-F6'

SI_NA_F7 = 'SI-NA-F7'

SI_NA_F8 = 'SI-NA-F8'

SI_NA_F9 = 'SI-NA-F9'

SI_NA_G1 = 'SI-NA-G1'

SI_NA_G10 = 'SI-NA-G10'

SI_NA_G11 = 'SI-NA-G11'

SI_NA_G12 = 'SI-NA-G12'

SI_NA_G2 = 'SI-NA-G2'

SI_NA_G3 = 'SI-NA-G3'

SI_NA_G4 = 'SI-NA-G4'

SI_NA_G5 = 'SI-NA-G5'

SI_NA_G6 = 'SI-NA-G6'

SI_NA_G7 = 'SI-NA-G7'

SI_NA_G8 = 'SI-NA-G8'

SI_NA_G9 = 'SI-NA-G9'

SI_NA_H1 = 'SI-NA-H1'

SI_NA_H10 = 'SI-NA-H10'

SI_NA_H11 = 'SI-NA-H11'

SI_NA_H12 = 'SI-NA-H12'

SI_NA_H2 = 'SI-NA-H2'

SI_NA_H3 = 'SI-NA-H3'

SI_NA_H4 = 'SI-NA-H4'

SI_NA_H5 = 'SI-NA-H5'

SI_NA_H6 = 'SI-NA-H6'

SI_NA_H7 = 'SI-NA-H7'

SI_NA_H8 = 'SI-NA-H8'

SI_NA_H9 = 'SI-NA-H9'

SI_NN_A1 = 'SI-NN-A1'

SI_NN_A10 = 'SI-NN-A10'

SI_NN_A11 = 'SI-NN-A11'

SI_NN_A12 = 'SI-NN-A12'

SI_NN_A2 = 'SI-NN-A2'

SI_NN_A3 = 'SI-NN-A3'

SI_NN_A4 = 'SI-NN-A4'

SI_NN_A5 = 'SI-NN-A5'

SI_NN_A6 = 'SI-NN-A6'

SI_NN_A7 = 'SI-NN-A7'

SI_NN_A8 = 'SI-NN-A8'

SI_NN_A9 = 'SI-NN-A9'

SI_NN_B1 = 'SI-NN-B1'

SI_NN_B10 = 'SI-NN-B10'

SI_NN_B11 = 'SI-NN-B11'

SI_NN_B12 = 'SI-NN-B12'

SI_NN_B2 = 'SI-NN-B2'

SI_NN_B3 = 'SI-NN-B3'

SI_NN_B4 = 'SI-NN-B4'

SI_NN_B5 = 'SI-NN-B5'

SI_NN_B6 = 'SI-NN-B6'

SI_NN_B7 = 'SI-NN-B7'

SI_NN_B8 = 'SI-NN-B8'

SI_NN_B9 = 'SI-NN-B9'

SI_NN_C1 = 'SI-NN-C1'

SI_NN_C10 = 'SI-NN-C10'

SI_NN_C11 = 'SI-NN-C11'

SI_NN_C12 = 'SI-NN-C12'

SI_NN_C2 = 'SI-NN-C2'

SI_NN_C3 = 'SI-NN-C3'

SI_NN_C4 = 'SI-NN-C4'

SI_NN_C5 = 'SI-NN-C5'

SI_NN_C6 = 'SI-NN-C6'

SI_NN_C7 = 'SI-NN-C7'

SI_NN_C8 = 'SI-NN-C8'

SI_NN_C9 = 'SI-NN-C9'

SI_NN_D1 = 'SI-NN-D1'

SI_NN_D10 = 'SI-NN-D10'

SI_NN_D11 = 'SI-NN-D11'

SI_NN_D12 = 'SI-NN-D12'

SI_NN_D2 = 'SI-NN-D2'

SI_NN_D3 = 'SI-NN-D3'

SI_NN_D4 = 'SI-NN-D4'

SI_NN_D5 = 'SI-NN-D5'

SI_NN_D6 = 'SI-NN-D6'

SI_NN_D7 = 'SI-NN-D7'

SI_NN_D8 = 'SI-NN-D8'

SI_NN_D9 = 'SI-NN-D9'

SI_NN_E1 = 'SI-NN-E1'

SI_NN_E10 = 'SI-NN-E10'

SI_NN_E11 = 'SI-NN-E11'

SI_NN_E12 = 'SI-NN-E12'

SI_NN_E2 = 'SI-NN-E2'

SI_NN_E3 = 'SI-NN-E3'

SI_NN_E4 = 'SI-NN-E4'

SI_NN_E5 = 'SI-NN-E5'

SI_NN_E6 = 'SI-NN-E6'

SI_NN_E7 = 'SI-NN-E7'

SI_NN_E8 = 'SI-NN-E8'

SI_NN_E9 = 'SI-NN-E9'

SI_NN_F1 = 'SI-NN-F1'

SI_NN_F10 = 'SI-NN-F10'

SI_NN_F11 = 'SI-NN-F11'

SI_NN_F12 = 'SI-NN-F12'

SI_NN_F2 = 'SI-NN-F2'

SI_NN_F3 = 'SI-NN-F3'

SI_NN_F4 = 'SI-NN-F4'

SI_NN_F5 = 'SI-NN-F5'

SI_NN_F6 = 'SI-NN-F6'

SI_NN_F7 = 'SI-NN-F7'

SI_NN_F8 = 'SI-NN-F8'

SI_NN_F9 = 'SI-NN-F9'

SI_NN_G1 = 'SI-NN-G1'

SI_NN_G10 = 'SI-NN-G10'

SI_NN_G11 = 'SI-NN-G11'

SI_NN_G12 = 'SI-NN-G12'

SI_NN_G2 = 'SI-NN-G2'

SI_NN_G3 = 'SI-NN-G3'

SI_NN_G4 = 'SI-NN-G4'

SI_NN_G5 = 'SI-NN-G5'

SI_NN_G6 = 'SI-NN-G6'

SI_NN_G7 = 'SI-NN-G7'

SI_NN_G8 = 'SI-NN-G8'

SI_NN_G9 = 'SI-NN-G9'

SI_NN_H1 = 'SI-NN-H1'

SI_NN_H10 = 'SI-NN-H10'

SI_NN_H11 = 'SI-NN-H11'

SI_NN_H12 = 'SI-NN-H12'

SI_NN_H2 = 'SI-NN-H2'

SI_NN_H3 = 'SI-NN-H3'

SI_NN_H4 = 'SI-NN-H4'

SI_NN_H5 = 'SI-NN-H5'

SI_NN_H6 = 'SI-NN-H6'

SI_NN_H7 = 'SI-NN-H7'

SI_NN_H8 = 'SI-NN-H8'

SI_NN_H9 = 'SI-NN-H9'

SI_TT_A1 = 'SI-TT-A1'

SI_TT_A10 = 'SI-TT-A10'

SI_TT_A11 = 'SI-TT-A11'

SI_TT_A12 = 'SI-TT-A12'

SI_TT_A2 = 'SI-TT-A2'

SI_TT_A3 = 'SI-TT-A3'

SI_TT_A4 = 'SI-TT-A4'

SI_TT_A5 = 'SI-TT-A5'

SI_TT_A6 = 'SI-TT-A6'

SI_TT_A7 = 'SI-TT-A7'

SI_TT_A8 = 'SI-TT-A8'

SI_TT_A9 = 'SI-TT-A9'

SI_TT_B1 = 'SI-TT-B1'

SI_TT_B10 = 'SI-TT-B10'

SI_TT_B11 = 'SI-TT-B11'

SI_TT_B12 = 'SI-TT-B12'

SI_TT_B2 = 'SI-TT-B2'

SI_TT_B3 = 'SI-TT-B3'

SI_TT_B4 = 'SI-TT-B4'

SI_TT_B5 = 'SI-TT-B5'

SI_TT_B6 = 'SI-TT-B6'

SI_TT_B7 = 'SI-TT-B7'

SI_TT_B8 = 'SI-TT-B8'

SI_TT_B9 = 'SI-TT-B9'

SI_TT_C1 = 'SI-TT-C1'

SI_TT_C10 = 'SI-TT-C10'

SI_TT_C11 = 'SI-TT-C11'

SI_TT_C12 = 'SI-TT-C12'

SI_TT_C2 = 'SI-TT-C2'

SI_TT_C3 = 'SI-TT-C3'

SI_TT_C4 = 'SI-TT-C4'

SI_TT_C5 = 'SI-TT-C5'

SI_TT_C6 = 'SI-TT-C6'

SI_TT_C7 = 'SI-TT-C7'

SI_TT_C8 = 'SI-TT-C8'

SI_TT_C9 = 'SI-TT-C9'

SI_TT_D1 = 'SI-TT-D1'

SI_TT_D10 = 'SI-TT-D10'

SI_TT_D11 = 'SI-TT-D11'

SI_TT_D12 = 'SI-TT-D12'

SI_TT_D2 = 'SI-TT-D2'

SI_TT_D3 = 'SI-TT-D3'

SI_TT_D4 = 'SI-TT-D4'

SI_TT_D5 = 'SI-TT-D5'

SI_TT_D6 = 'SI-TT-D6'

SI_TT_D7 = 'SI-TT-D7'

SI_TT_D8 = 'SI-TT-D8'

SI_TT_D9 = 'SI-TT-D9'

SI_TT_E1 = 'SI-TT-E1'

SI_TT_E10 = 'SI-TT-E10'

SI_TT_E11 = 'SI-TT-E11'

SI_TT_E12 = 'SI-TT-E12'

SI_TT_E2 = 'SI-TT-E2'

SI_TT_E3 = 'SI-TT-E3'

SI_TT_E4 = 'SI-TT-E4'

SI_TT_E5 = 'SI-TT-E5'

SI_TT_E6 = 'SI-TT-E6'

SI_TT_E7 = 'SI-TT-E7'

SI_TT_E8 = 'SI-TT-E8'

SI_TT_E9 = 'SI-TT-E9'

SI_TT_F1 = 'SI-TT-F1'

SI_TT_F10 = 'SI-TT-F10'

SI_TT_F11 = 'SI-TT-F11'

SI_TT_F12 = 'SI-TT-F12'

SI_TT_F2 = 'SI-TT-F2'

SI_TT_F3 = 'SI-TT-F3'

SI_TT_F4 = 'SI-TT-F4'

SI_TT_F5 = 'SI-TT-F5'

SI_TT_F6 = 'SI-TT-F6'

SI_TT_F7 = 'SI-TT-F7'

SI_TT_F8 = 'SI-TT-F8'

SI_TT_F9 = 'SI-TT-F9'

SI_TT_G1 = 'SI-TT-G1'

SI_TT_G10 = 'SI-TT-G10'

SI_TT_G11 = 'SI-TT-G11'

SI_TT_G12 = 'SI-TT-G12'

SI_TT_G2 = 'SI-TT-G2'

SI_TT_G3 = 'SI-TT-G3'

SI_TT_G4 = 'SI-TT-G4'

SI_TT_G5 = 'SI-TT-G5'

SI_TT_G6 = 'SI-TT-G6'

SI_TT_G7 = 'SI-TT-G7'

SI_TT_G8 = 'SI-TT-G8'

SI_TT_G9 = 'SI-TT-G9'

SI_TT_H1 = 'SI-TT-H1'

SI_TT_H10 = 'SI-TT-H10'

SI_TT_H11 = 'SI-TT-H11'

SI_TT_H12 = 'SI-TT-H12'

SI_TT_H2 = 'SI-TT-H2'

SI_TT_H3 = 'SI-TT-H3'

SI_TT_H4 = 'SI-TT-H4'

SI_TT_H5 = 'SI-TT-H5'

SI_TT_H6 = 'SI-TT-H6'

SI_TT_H7 = 'SI-TT-H7'

SI_TT_H8 = 'SI-TT-H8'

SI_TT_H9 = 'SI-TT-H9'

SetB_A1 = 'SetB-A1'

SetB_A10 = 'SetB-A10'

SetB_A11 = 'SetB-A11'

SetB_A12 = 'SetB-A12'

SetB_A13 = 'SetB-A13'

SetB_A14 = 'SetB-A14'

SetB_A15 = 'SetB-A15'

SetB_A16 = 'SetB-A16'

SetB_A17 = 'SetB-A17'

SetB_A18 = 'SetB-A18'

SetB_A19 = 'SetB-A19'

SetB_A2 = 'SetB-A2'

SetB_A20 = 'SetB-A20'

SetB_A21 = 'SetB-A21'

SetB_A22 = 'SetB-A22'

SetB_A23 = 'SetB-A23'

SetB_A24 = 'SetB-A24'

SetB_A3 = 'SetB-A3'

SetB_A4 = 'SetB-A4'

SetB_A5 = 'SetB-A5'

SetB_A6 = 'SetB-A6'

SetB_A7 = 'SetB-A7'

SetB_A8 = 'SetB-A8'

SetB_A9 = 'SetB-A9'

SetB_B1 = 'SetB-B1'

SetB_B10 = 'SetB-B10'

SetB_B11 = 'SetB-B11'

SetB_B12 = 'SetB-B12'

SetB_B13 = 'SetB-B13'

SetB_B14 = 'SetB-B14'

SetB_B15 = 'SetB-B15'

SetB_B16 = 'SetB-B16'

SetB_B17 = 'SetB-B17'

SetB_B18 = 'SetB-B18'

SetB_B19 = 'SetB-B19'

SetB_B2 = 'SetB-B2'

SetB_B20 = 'SetB-B20'

SetB_B21 = 'SetB-B21'

SetB_B22 = 'SetB-B22'

SetB_B23 = 'SetB-B23'

SetB_B24 = 'SetB-B24'

SetB_B3 = 'SetB-B3'

SetB_B4 = 'SetB-B4'

SetB_B5 = 'SetB-B5'

SetB_B6 = 'SetB-B6'

SetB_B7 = 'SetB-B7'

SetB_B8 = 'SetB-B8'

SetB_B9 = 'SetB-B9'

SetB_C1 = 'SetB-C1'

SetB_C10 = 'SetB-C10'

SetB_C11 = 'SetB-C11'

SetB_C12 = 'SetB-C12'

SetB_C13 = 'SetB-C13'

SetB_C14 = 'SetB-C14'

SetB_C15 = 'SetB-C15'

SetB_C16 = 'SetB-C16'

SetB_C17 = 'SetB-C17'

SetB_C18 = 'SetB-C18'

SetB_C19 = 'SetB-C19'

SetB_C2 = 'SetB-C2'

SetB_C20 = 'SetB-C20'

SetB_C21 = 'SetB-C21'

SetB_C22 = 'SetB-C22'

SetB_C23 = 'SetB-C23'

SetB_C24 = 'SetB-C24'

SetB_C3 = 'SetB-C3'

SetB_C4 = 'SetB-C4'

SetB_C5 = 'SetB-C5'

SetB_C6 = 'SetB-C6'

SetB_C7 = 'SetB-C7'

SetB_C8 = 'SetB-C8'

SetB_C9 = 'SetB-C9'

SetB_D1 = 'SetB-D1'

SetB_D10 = 'SetB-D10'

SetB_D11 = 'SetB-D11'

SetB_D12 = 'SetB-D12'

SetB_D13 = 'SetB-D13'

SetB_D14 = 'SetB-D14'

SetB_D15 = 'SetB-D15'

SetB_D16 = 'SetB-D16'

SetB_D17 = 'SetB-D17'

SetB_D18 = 'SetB-D18'

SetB_D19 = 'SetB-D19'

SetB_D2 = 'SetB-D2'

SetB_D20 = 'SetB-D20'

SetB_D21 = 'SetB-D21'

SetB_D22 = 'SetB-D22'

SetB_D23 = 'SetB-D23'

SetB_D24 = 'SetB-D24'

SetB_D3 = 'SetB-D3'

SetB_D4 = 'SetB-D4'

SetB_D5 = 'SetB-D5'

SetB_D6 = 'SetB-D6'

SetB_D7 = 'SetB-D7'

SetB_D8 = 'SetB-D8'

SetB_D9 = 'SetB-D9'

SetB_E1 = 'SetB-E1'

SetB_E10 = 'SetB-E10'

SetB_E11 = 'SetB-E11'

SetB_E12 = 'SetB-E12'

SetB_E13 = 'SetB-E13'

SetB_E14 = 'SetB-E14'

SetB_E15 = 'SetB-E15'

SetB_E16 = 'SetB-E16'

SetB_E17 = 'SetB-E17'

SetB_E18 = 'SetB-E18'

SetB_E19 = 'SetB-E19'

SetB_E2 = 'SetB-E2'

SetB_E20 = 'SetB-E20'

SetB_E21 = 'SetB-E21'

SetB_E22 = 'SetB-E22'

SetB_E23 = 'SetB-E23'

SetB_E24 = 'SetB-E24'

SetB_E3 = 'SetB-E3'

SetB_E4 = 'SetB-E4'

SetB_E5 = 'SetB-E5'

SetB_E6 = 'SetB-E6'

SetB_E7 = 'SetB-E7'

SetB_E8 = 'SetB-E8'

SetB_E9 = 'SetB-E9'

SetB_F1 = 'SetB-F1'

SetB_F10 = 'SetB-F10'

SetB_F11 = 'SetB-F11'

SetB_F12 = 'SetB-F12'

SetB_F13 = 'SetB-F13'

SetB_F14 = 'SetB-F14'

SetB_F15 = 'SetB-F15'

SetB_F16 = 'SetB-F16'

SetB_F17 = 'SetB-F17'

SetB_F18 = 'SetB-F18'

SetB_F19 = 'SetB-F19'

SetB_F2 = 'SetB-F2'

SetB_F20 = 'SetB-F20'

SetB_F21 = 'SetB-F21'

SetB_F22 = 'SetB-F22'

SetB_F23 = 'SetB-F23'

SetB_F24 = 'SetB-F24'

SetB_F3 = 'SetB-F3'

SetB_F4 = 'SetB-F4'

SetB_F5 = 'SetB-F5'

SetB_F6 = 'SetB-F6'

SetB_F7 = 'SetB-F7'

SetB_F8 = 'SetB-F8'

SetB_F9 = 'SetB-F9'

SetB_G1 = 'SetB-G1'

SetB_G10 = 'SetB-G10'

SetB_G11 = 'SetB-G11'

SetB_G12 = 'SetB-G12'

SetB_G13 = 'SetB-G13'

SetB_G14 = 'SetB-G14'

SetB_G15 = 'SetB-G15'

SetB_G16 = 'SetB-G16'

SetB_G17 = 'SetB-G17'

SetB_G18 = 'SetB-G18'

SetB_G19 = 'SetB-G19'

SetB_G2 = 'SetB-G2'

SetB_G20 = 'SetB-G20'

SetB_G21 = 'SetB-G21'

SetB_G22 = 'SetB-G22'

SetB_G23 = 'SetB-G23'

SetB_G24 = 'SetB-G24'

SetB_G3 = 'SetB-G3'

SetB_G4 = 'SetB-G4'

SetB_G5 = 'SetB-G5'

SetB_G6 = 'SetB-G6'

SetB_G7 = 'SetB-G7'

SetB_G8 = 'SetB-G8'

SetB_G9 = 'SetB-G9'

SetB_H1 = 'SetB-H1'

SetB_H10 = 'SetB-H10'

SetB_H11 = 'SetB-H11'

SetB_H12 = 'SetB-H12'

SetB_H13 = 'SetB-H13'

SetB_H14 = 'SetB-H14'

SetB_H15 = 'SetB-H15'

SetB_H16 = 'SetB-H16'

SetB_H17 = 'SetB-H17'

SetB_H18 = 'SetB-H18'

SetB_H19 = 'SetB-H19'

SetB_H2 = 'SetB-H2'

SetB_H20 = 'SetB-H20'

SetB_H21 = 'SetB-H21'

SetB_H22 = 'SetB-H22'

SetB_H23 = 'SetB-H23'

SetB_H24 = 'SetB-H24'

SetB_H3 = 'SetB-H3'

SetB_H4 = 'SetB-H4'

SetB_H5 = 'SetB-H5'

SetB_H6 = 'SetB-H6'

SetB_H7 = 'SetB-H7'

SetB_H8 = 'SetB-H8'

SetB_H9 = 'SetB-H9'

SetB_I1 = 'SetB-I1'

SetB_I10 = 'SetB-I10'

SetB_I11 = 'SetB-I11'

SetB_I12 = 'SetB-I12'

SetB_I13 = 'SetB-I13'

SetB_I14 = 'SetB-I14'

SetB_I15 = 'SetB-I15'

SetB_I16 = 'SetB-I16'

SetB_I17 = 'SetB-I17'

SetB_I18 = 'SetB-I18'

SetB_I19 = 'SetB-I19'

SetB_I2 = 'SetB-I2'

SetB_I20 = 'SetB-I20'

SetB_I21 = 'SetB-I21'

SetB_I22 = 'SetB-I22'

SetB_I23 = 'SetB-I23'

SetB_I24 = 'SetB-I24'

SetB_I3 = 'SetB-I3'

SetB_I4 = 'SetB-I4'

SetB_I5 = 'SetB-I5'

SetB_I6 = 'SetB-I6'

SetB_I7 = 'SetB-I7'

SetB_I8 = 'SetB-I8'

class bkbit.models.library_generation.LibraryTechnique(value)

Bases: str, Enum

An enumeration.

DBiT_ATAC_seq = 'DBiT ATAC-seq'

DBiT_RNA_seq = 'DBiT RNA-seq'

MERFISH = 'MERFISH'

MethylC_Seq = 'MethylC-Seq'

SMARTSeqSC = 'SMARTSeqSC'

Slide_seq_MERFISH = 'Slide-seq MERFISH'

SmartSeq3 = 'SmartSeq3'

number_10XMultiome_CellHashingSEMICOLONATAC = '10XMultiome-CellHashing;ATAC'

number_10XMultiome_CellHashingSEMICOLONGEX = '10XMultiome-CellHashing;GEX'

number_10XMultiome_Cell_HashingSEMICOLONBarcode = '10XMultiome-Cell Hashing;Barcode'

number_10xATAC_V2FULL_STOP0 = '10xATAC_V2.0'

number_10xMultiomeSEMICOLONATAC = '10xMultiome;ATAC'

number_10xMultiomeSEMICOLONGEX = '10xMultiome;GEX'

number_10xV3FULL_STOP1 = '10xV3.1'

number_10xV3FULL_STOP1_CellPlexSEMICOLONBarcode = '10xV3.1_CellPlex;Barcode'

number_10xV3FULL_STOP1_CellPlexSEMICOLONGEX = '10xV3.1_CellPlex;GEX'

number_10xV3FULL_STOP1_HT = '10xV3.1_HT'

number_10xV3FULL_STOP1_HT_CellPlexSEMICOLONBarcode = '10xV3.1_HT_CellPlex;Barcode'

number_10xV3FULL_STOP1_HT_CellPlexSEMICOLONGEX = '10xV3.1_HT_CellPlex;GEX'

scATAC_seq = 'scATAC-seq'

snm3C_seq = 'snm3C-seq'

snmCT_seq = 'snmCT-seq'

whole_brain_MERFISH = 'whole brain MERFISH'

class bkbit.models.library_generation.LinkMLMeta(root: RootModelRootType = PydanticUndefined)

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)

Bases: ConfiguredBaseModel

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

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

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

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

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

model_config: ClassVar[ConfigDict] = {'arbitrary_types_allowed': True, 'extra': 'forbid', 'strict': False, 'use_enum_values': True, 'validate_assignment': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

name: str | None

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

Bases: SubjectOfInvestigation, PhysicalEntity

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

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

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

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

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

deprecated: bool | None

description: str | None

full_name: str | None

has_attribute: List[str] | None

id: str

iri: str | None

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

model_config: ClassVar[ConfigDict] = {'arbitrary_types_allowed': True, 'extra': 'forbid', 'strict': False, 'use_enum_values': True, 'validate_assignment': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

name: str | None

provided_by: List[str] | None

synonym: List[str] | None

type: List[str] | None

xref: List[str] | None

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

Bases: Entity

a databased entity or concept/class

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

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

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

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

deprecated: bool | None

description: str | None

full_name: str | None

has_attribute: List[str] | None

id: str

iri: str | None

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

model_config: ClassVar[ConfigDict] = {'arbitrary_types_allowed': True, 'extra': 'forbid', 'strict': False, 'use_enum_values': True, 'validate_assignment': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

name: str | None

provided_by: List[str] | None

synonym: List[str] | None

type: List[str] | None

xref: List[str] | None

class bkbit.models.library_generation.Occurrent

Bases: PhysicalEssenceOrOccurrent

A processual entity.

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

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

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

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

model_config: ClassVar[ConfigDict] = {'arbitrary_types_allowed': True, 'extra': 'forbid', 'strict': False, 'use_enum_values': True, 'validate_assignment': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class bkbit.models.library_generation.OntologyClass(*, id: str)

Bases: ConfiguredBaseModel

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

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

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

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

id: str

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

model_config: ClassVar[ConfigDict] = {'arbitrary_types_allowed': True, 'extra': 'forbid', 'strict': False, 'use_enum_values': True, 'validate_assignment': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class bkbit.models.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, has_taxonomic_rank: str | None = None)

Bases: NamedThing

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

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

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

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

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

deprecated: bool | None

description: str | None

full_name: str | None

has_attribute: List[str] | None

has_taxonomic_rank: str | None

id: str

iri: str | None

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

model_config: ClassVar[ConfigDict] = {'arbitrary_types_allowed': True, 'extra': 'forbid', 'strict': False, 'use_enum_values': True, 'validate_assignment': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

name: str | None

provided_by: List[str] | None

synonym: List[str] | None

type: List[str] | None

xref: List[str] | None

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

Bases: PhysicalEssence, NamedThing

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

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

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

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

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

deprecated: bool | None

description: str | None

full_name: str | None

has_attribute: List[str] | None

id: str

iri: str | None

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

model_config: ClassVar[ConfigDict] = {'arbitrary_types_allowed': True, 'extra': 'forbid', 'strict': False, 'use_enum_values': True, 'validate_assignment': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

name: str | None

provided_by: List[str] | None

synonym: List[str] | None

type: List[str] | None

xref: List[str] | None

class bkbit.models.library_generation.PhysicalEssence

Bases: PhysicalEssenceOrOccurrent

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

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

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

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

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

model_config: ClassVar[ConfigDict] = {'arbitrary_types_allowed': True, 'extra': 'forbid', 'strict': False, 'use_enum_values': True, 'validate_assignment': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class bkbit.models.library_generation.PhysicalEssenceOrOccurrent

Bases: ConfiguredBaseModel

Either a physical or processual entity.

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

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

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

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

model_config: ClassVar[ConfigDict] = {'arbitrary_types_allowed': True, 'extra': 'forbid', 'strict': False, 'use_enum_values': True, 'validate_assignment': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

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

Bases: ActivityAndBehavior, NamedThing

A series of actions conducted in a certain order or manner

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

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

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

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

deprecated: bool | None

description: str | None

full_name: str | None

has_attribute: List[str] | None

id: str

iri: str | None

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

model_config: ClassVar[ConfigDict] = {'arbitrary_types_allowed': True, 'extra': 'forbid', 'strict': False, 'use_enum_values': True, 'validate_assignment': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

name: str | None

provided_by: List[str] | None

synonym: List[str] | None

type: List[str] | None

xref: List[str] | None

class bkbit.models.library_generation.ProvActivity(*, used: str | None = None)

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/genome-prov-schema', 'mixin': True})

model_config: ClassVar[ConfigDict] = {'arbitrary_types_allowed': True, 'extra': 'forbid', 'strict': False, 'use_enum_values': True, 'validate_assignment': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

used: str | None

class bkbit.models.library_generation.ProvEntity(*, was_derived_from: str | None = None, was_generated_by: str | None = None)

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/genome-prov-schema', 'mixin': True})

model_config: ClassVar[ConfigDict] = {'arbitrary_types_allowed': True, 'extra': 'forbid', 'strict': False, 'use_enum_values': True, 'validate_assignment': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

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)

Bases: Annotation

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

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

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

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

has_numeric_value: float | None

has_unit: str | None

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

model_config: ClassVar[ConfigDict] = {'arbitrary_types_allowed': True, 'extra': 'forbid', 'strict': False, 'use_enum_values': True, 'validate_assignment': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class bkbit.models.library_generation.Sex(value)

Bases: str, Enum

An enumeration.

number_1 = '1'

number_2 = '2'

number_7 = '7'

number_8 = '8'

number_9 = '9'

class bkbit.models.library_generation.SubjectOfInvestigation

Bases: ConfiguredBaseModel

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

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

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

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

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

model_config: ClassVar[ConfigDict] = {'arbitrary_types_allowed': True, 'extra': 'forbid', 'strict': False, 'use_enum_values': True, 'validate_assignment': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class bkbit.models.library_generation.TaxonomicRank(*, id: str)

Bases: OntologyClass

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

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

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

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

id: str

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

model_config: ClassVar[ConfigDict] = {'arbitrary_types_allowed': True, 'extra': 'forbid', 'strict': False, 'use_enum_values': True, 'validate_assignment': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class bkbit.models.library_generation.ThingWithTaxon(*, in_taxon: List[str] | None = None, in_taxon_label: str | None = None)

Bases: ConfiguredBaseModel

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

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

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

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

in_taxon: List[str] | None

in_taxon_label: str | None

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

model_config: ClassVar[ConfigDict] = {'arbitrary_types_allowed': True, 'extra': 'forbid', 'strict': False, 'use_enum_values': True, 'validate_assignment': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class bkbit.models.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, used: str | None = None, was_guided_by: str | None = None)

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

full_name: str | None

has_attribute: List[str] | None

id: str

iri: str | None

linkml_meta: ClassVar[LinkMLMeta] = LinkMLMeta(root={'from_schema': 'https://identifiers.org/brain-bican/library-generation-schema', 'in_subset': ['bican', 'library_generation'], 'mixins': ['ProvActivity'], 'slot_usage': {'category': {'name': 'category', 'pattern': '^bican:[A-Z][A-Za-z]+$'}, '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', 'strict': False, 'use_enum_values': True, 'validate_assignment': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

name: str | None

classmethod pattern_category(v)

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, was_derived_from: str | None = None, was_generated_by: str | None = None, dissection_was_guided_by: str | None = None, tissue_sample_structure: List[str] | None = None)

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

full_name: str | None

has_attribute: List[str] | None

id: str

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': {'category': {'name': 'category', 'pattern': '^bican:[A-Z][A-Za-z]+$'}, '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': ['NIMP:PD-LJCRCC35'], 'local_names': {'NIMP': {'local_name_source': 'NIMP', 'local_name_value': 'tissue_sample_local_name'}}, 'name': 'name', 'slot_uri': 'bican:2e4ca2fc-2d77-4d19-af45-d0fb7bbc2269'}, 'was_derived_from': {'description': 'The donor or brain slab from which the tissue sample was derived from.', 'exact_mappings': ['NIMP:has_parent'], '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'}}})

model_config: ClassVar[ConfigDict] = {'arbitrary_types_allowed': True, 'extra': 'forbid', 'strict': False, 'use_enum_values': True, 'validate_assignment': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

name: str | None

classmethod pattern_category(v)

provided_by: List[str] | None

synonym: List[str] | None

tissue_sample_structure: List[str] | None

type: List[str] | None

was_derived_from: str | None

was_generated_by: str | None

xref: List[str] | None