models.py

"""
Models used in iPPI-DB
"""

from __future__ import unicode_literals
import operator

from django.db import models
from django.conf import settings
from django.db.models import Max, Min, Count, F, Q
from django.db.models.functions import Cast
from django.db.models import FloatField                                                                                                                                                                 


from .utils import FingerPrinter, smi2inchi, smi2inchikey
from .ws import get_pubmed_info, get_google_patent_info, get_uniprot_info, get_taxonomy_info, get_go_info, get_pfam_info


class AutoFillableModel(models.Model):

    """
    AutoFillableModel makes it possible to automatically fill model fields from
    external sources in the autofill() method
    The save method allows to either include autofill or not. in autofill kwarg is
    set to True, save() will first call autofill(), otherwise it won't
    """

    class Meta:
        abstract = True

    def save(self, *args, **kwargs):
        if kwargs.get('autofill') is True:
            self.autofill()
        if 'autofill' in kwargs:
            del kwargs['autofill']
        super(AutoFillableModel, self).save(*args, **kwargs)


class Bibliography(AutoFillableModel):

    """
    Bibliography data table
    """
    SOURCES = (
        ('PM', 'PubMed ID'),
        ('PT', 'Patent'),
        ('DO', 'DOI ID')
    )
    source = models.CharField(
        'Bibliographic type', max_length=2, choices=SOURCES, default='PM')
    id_source = models.CharField('Bibliographic ID', max_length=25)
    title = models.CharField('Title', max_length=300)
    journal_name = models.CharField('Journal name', max_length=50, null=True, blank=True)
    authors_list = models.CharField('Authors list', max_length=500)
    biblio_year = models.PositiveSmallIntegerField('Year')
    cytotox = models.BooleanField('Cytotoxicity data', default=False)
    in_silico = models.BooleanField('in silico study', default=False)
    in_vitro = models.BooleanField('in vitro study', default=False)
    in_vivo = models.BooleanField('in vivo study', default=False)
    in_cellulo = models.BooleanField('in cellulo study', default=False)
    pharmacokinetic = models.BooleanField(
        'pharmacokinetic study', default=False)
    xray = models.BooleanField('X-Ray data', default=False)

    def autofill(self):
        if self.source == 'PM':
            info = get_pubmed_info(self.id_source)
        else:
            info = get_google_patent_info(self.id_source)
        self.title = info['title']
        self.journal_name = info['journal_name']
        self.authors_list = info['authors_list']
        self.biblio_year = info['biblio_year']

    class Meta:
        verbose_name_plural = "bibliographies"

    def __str__(self):
        return '{}, {}'.format(self.source, self.id_source)


class Taxonomy(AutoFillableModel):
    taxonomy_id = models.DecimalField(
        'NCBI TaxID', unique=True, max_digits=9, decimal_places=0)
    name = models.CharField('Organism name', max_length=200)

    def autofill(self):
        info = get_taxonomy_info(self.taxonomy_id)
        self.name = info['scientific_name']

    def __str__(self):
        return self.name

    class Meta:
        verbose_name_plural = "taxonomies"


class MolecularFunction(AutoFillableModel):
    go_id = models.CharField('Gene Ontology ID', unique=True, max_length=10)
    # GO term id format: 'GO:0000000'
    description = models.CharField('description', max_length=500)

    def autofill(self):
        info = get_go_info(self.go_id)
        self.description = info['label']

    def __str__(self):
        return self.description


class Protein(AutoFillableModel):
    uniprot_id = models.CharField('Uniprot ID', unique=True, max_length=10)
    recommended_name_long = models.CharField(
        'Uniprot Recommended Name (long)', max_length=75)
    short_name = models.CharField('Short name', max_length=50)
    gene_name = models.CharField('Gene name', unique=True, max_length=30)
    entry_name = models.CharField('Entry name', max_length=30)
    organism = models.ForeignKey('Taxonomy', models.CASCADE)
    molecular_functions = models.ManyToManyField(MolecularFunction)

    def autofill(self):
        info = get_uniprot_info(self.uniprot_id)
        self.recommended_name_long = info['recommended_name']
        self.gene_name = info['gene']
        self.entry_name = info['entry_name']
        self.short_name = info['short_name']
        try:
            taxonomy = Taxonomy.objects.get(taxonomy_id=info['organism'])
        except Taxonomy.DoesNotExist:
            taxonomy = Taxonomy()
            taxonomy.taxonomy_id = info['organism']
            taxonomy.save(autofill=True)
        self.organism = taxonomy
        super(Protein, self).save()
        for go_id in info['molecular_functions']:
            try:
                mol_function = MolecularFunction.objects.get(go_id=go_id)
            except MolecularFunction.DoesNotExist:
                mol_function = MolecularFunction()
                mol_function.go_id = go_id
                mol_function.save(autofill=True)
            self.molecular_functions.add(mol_function)

    def __str__(self):
        return '{} ({})'.format(self.uniprot_id, self.recommended_name_long)


