models.py

from __future__ import unicode_literals

from django.db import models
from django_pandas.managers import DataFrameManager
from django.db.models import Max

from .ws import get_pubmed_info, get_epo_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)
    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_epo_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)

    def __str__(self):
        return self.name

class Ppi(models.Model):
    pdb_id = models.CharField('PDB ID', max_length=4, null=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)

    def __str__(self):
        return '{} PPI, PDB:{}'.format(self.symmetry.description, self.pdb_id or 'unknown')

    def get_ppi_complexes(self):
        """
        return all ppi complexes belonging to this ppi
        """
        return PpiComplex.objects.filter(ppi=self)

    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())

    @property
    def name(self):
        all_protein_names = set([ppi_complex.complex.protein.short_name for ppi_complex in self.get_ppi_complexes()])
        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 Compound(models.Model):
    canonical_smile = models.CharField(
        'Canonical Smile', unique=True, max_length=500)
    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')
    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)
    mddr_compound = models.ForeignKey(
        'MDDRCompoundImport', models.CASCADE, blank=True, null=True)

    objects = DataFrameManager()

    @property
    def biblio_refs(self):
        """
        return all RefCompoundBiblio related to this complex
        """
        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_pdb_ids(self):
        """
        return all PDB codes of the corresponding compound actions
        """
        pdb_ids = set()
        for ca in self.compoundaction_set.all():
            pdb_ids.add(ca.pdb_id)
        return pdb_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 le(self):
        """
        LE: Ligand Efficiency
        """
        best_pXC50_activity = self.best_pXC50_activity
        if best_pXC50_activity is None:
            return None
        return (1.37 * float(best_pXC50_activity))/self.nb_atom_non_h

    @property
    def lle(self):
        """
        LLE: Lipophilic Efficiency
        """
        best_pXC50_activity = self.best_pXC50_activity
        if best_pXC50_activity is None:
            return None
        return float(best_pXC50_activity - self.a_log_p)     

    @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 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()


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

class MDDRActivityClass(models.Model):
    name = models.CharField('Activity Class', max_length=100, unique=True)

    class Meta:
        verbose_name_plural = "MDDR activity classes"

    def __str__(self):
        return self.name


class MDDRCompoundImport(models.Model):

    MDDR_DEVELOPMENT_PHASES = (
        ('Biological Testing', ''),
        ('Preclinical', ''),
        ('Phase III', ''),
        ('Phase II', ''),
        ('Phase I/II', ''),
        ('Phase I', ''),
        ('Launched', ''),
        ('Pre-Registered', ''),
        ('Not Applicable', ''),
        ('Discontinued', ''),
        ('Clinical', ''),
        ('Withdrawn', ''),
        ('Registered', ''),
        ('Not Determined', ''),
        ('Phase II/III', ''),
        ('IND Filed', ''),
    )

    mddr_name = models.CharField('MDDR name', max_length=40)
    dvpmt_phase = models.CharField(
        'Development phase', max_length=20, choices=MDDR_DEVELOPMENT_PHASES)
    canonical_smile = models.CharField(
        'Canonical Smile', max_length=500, blank=True, null=True)
    # TODO index this table on canonical_smile
    db_import_date = models.DateTimeField('MDDR release year/month')
    activity_classes = models.ManyToManyField(MDDRActivityClass)

    class Meta:
        # over multiple releases of the MDDR database, the same compound can evolve in its development phase
        # the same compound can have different names and development phases in
        # the same MDDR release
        unique_together = (('mddr_name', 'dvpmt_phase', 'canonical_smile'),)
        verbose_name_plural = "MDDR compound imports"

    def __str__(self):
        return "{}, {}".format(self.mddr_name, self.dvpmt_phase)


class MDDRSimilarity(models.Model):
    canonical_smile_ippidb = models.CharField(
        'Canonical Smile for IPPIDB compound', max_length=500, unique=True, blank=True, null=True)
    canonical_smile_mddr = models.CharField(
        'Canonical Smile for MDDR Compound', max_length=500, unique=True, blank=True, null=True)
    tanimoto = models.DecimalField('Tanimoto', max_digits=6, decimal_places=5)

    class Meta:
        unique_together = (('canonical_smile_ippidb', 'canonical_smile_mddr'),)
        verbose_name_plural = "MDDR similarities"


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.get_ppi_complexes()
        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)
    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)
    cmax = 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)
    pdb_id = models.CharField('PDB ID', max_length=4, blank=True, null=True)
    nb_copy_compounds = models.IntegerField(
        'Number of copies for the compound')

    class Meta:
        unique_together = (('ppi', 'compound', 'activation_mode', 'pdb_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()


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'),)