class ExperimentMetadata(db.Model):
"""
db.Table representing Metadata identifiers for entities and properties
Attributes:
name (:obj:`str`): Name of the entity or property
"""
__tablename__ = '_experimentmetadata'
name = db.Column(db.Unicode, unique=True)
id = db.Column(db.Integer, primary_key=True)
description = db.Column(db.Text())
method = db.relationship('Method',
secondary=_experimentmetadata_method,
backref='_experimentmetadata')
taxon = db.relationship('Taxon',
secondary=_experimentmetadata_taxon,
backref='_experimentmetadata')
experiment_design = db.relationship(
'ExperimentDesign',
secondary=_experimentmetadata_experimentdesign,
backref='_experimentmetadata')
experiment_type = db.relationship(
'ExperimentType',
secondary=_experimentmetadata_experimenttype,
backref='_experimentmetadata')
resource = db.relationship('Resource',
secondary=_experimentmetadata_resource,
backref='_experimentmetadata')
def __repr__(self):
return 'ExperimentMetadata(%s||%s)' % (self.name, self.id)
class Concentration(PhysicalProperty):
"""
Represents the concentration of an entity
Attributes:
value (:obj:`float`): concentration of a tagged metabolite
error (:obj:`float`): uncertainty of corresponding concentration value
"""
__tablename__ = 'concentration'
concentration_id = db.Column(
db.Integer,
db.ForeignKey('physical_property.observation_id'),
primary_key=True)
metabolite_id = db.Column(db.Integer,
db.ForeignKey('metabolite.metabolite_id'))
metabolite = db.relationship('Metabolite', backref='concentration')
value = db.Column(db.Float)
error = db.Column(db.Float)
units = db.Column(db.Unicode)
def __repr__(self):
return 'Concentration(%s)' % (self.concentration_id)
class DNABindingDataset(PhysicalProperty):
"""
Represents a dataset for Transcription Factor Binding
Attributes:
version (:obj:`int`): Represents the version of binding matrix
complex_id (:obj:`int`): Relation ID for transcription factor complex
subunit_id (:obj:`int`): Relation ID for transcription factor subunit
"""
__tablename__ = 'dna_binding_dataset'
dataset_id = db.Column(db.Integer,
db.ForeignKey('physical_property.observation_id'),
primary_key=True)
version = db.Column(db.Integer)
complex_id = db.Column(db.Integer,
db.ForeignKey('protein_complex.complex_id'))
tf = db.relationship('ProteinComplex', backref='dna_binding_dataset')
subunit_id = db.Column(db.Integer,
db.ForeignKey('protein_subunit.subunit_id'))
subunit = db.relationship('ProteinSubunit', backref='dna_binding_dataset')
def __repr__(self):
return 'DNABindingDataset(%s)' % (self.dataset_id)
class Reaction(db.Model):
"""
Represents a reaction
Attributes:
metabolite_id (:obj:`int`): ID of the corresponding metabolite
coefficient (:obj:`float`): Stoichiometric coefficient
_is_reactant (:obj:`bool`): Indicates of corresponding metabolite is a reactant
_is_product (:obj:`bool`): Indicates of corresponding metabolite is a product
_is_modifier (:obj:`bool`): Indicates of corresponding metabolite is a modifier
rxn_type (:obj:`str`): Classifer of reaction
"""
__tablename__ = 'reaction'
reaction_id = db.Column(db.Integer, primary_key=True)
metabolite_id = db.Column(db.Integer,
db.ForeignKey('metabolite.metabolite_id'))
metabolite = db.relationship(Metabolite, backref='reaction')
compartment_id = db.Column(db.Integer,
db.ForeignKey('cell_compartment.id'))
compartment = db.relationship(CellCompartment, backref='reaction')
coefficient = db.Column(db.Float)
_is_reactant = db.Column(db.Boolean)
_is_product = db.Column(db.Boolean)
_is_modifier = db.Column(db.Boolean)
rxn_type = db.Column(db.Unicode)
kinetic_law_id = db.Column(db.Integer,
db.ForeignKey('kinetic_law.kinetic_law_id'))
kinetic_law = db.relationship(KineticLaw, backref='reaction')
def __repr__(self):
return 'Reaction(%s)' % (self.reaction_id)
class ExperimentDesign(db.Model):
""" Represents and experimental design
Attributes:
_id (:obj:`int`): unique id
name (:obj:`str`): name
"""
__tablename__ = 'experiment_design'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.Unicode)
def __repr__(self):
return 'ExperimentDesign(%s||%s)' % (self.name, self.id)
class ReferenceGenome(PhysicalProperty):
__tablename__ = 'reference_genome'
reference_genome_id = db.Column(
db.Integer,
db.ForeignKey('physical_property.observation_id'),
primary_key=True)
namespace = db.Column(db.Unicode)
organism_strain = db.Column(db.Unicode)
download_url = db.Column(db.Unicode)
def __repr__(self):
return 'ReferenceGenome(%s)' % (self.reference_genome_id)
class Experiment(db.Model):
__tablename__ = 'experiment'
id = db.Column(db.Integer, primary_key=True)
#observations = db.relationship('Observation', backref='experiment')
_experimentmetadata_id = db.Column(db.Integer,
db.ForeignKey('_experimentmetadata.id'))
_experimentmetadata = db.relationship('ExperimentMetadata',
backref='experiment')
def __repr__(self):
return 'Experiment(%s||%s)' % (self.id, self._experimentmetadata_id)
class Metabolite(PhysicalEntity):
"""
Represents a Metabolite - An instance of Physical Entity
Attributes:
metabolite_id (:obj:`int`): Common Schema Observation Identifier
metabolite_name (:obj:`str`): Name of the Metabolite
description (:obj:`str`):
comment = db.Column(db.Unicode)
_is_name_ambiguous = db.Column(db.Boolean)
"""
__tablename__ = 'metabolite'
query_class = FullTextQuery
metabolite_id = db.Column(db.Integer,
db.ForeignKey('physical_entity.observation_id'),
primary_key=True)
metabolite_name = db.Column(db.Unicode)
description = db.Column(db.Unicode)
comment = db.Column(db.Unicode)
_is_name_ambiguous = db.Column(db.Boolean)
simple_search_vector = db.Column(TSVectorType('metabolite_name'))
complex_search_vector = db.Column(
TSVectorType('metabolite_name', 'description'))
structure_id = db.Column(db.Integer, db.ForeignKey('structure.struct_id'))
structure = db.relationship('Structure', backref='metabolite')
def __repr__(self):
return self.__class__.__name__ + '||%s' % (self.id)
class DNABindingData(db.Model):
"""
Represents Matrix binding profile for a protein transcription factor
Attributes:
position (:obj:`int`): Position in the sequence
frequency_a (:obj:`int`): Frequency of A
frequency_c (:obj:`int`): Frequency of C
frequency_g (:obj:`int`): Frequency of G
frequency_t (:obj:`int`): Frequency of T
jaspar_id (:obj:`int`): ID of Jaspar Matrix (used for bulk insert mapping)
dataset_id (:obj:`int`): Represents the dataset from which the data stems from
"""
__tablename__ = 'dna_binding_data'
position_id = db.Column(db.Integer, primary_key=True)
position = db.Column(db.Integer, index=True)
frequency_a = db.Column(db.Integer)
frequency_c = db.Column(db.Integer)
frequency_g = db.Column(db.Integer)
frequency_t = db.Column(db.Integer)
jaspar_id = db.Column(db.Integer)
dataset_id = db.Column(db.Integer,
db.ForeignKey('dna_binding_dataset.dataset_id'))
dataset = db.relationship('DNABindingDataset',
backref='dna_binding_data',
foreign_keys=[dataset_id])
def __repr__(self):
return 'DNABindingData(%s)' % (self.position_id)
class RNASeqExperiment(Experiment):
__tablename__ = 'rna_seq_experiment'
experiment_id = db.Column(db.Integer,
db.ForeignKey('experiment.id'),
primary_key=True)
samples = db.relationship('RNASeqDataSet',
secondary=rnaseqdataset_rnaseqexperiment,
backref='experiment')
accession_number = db.Column(db.Unicode)
exp_name = db.Column(db.Unicode)
has_fastq_files = db.Column(db.Boolean)
def __repr__(self):
return 'RNASeqExperiment(%s)' % (self.experiment_id)
class Progress(db.Model):
"""
Represents amount loaded of large DBs (Ex. Pax and Sabio)
Attributes:
database_name (:obj:`str`): Name of observed databse
amount_loaded (:obj:`int`): Amount of entries loaded in Common Schema
"""
__tablename__ = 'progress'
database_name = db.Column(db.Unicode, primary_key=True)
amount_loaded = db.Column(db.Integer)
def __repr__(self):
return 'Progress(%s||%s)' % (self.database_name, self.amount_loaded)
class DataFormat(db.Model):
""" Represents a data format
Attributes:
_id (:obj:`int`): unique id
name (:obj:`str`): name
bio_assay_data_cubes (:obj:`int`): number of dimensions to the data
"""
__tablename__ = 'data_format'
_id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.Unicode)
bio_assay_data_cubes = db.Column(db.Integer)
def __repr__(self):
return 'DataFormat(%s||%s)' % (self.name, self._id)
class CellLine(db.Model):
"""
Represents a cell line of a given physical entity or property
Attributes:
name (:obj:`str`): Name of the Cell Line
"""
__tablename__ = 'cell_line'
query_class = FullTextQuery
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.Unicode)
search_vector = db.Column(TSVectorType('name'))
def __repr__(self):
return 'CellLine(%s||%s)' % (self.name, self.id)
class Characteristic(db.Model):
"""
Represents the method of collection for a given entity or Property
Attributes:
name (:obj:`str`): Name of the Method
comments (:obj:`str`): Comments on the method
"""
__tablename__ = 'characteristic'
#query_class = FullTextQuery
id = db.Column(db.Integer, primary_key=True)
category = db.Column(db.Unicode)
value = db.Column(db.Unicode)
def __repr__(self):
return 'Charactaristic(%s)' % (self.id)
class Taxon(db.Model):
"""
Represents the species of a given physical entity or property
Attributes:
ncbi_id (:obj:`int`): NCBI id of the species
name (:obj:`str`): Name of the species
"""
__tablename__ = 'taxon'
query_class = FullTextQuery
ncbi_id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.Unicode)
search_vector = db.Column(TSVectorType('name'))
def __repr__(self):
return 'Taxon(%s||%s)' % (self.name, self.ncbi_id)
class CellCompartment(db.Model):
"""
Represents a cell compartment of a given physical entity or property
Ties especially to the reacitons because this is where the reactions occur
Attributes:
name (:obj:`str`): Name of the Cell Compartment
"""
__tablename__ = 'cell_compartment'
query_class = FullTextQuery
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.Unicode, unique=True, index=True)
search_vector = db.Column(TSVectorType('name'))
def __repr__(self):
return 'CellCompartment(%s||%s)' % (self.name, self.id)
class Observation(db.Model):
"""
Represents an Observation of a Physical Entity or Property in the Common Schema
Attributes:
id (:obj:`int`): Common Schema Observation Identifier
_metadata_id (:obj:`int` of :obj:`Metadata`): Related Metadata ID
"""
__tablename__ = 'observation'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
_metadata_id = db.Column(db.Integer, db.ForeignKey('_metadata.id'))
_metadata = db.relationship('Metadata')
def __repr__(self):
return 'Observation({0})'.format(self.id)
class Synonym(db.Model):
"""
Represents a synonym of a given physical entity or property
Attributes:
name (:obj:`str`): Name of the Synonym
"""
query_class = FullTextQuery
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.Unicode)
search_vector = db.Column(TSVectorType('name'))
__tablename__ = 'synonym'
def __repr__(self):
return 'Synonym(%s||%s)' % (self.name, self.id)
class PhysicalProperty(Observation):
"""
Represents a Physical Property in the Common Schema
Attributes:
observation_id (:obj:`int`): Common Schema Observation Identifier
type (:obj:`str`): Type of Physical Property (Ex. Concentration)
name (:obj:`str`): Name of the Physical Property
"""
observation_id = db.Column(db.Integer,
db.ForeignKey('observation.id'),
primary_key=True)
type = db.Column(db.Unicode)
name = db.Column(db.Unicode)
__tablename__ = 'physical_property'
def __repr__(self):
return 'PhysicalProperty(%s||%s)' % (self.name, self.observation_id)
class Resource(db.Model):
"""
Represents a resource of a given physical entity or property
Attributes:
namespace (:obj:`str`): Name of the classifier of the resource (Ex. Pubmed)
_id (:obj:`str`): Identifier of the resource
release_date(:obj:`str`): The date that resource released the data
"""
__tablename__ = 'resource'
id = db.Column(db.Integer, primary_key=True)
namespace = db.Column(db.Unicode)
_id = db.Column(db.Unicode)
release_date = db.Column(db.Unicode)
def __repr__(self):
return 'Resource(%s)' % (self.id)
class Metadata(db.Model):
"""
db.Table representing Metadata identifiers for entities and properties
Attributes:
name (:obj:`str`): Name of the entity or property
"""
__tablename__ = '_metadata'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.Unicode, unique=True)
taxon = db.relationship('Taxon',
secondary=_metadata_taxon,
backref='_metadata')
method = db.relationship('Method',
secondary=_metadata_method,
backref='_metadata')
resource = db.relationship('Resource',
secondary=_metadata_resource,
backref='_metadata')
cell_line = db.relationship('CellLine',
secondary=_metadata_cell_line,
backref='_metadata')
synonym = db.relationship('Synonym',
secondary=_metadata_synonym,
backref='_metadata')
conditions = db.relationship('Conditions',
secondary=_metadata_conditions,
backref='_metadata')
cell_compartment = db.relationship('CellCompartment',
secondary=_metadata_compartment,
backref='_metadata')
characteristic = db.relationship('Characteristic',
secondary=_metadata_characteristic,
backref='_metadata')
variable = db.relationship('Variable',
secondary=_metadata_variable,
backref='_metadata')
def __repr__(self):
return 'Metadata(%s||%s)' % (self.name, self.id)
class PhysicalEntity(Observation):
"""
Represents a Physical Entity in the Common Schema
Attributes:
observation_id (:obj:`int`): Common Schema Observation Identifier
type (:obj:`str`): Type of Physical Entity (Ex. Metabolite)
name (:obj:`str`): Name of the Physical Entity (Ex. Water )
"""
__tablename__ = 'physical_entity'
observation_id = db.Column(db.Integer,
db.ForeignKey('observation.id'),
primary_key=True,
autoincrement=True)
type = db.Column(db.Unicode)
name = db.Column(db.Unicode)
def __repr__(self):
return 'PhysicalEntity(%s||%s)' % (self.name, self.observation_id)
class KineticLaw(PhysicalProperty):
"""
Represents the concentration of an entity
Attributes:
enzyme_id (:obj:`int`): ID of enzyme driving the kinetic law
enzyme_type (:obj:`str`): Enzyme classification (Ex. Modifier-Catalyst)
tissue (:obj:`str`): Tissue from which kinetic law stems from
mechanism (:obj:`str`): Rate kinetics of Kinetic Law
equation (:obj:`str`): Equation of the rate kinetics
"""
__tablename__ = 'kinetic_law'
kinetic_law_id = db.Column(
db.Integer,
db.ForeignKey('physical_property.observation_id'),
primary_key=True)
enzyme_id = db.Column(db.Integer,
db.ForeignKey('protein_complex.complex_id'),
index=True)
enzyme = db.relationship(ProteinComplex, backref='kinetic_law')
enzyme_type = db.Column(db.Unicode)
tissue = db.Column(db.Unicode)
mechanism = db.Column(db.Unicode)
equation = db.Column(db.Unicode)
def __repr__(self):
return 'KineticLaw(%s)' % (self.kinetic_law_id)
class AbundanceData(db.Model):
"""
Represents protein abundance data from the Pax DB database
Attributes:
abundance (:obj:`float`): Represents protein abundance from given observation in ppm
dataset_id (:obj:`int`): Represents the dataset from which the abundance stems from
subunit_id (:obj:`int`): Represents the protein frmo which the abundance stems from
"""
__tablename__ = 'abundance_data'
abundance_id = db.Column(db.Integer, primary_key=True)
abundance = db.Column(db.Float)
dataset_id = db.Column(db.Integer,
db.ForeignKey('abundance_dataset.dataset_id'))
dataset = db.relationship('AbundanceDataSet',
backref='abundance_data',
foreign_keys=[dataset_id])
subunit_id = db.Column(db.Integer,
db.ForeignKey('protein_subunit.subunit_id'),
index=True)
subunit = db.relationship('ProteinSubunit')
pax_load = db.Column(db.Integer)
uniprot_id = db.Column(db.Unicode)
def __repr__(self):
return 'AbundanceData(%s)' % (self.abundance_id)
class Structure(PhysicalProperty):
"""
Represents a structure of a metabolite
Attributes:
_value_smiles (:obj:`str`): Smiles format for metabolite representation
_value_inchi (:obj:`str`): Inchi format for metabolite representation
_structure_formula_connectivity (:obj:`str`): Connectivity of metabolite
"""
__tablename__ = 'structure'
struct_id = db.Column(db.Integer,
db.ForeignKey('physical_property.observation_id'),
primary_key=True)
_value_smiles = db.Column(db.Unicode)
_value_inchi = db.Column(db.Unicode)
_structure_formula_connectivity = db.Column(db.Unicode)
def __repr__(self):
return 'Structure(%s)' % (self.struct_id)
class AbundanceDataSet(PhysicalProperty):
"""
Represents a dataset for protein abundance
Attributes:
file_name (:obj:`str`): Name of data set which data stems from
score (:obj:`float`): Quality of the experimental analysis (PAXdb Measure)
weight (:obj:`int`):
coverage (:obj:`int`): Percentage of genome coverage
"""
__tablename__ = 'abundance_dataset'
dataset_id = db.Column(db.Integer,
db.ForeignKey('physical_property.observation_id'),
primary_key=True)
file_name = db.Column(db.Unicode, unique=True)
score = db.Column(db.Float)
weight = db.Column(db.Integer)
coverage = db.Column(db.Integer)
def __repr__(self):
return 'AbundanceDataset(%s)' % (self.dataset_id)
class RNASeqDataSet(PhysicalProperty):
__tablename__ = 'rna_seq_dataset'
sample_id = db.Column(db.Integer,
db.ForeignKey('physical_property.observation_id'),
primary_key=True)
experiment_accession_number = db.Column(db.Unicode)
sample_name = db.Column(db.Unicode)
assay = db.Column(db.Unicode)
ensembl_organism_strain = db.Column(db.Unicode)
read_type = db.Column(db.Unicode)
full_strain_specificity = db.Column(db.Boolean)
reference_genome = db.relationship('ReferenceGenome',
secondary=rnaseqdataset_referencegenome,
backref='sample')
def __repr__(self):
return 'RNASeqDataset(%s)' % (self.sample_id)
class Method(db.Model):
"""
Represents the method of collection for a given entity or Property
Attributes:
name (:obj:`str`): Name of the Method
comments (:obj:`str`): Comments on the method
"""
__tablename__ = 'method'
query_class = FullTextQuery
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.Unicode)
comments = db.Column(db.Unicode)
performer = db.Column(db.Unicode)
hardware = db.Column(db.Unicode)
software = db.Column(db.Unicode)
def __repr__(self):
return 'Method(%s||%s)' % (self.name, self.id)
class Conditions(db.Model):
"""
Represents the conditions of a given physical entity or property
Attributes:
growth_status (:obj:`str`): Type of growth status
media (:obj:`str`): Media composition
temperature (:obj:`float`): Temperature of the sample (C)
ph (:obj:`float`): pH of the sample
growth_system (:obj:`str`): Type of growth system
"""
id = db.Column(db.Integer, primary_key=True)
growth_status = db.Column(db.Unicode)
media = db.Column(db.Unicode)
temperature = db.Column(db.Float)
ph = db.Column(db.Float)
growth_system = db.Column(db.Unicode)
__tablename__ = 'conditions'
def __repr__(self):
return 'Conditions(%s)' % (self.id)
class ProteinInteraction(PhysicalProperty):
"""
Represents a protein-protein interaction
Attributes:
participant_a (:obj:`str`): Participant A in the interaction
participant_b (:obj:`str`): Participant B in the interaction
interaction (:obj:`str`): Interaction ID
site_a (:obj:`str`): Binding Site of Participant A
site_b (:obj:`str`): Binding Site of Participant B
stoich_a (:obj:`str`): Stoichiometry of Participant A
stoich_b (:obj:`str`): Stoichiometry of Participant B
"""
__tablename__ = 'protein_interactions'
query_class = FullTextQuery
interaction_id = db.Column(
db.Integer,
db.ForeignKey('physical_property.observation_id'),
primary_key=True)
protein_a = db.Column(db.Unicode)
protein_b = db.Column(db.Unicode)
gene_a = db.Column(db.Unicode)
gene_b = db.Column(db.Unicode)
type_a = db.Column(db.Unicode)
type_b = db.Column(db.Unicode)
role_a = db.Column(db.Unicode)
role_b = db.Column(db.Unicode)
loc_a = db.Column(db.Unicode)
loc_b = db.Column(db.Unicode)
stoich_a = db.Column(db.Unicode)
stoich_b = db.Column(db.Unicode)
interaction_type = db.Column(db.Unicode)
confidence = db.Column(db.Unicode)
def __repr__(self):
return 'ProteinInteratction(%s)' % (self.interaction_id)