class Domain(AutoFillableModel):
    pfam_acc = models.CharField('Pfam Accession', max_length=10, unique=True)
    pfam_id = models.CharField('Pfam Family Identifier', max_length=20)
    pfam_description = models.CharField('Pfam Description', max_length=100)
    domain_family = models.CharField('Domain family', max_length=25)
    # TODO: what is this field? check database
    # contents

    def autofill(self):
        info = get_pfam_info(self.pfam_acc)
        self.pfam_id = info['id']
        self.pfam_description = info['description']

    def __str__(self):
        return '{} ({}-{})'.format(self.pfam_acc, self.pfam_id, self.pfam_description)


class ProteinDomainComplex(models.Model):
    protein = models.ForeignKey('Protein', models.CASCADE)
    domain = models.ForeignKey('Domain', models.CASCADE)
    ppc_copy_nb = models.IntegerField(
        'Number of copies of the protein in the complex')

    class Meta:
        verbose_name_plural = "complexes"

    def __str__(self):
        return '{}-{}'.format(self.protein_id, self.domain_id)

    def name(self):
        return self.protein.short_name


class ProteinDomainBoundComplex(ProteinDomainComplex):
    ppp_copy_nb_per_p = models.IntegerField(
        'Number of copies of the protein in the pocket')

    class Meta:
        verbose_name_plural = "bound complexes"


class ProteinDomainPartnerComplex(ProteinDomainComplex):

    class Meta:
        verbose_name_plural = "partner complexes"


class Symmetry(models.Model):
    code = models.CharField('Symmetry code', max_length=2)
    description = models.CharField('Description', max_length=300)

    class Meta:
        verbose_name_plural = "symmetries"

    def __str__(self):
        return '{} ({})'.format(self.code, self.description)


class Disease(models.Model):
    name = models.CharField('Disease', max_length=30, unique=True)
    # is there any database/nomenclature for diseases?

    def __str__(self):
        return self.name


class PpiFamily(models.Model):
    name = models.CharField('Name', max_length=30, unique=True)

    class Meta:
        verbose_name_plural = "PPI Families"

    def __str__(self):
        return self.name


class Ppi(AutoFillableModel):
    pdb_id = models.CharField('PDB ID', max_length=4, null=True, blank=True)
    pockets_nb = models.IntegerField(
        'Total number of pockets in the complex', default=1)
    symmetry = models.ForeignKey(Symmetry, models.CASCADE)
    diseases = models.ManyToManyField(Disease)
    family = models.ForeignKey(PpiFamily, models.CASCADE, null=True, blank=True)
    name = models.TextField('PPI name', null=True, blank=True)

    def __str__(self):
        return 'PPI #{} on {}'.format(self.id, self.name)

    def autofill(self):
        # name is denormalized and stored in the database to reduce SQL queries in query mode
        self.name = self.compute_name_from_protein_names()

    def get_ppi_bound_complexes(self):
        """
        return bound ppi complexes belonging to this ppi
        """
        # this is the less efficient query ever seen, FIXME
        return PpiComplex.objects.filter(ppi=self, complex__in=ProteinDomainBoundComplex.objects.all())

    def compute_name_from_protein_names(self):
        all_protein_names = set(
            [ppi_complex.complex.protein.short_name for ppi_complex in self.ppicomplex_set.all()])
        bound_protein_names = set(
            [ppi_complex.complex.protein.short_name for ppi_complex in self.get_ppi_bound_complexes()])
        partner_protein_names = all_protein_names - bound_protein_names
        bound_str = ','.join(bound_protein_names)
        partner_str = ','.join(partner_protein_names)
        name = bound_str
        if partner_str != '':
            name += ' / ' + partner_str
        return name


class PpiComplex(models.Model):
    ppi = models.ForeignKey(Ppi, models.CASCADE)
    complex = models.ForeignKey(ProteinDomainComplex, models.CASCADE)
    cc_nb = models.IntegerField(
        'Number of copies of the complex in the PPI', default=1)

    class Meta:
        verbose_name_plural = "Ppi complexes"

    def __str__(self):
        return 'PPI {}, Complex {} ({})'.format(self.ppi, self.complex, self.cc_nb)


class CompoundManager(models.Manager):

    def get_queryset(self):
        qs = super().get_queryset()
        #  with number of publications
        qs = qs.annotate(pubs=Count('refcompoundbiblio', distinct=True))
        #  with best activity
        qs = qs.annotate(best_activity=Max('compoundactivityresult__activity')) 
        #  with LE
        qs = qs.annotate(le=Cast(1.37 * Max('compoundactivityresult__activity') / F('nb_atom_non_h'),FloatField()))
        #  with LLE
        qs = qs.annotate(lle=Cast(Max('compoundactivityresult__activity') - F('a_log_p'),FloatField()))
        return qs

class Compound(AutoFillableModel):
    objects = CompoundManager() 
    canonical_smile = models.TextField(
        'Canonical Smile', unique=True)
    is_macrocycle = models.BooleanField('Contains one or more macrocycles')
    aromatic_ratio = models.DecimalField(
        'Aromatic ratio', max_digits=3, decimal_places=2)
    balaban_index = models.DecimalField(
        'Balaban index', max_digits=3, decimal_places=2)
    fsp3 = models.DecimalField('Fsp3', max_digits=3, decimal_places=2)
    gc_molar_refractivity = models.DecimalField(
        'GC Molar Refractivity', max_digits=5, decimal_places=2)
    log_d = models.DecimalField(
        'LogD (Partition coefficient octanol-1/water, with pKa information)', max_digits=4, decimal_places=2)
    a_log_p = models.DecimalField(
        'ALogP (Partition coefficient octanol-1/water)', max_digits=4, decimal_places=2)
    mean_atom_vol_vdw = models.DecimalField(
        'Mean atom volume computed with VdW radii', max_digits=4, decimal_places=2)
    molecular_weight = models.DecimalField(
        'Molecular weight', max_digits=6, decimal_places=2)
    nb_acceptor_h = models.IntegerField('Number of hydrogen bond acceptors')
    nb_aliphatic_amines = models.IntegerField('Number of aliphatics amines')
    nb_aromatic_bonds = models.IntegerField('Number of aromatic bonds')
    nb_aromatic_ether = models.IntegerField('Number of aromatic ethers')
    nb_aromatic_sssr = models.IntegerField(
        'Number of aromatic Smallest Set of System Rings (SSSR)')
    nb_atom = models.IntegerField('Number of atoms')
    nb_atom_non_h = models.IntegerField('Number of non hydrogen atoms')
    nb_benzene_like_rings = models.IntegerField('Number of benzene-like rings')
    nb_bonds = models.IntegerField('Number of bonds')
    nb_bonds_non_h = models.IntegerField(
        'Number of bonds not involving a hydrogen')
    nb_br = models.IntegerField('Number of Bromine atoms')
    nb_c = models.IntegerField('Number of Carbon atoms')
    nb_chiral_centers = models.IntegerField('Number of chiral centers')
    nb_circuits = models.IntegerField('Number of circuits')
    nb_cl = models.IntegerField('Number of Chlorine atoms')
    nb_csp2 = models.IntegerField('Number of sp2-hybridized carbon atoms')
    nb_csp3 = models.IntegerField('Number of sp3-hybridized carbon atoms')
    nb_donor_h = models.IntegerField('Number of hydrogen bond donors')
    nb_double_bonds = models.IntegerField('Number of double bonds')
    nb_f = models.IntegerField('Number of fluorine atoms')
    nb_i = models.IntegerField('Number of iodine atoms')
    nb_multiple_bonds = models.IntegerField('Number of multiple bonds')
    nb_n = models.IntegerField('Number of nitrogen atoms')
    nb_o = models.IntegerField('Number of oxygen atoms')
    nb_rings = models.IntegerField('Number of rings')
    nb_rotatable_bonds = models.IntegerField('Number of rotatable bonds')
    inchi = models.TextField('InChi')
    inchikey = models.TextField('InChiKey')
    randic_index = models.DecimalField(
        'Randic index', max_digits=4, decimal_places=2)
    rdf070m = models.DecimalField(
        'RDF070m, radial distribution function weighted by the atomic masses at 7Å', max_digits=5, decimal_places=2)
    rotatable_bond_fraction = models.DecimalField(
        'Fraction of rotatable bonds', max_digits=3, decimal_places=2)
    sum_atom_polar = models.DecimalField(
        'Sum of atomic polarizabilities', max_digits=5, decimal_places=2)
    sum_atom_vol_vdw = models.DecimalField(
        'Sum of atom volumes computed with VdW radii', max_digits=6, decimal_places=2)
    tpsa = models.DecimalField(
        'Topological Polar Surface Area (TPSA)', max_digits=5, decimal_places=2)
    ui = models.DecimalField(
        'Unsaturation index', max_digits=4, decimal_places=2)
    wiener_index = models.IntegerField('Wiener index')
    common_name = models.CharField(
        'Common name', unique=True, max_length=20, blank=True, null=True)
    pubchem_id = models.CharField(
        'Pubchem ID', max_length=10, blank=True, null=True)
    chemspider_id = models.CharField(
        'Chemspider ID', unique=True, max_length=10, blank=True, null=True)
    chembl_id = models.CharField(
        'Chembl ID', max_length=30, blank=True, null=True)
    iupac_name = models.CharField(
        'IUPAC name', max_length=255, blank=True, null=True)

    class Meta:
       ordering = ['id']

    def compute_drugbank_compound_similarity(self):
        """ compute Tanimoto similarity to existing DrugBank compounds """
        self.save()
        # fingerprints to compute drugbank similarities are in settings module, default FP2
        fingerprinter = FingerPrinter(getattr(settings, "DRUGBANK_FINGERPRINTS", "FP2"))
        #1. compute tanimoto for SMILES query vs all compounds
        smiles_dict = {c.id:c.canonical_smiles for c in DrugBankCompound.objects.all()}
        tanimoto_dict = fingerprinter.tanimoto_smiles(self.canonical_smile, smiles_dict)
        tanimoto_dict = dict(sorted(tanimoto_dict.items(), key=operator.itemgetter(1), reverse=True)[:15])
        dbcts = []
        for id_, tanimoto in tanimoto_dict.items():
            dbcts.append(DrugbankCompoundTanimoto(compound=self, drugbank_compound=DrugBankCompound.objects.get(id=id_), tanimoto=tanimoto))
        DrugbankCompoundTanimoto.objects.bulk_create(dbcts)

    @property
    def biblio_refs(self):
        """
        return all RefCompoundBiblio related to this compound
        """
        return RefCompoundBiblio.objects.filter(compound=self)

    @property
    def pfam_ids(self):
        """
        return all PFAM ids for the domain of the proteins of the bound
        complexes in the PPIs this compound has an action on
        """
        pfam_ids = set()
        for ca in self.compoundaction_set.all():
            ca.get_complexes()
            for bound_complex in ca.ppi.get_ppi_bound_complexes():
                pfam_ids.add(bound_complex.complex.domain.pfam_id)
        return pfam_ids

    @property
    def compound_action_ligand_ids(self):
        """
        return all PDB codes of the corresponding compound actions
        """
        ligand_ids = set()
        for ca in self.compoundaction_set.all():
            ligand_ids.add(ca.ligand_id)
        return ligand_ids

    @property
    def hba_hbd(self):
        return self.nb_acceptor_h + self.nb_donor_h

    @property
    def lipinsky_mw(self):
        return self.molecular_weight <= 500

    @property
    def lipinsky_hba(self):
        return self.nb_acceptor_h <= 10

    @property
    def lipinsky_hbd(self):
        return self.nb_donor_h <= 5

    @property
    def lipinsky_a_log_p(self):
        return self.a_log_p <= 5

    @property
    def lipinsky_global(self):
        return int(self.lipinsky_mw) + int(self.lipinsky_hba) + \
            int(self.lipinsky_hbd) + int(self.lipinsky_a_log_p) >= 3

    @property
    def veber_hba_hbd(self):
        return self.nb_acceptor_h + self.nb_donor_h <= 12

    @property
    def veber_tpsa(self):
        return self.tpsa <= 140

    @property
    def veber_rb(self):
        return self.nb_rotatable_bonds <= 10

    @property
    def veber_global(self):
        return self.veber_rb and (self.veber_hba_hbd or self.veber_tpsa)

    @property
    def pfizer_a_log_p(self):
        return self.a_log_p <= 3

    @property
    def pfizer_tpsa(self):
        return self.tpsa >= 75

    @property
    def pfizer_global(self):
        return self.pfizer_a_log_p and self.pfizer_tpsa

    @property
    def best_pXC50_activity(self):
        return self.compoundactivityresult_set.aggregate(Max('activity'))['activity__max']

    @property
    def best_pXC50_compound_activity_result(self):
        best_pXC50_activity = self.best_pXC50_activity
        if best_pXC50_activity is None:
            return None
        return self.compoundactivityresult_set.filter(activity=best_pXC50_activity)[0]

    @property
    def best_pXC50_activity_ppi_name(self):
        """
        Name of the PPI corresponding to the best PXC50 activity
        """
        best_activity_car = self.best_pXC50_compound_activity_result
        if best_activity_car is None:
            return None
        ppi_name = best_activity_car.test_activity_description.ppi.name
        return ppi_name

    @property
    def best_pXC50_activity_ppi_family(self):
        """
        Family of the PPI corresponding to the best PXC50 activity
        """
        best_activity_car = self.best_pXC50_compound_activity_result
        if best_activity_car is None:
            return None
        ppi_family = best_activity_car.test_activity_description.ppi.family.name
        return ppi_family

    @property
    def bioch_tests_count(self):
        """
        return the number of associated biochemical tests
        """
        return self.compoundactivityresult_set.all().filter(test_activity_description__test_type='BIOCH').count()

    @property
    def cell_tests_count(self):
        """
        return the number of associated cell tests
        """
        return self.compoundactivityresult_set.all().filter(test_activity_description__test_type='CELL').count()

    @property
    def families(self):
        """
        return the all PPI families for PPIs involved in the compound activity of the compound
        """
        return list(set([ca.ppi.family for ca in self.compoundaction_set.all()]))
    
    @property
    def sorted_similar_drugbank_compounds(self):
        return self.drugbankcompoundtanimoto_set.order_by('-tanimoto')
        
    def autofill(self):
        # compute InChi and InChiKey
        self.inchi = smi2inchi(self.canonical_smile)
        self.inchikey = smi2inchikey(self.canonical_smile)
        self.compute_drugbank_compound_similarity()

    def __str__(self):
        return 'Compound #{}'.format(self.id)

class CompoundTanimoto(models.Model):
    canonical_smiles = models.TextField(
        'Canonical Smile')
    fingerprint = models.TextField('Fingerprint')
    compound = models.ForeignKey(Compound, models.CASCADE)
    tanimoto = models.DecimalField(
        'Tanimoto value', max_digits=5, decimal_places=4)

    class Meta:
        unique_together = (
            ('canonical_smiles', 'fingerprint', 'compound'))

def create_tanimoto(smiles_query, fingerprint):
    if CompoundTanimoto.objects.filter(canonical_smiles=smiles_query, fingerprint=fingerprint).count()==0:
        smiles_dict = {c.id:c.canonical_smile for c in Compound.objects.all()}
        fingerprinter = FingerPrinter(fingerprint)
        #1. compute tanimoto for SMILES query vs all compounds
        tanimoto_dict = fingerprinter.tanimoto_smiles(smiles_query, smiles_dict)
        #2. insert results in a table with three fields: SMILES query, compound id, tanimoto index
        cts = []
        for id_, smiles in smiles_dict.items():
            cts.append(CompoundTanimoto(canonical_smiles=smiles_query, fingerprint=fingerprint, compound=Compound.objects.get(id=id_), tanimoto=tanimoto_dict[id_]))
        CompoundTanimoto.objects.bulk_create(cts)

class PcaBiplotData(models.Model):
    pca_biplot_data = models.TextField(
        'PCA biplot JSON data', blank=True, null=True)


class LeLleBiplotData(models.Model):
    le_lle_biplot_data = models.TextField(
        'LE-LLE biplot JSON data', blank=True, null=True)


class CellLine(models.Model):
    name = models.CharField('Name', max_length=50, unique=True)

    def __str__(self):
        return self.name


class TestActivityDescription(models.Model):
    TEST_TYPES = (
        ('BIOCH', 'Biochemical assay'),
        ('CELL', 'Cellular assay')
    )
    TEST_MODULATION_TYPES = (
        ('B', 'Binding'),
        ('I', 'Inhibition'),
        ('S', 'Stabilization')
    )
    PROTEIN_BOUND_CONSTRUCTS = (
        ('F', 'Full length'),
        ('U', 'Unspecified')
    )
    biblio = models.ForeignKey(Bibliography, models.CASCADE)
    protein_domain_bound_complex = models.ForeignKey(
        ProteinDomainBoundComplex, models.CASCADE)
    ppi = models.ForeignKey(Ppi, models.CASCADE, blank=True, null=True)
    test_name = models.CharField('Test name', max_length=100)
    is_primary = models.BooleanField('Is primary')
    protein_bound_construct = models.CharField(
        'Protein bound construct', max_length=5, choices=PROTEIN_BOUND_CONSTRUCTS, blank=True, null=True)
    test_type = models.CharField('Test type', max_length=5, choices=TEST_TYPES)
    test_modulation_type = models.CharField(
        'Test modulation type', max_length=1, choices=TEST_MODULATION_TYPES)
    nb_active_compounds = models.IntegerField(
        'Total number of active compounds')
    cell_line = models.ForeignKey(
        CellLine, models.CASCADE, blank=True, null=True)

    def get_complexes(self):
        """
        get the complexes tested for this PPI
        depends on the modulation type
        """
        if self.test_modulation_type == 'I':
            return self.ppi.ppicomplex_set.all()
        else:
            return self.ppi.get_ppi_bound_complexes()

    @property
    def protein_domain_partner_complex(self):
        for ppic in self.ppi.ppicomplex_set.all():
            if hasattr(ppic.complex, 'proteindomainpartnercomplex'):
                return ppic.complex.proteindomainpartnercomplex
        return None


class CompoundActivityResult(models.Model):
    MODULATION_TYPES = (
        ('B', 'Binding'),
        ('I', 'Inhibition'),
        ('S', 'Stabilization')
    )
    ACTIVITY_TYPES = (
        ('pIC50', 'pIC50 (half maximal inhibitory concentration, -log10)'),
        ('pEC50', 'pEC50 (half maximal effective concentration, -log10)'),
        ('pKd', 'pKd (dissociation constant, -log10)'),
        ('pKi', 'pKi (inhibition constant, -log10)'),
    )
    compound = models.ForeignKey(Compound, models.CASCADE)
    test_activity_description = models.ForeignKey(
        TestActivityDescription, models.CASCADE)
    activity_type = models.CharField(
        'Activity type', max_length=5, choices=ACTIVITY_TYPES)
    activity = models.DecimalField(
        'Activity', max_digits=12, decimal_places=10)
    inhibition_percentage = models.DecimalField(
        'Inhibition percentage', max_digits=3, decimal_places=0, null=True, blank=True)
    modulation_type = models.CharField(
        'Modulation type', max_length=1, choices=MODULATION_TYPES)

    class Meta:
        unique_together = (
            ('compound', 'test_activity_description', 'activity_type'),)

    def __str__(self):
        return 'Compound activity result for {} test {} on {}'.format(self.activity_type, self.test_activity_description.id, self.compound.id)

    def is_best(self):
        return self.compound.best_pXC50_compound_activity_result.id == self.id


class TestCytotoxDescription(models.Model):
    biblio = models.ForeignKey(Bibliography, models.CASCADE)
    test_name = models.CharField('Cytotoxicity test name', max_length=100)
    cell_line = models.ForeignKey(CellLine, models.CASCADE)
    compound_concentration = models.DecimalField(
        'Compound concentration in μM', max_digits=7, decimal_places=3, blank=True, null=True)


class CompoundCytotoxicityResult(models.Model):
    compound = models.ForeignKey(Compound, models.CASCADE)
    test_cytotoxicity_description = models.ForeignKey(
        TestCytotoxDescription, models.CASCADE)
    toxicity = models.BooleanField('Toxicity', default=False)

    class Meta:
        unique_together = (('compound', 'test_cytotoxicity_description'),)

    def __str__(self):
        return 'Compound cytotoxicity result for test {} on {}'.format(self.test_cytotoxicity_description.id, self.compound.id)


class TestPKDescription(models.Model):
    ADMINISTRATION_MODES = (
        ('IV', ''),
        ('PO', ''),
        ('IP', ''),
        ('SL', 'SL')
    )
    biblio = models.ForeignKey(Bibliography, models.CASCADE)
    test_name = models.CharField('Pharmacokinetic test name', max_length=100)
    organism = models.ForeignKey(Taxonomy, models.CASCADE)
    administration_mode = models.CharField(
        'Administration mode', max_length=2, choices=ADMINISTRATION_MODES, blank=True, null=True)
    concentration = models.DecimalField(
        'Concentration in mg/l', max_digits=7, decimal_places=3, blank=True, null=True)
    dose = models.DecimalField(
        'Dose in mg/kg', max_digits=9, decimal_places=4, blank=True, null=True)
    dose_interval = models.IntegerField(
        'Dose interval, in hours', blank=True, null=True)


class CompoundPKResult(models.Model):
    compound = models.ForeignKey(Compound, models.CASCADE)
    test_pk_description = models.ForeignKey(TestPKDescription, models.CASCADE)
    tolerated = models.NullBooleanField('Tolerated', null=True)
    auc = models.IntegerField(
        'Area under curve (ng.mL-1.hr)', blank=True, null=True)
    clearance = models.DecimalField(
        'Clearance (mL/hr)', max_digits=7, decimal_places=3, blank=True, null=True)
    c_max = models.DecimalField(
        'Maximal concentration (ng/mL)', max_digits=7, decimal_places=3, blank=True, null=True)
    oral_bioavailability = models.IntegerField(
        'Oral Bioavailability (%F)', blank=True, null=True)
    t_demi = models.IntegerField('t½', blank=True, null=True)
    t_max = models.IntegerField('tmax', blank=True, null=True)
    voldistribution = models.DecimalField(
        'Volume distribution (Vd)', max_digits=5, decimal_places=2, blank=True, null=True)

    class Meta:
        unique_together = (('compound', 'test_pk_description'),)

    def __str__(self):
        return 'Compound PK result for test {} on {}'.format(self.test_pk_description.id, self.compound.id)


class CompoundAction(models.Model):
    ACTIVATION_MODES = (
        ('O', 'Orthosteric'),
        ('A', 'Allosteric'),
        ('U', 'Unspecified')
    )
    compound = models.ForeignKey(Compound, models.CASCADE)
    activation_mode = models.CharField(
        'Activation mode', max_length=1, choices=ACTIVATION_MODES)
    ppi = models.ForeignKey(Ppi, models.CASCADE)
    ligand_id = models.CharField('PDB Ligand ID', max_length=3, blank=True, null=True)
    nb_copy_compounds = models.IntegerField(
        'Number of copies for the compound')

    class Meta:
        unique_together = (('ppi', 'compound', 'activation_mode', 'ligand_id'),)

    def get_complexes(self):
        """
        get the complexes involved in the compound action
        which are always the bound complexes
        """
        return self.ppi.get_ppi_bound_complexes()

    def __str__(self):
        return 'Action of {} on {}'.format(self.compound, self.ppi)

class RefCompoundBiblio(models.Model):
    compound = models.ForeignKey(Compound, models.CASCADE)
    bibliography = models.ForeignKey(Bibliography, models.CASCADE)
    compound_name = models.CharField(
        'Compound name in the publication', max_length=50)

    class Meta:
        unique_together = (('compound', 'bibliography'),)

class DrugBankCompound(models.Model):
    id = models.TextField(
        'Drugbank ID', unique=True, primary_key=True)
    common_name = models.TextField('Common name')
    canonical_smiles = models.TextField(
        'Canonical SMILES')

class DrugbankCompoundTanimoto(models.Model):
    compound = models.ForeignKey(Compound, models.CASCADE)
    drugbank_compound = models.ForeignKey(DrugBankCompound, models.CASCADE)
    tanimoto = models.DecimalField(
        'Tanimoto value', max_digits=5, decimal_places=4)