models.py

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

from __future__ import unicode_literals

import operator
import re

from django.conf import settings
from django.core.exceptions import ValidationError
from django.db import models
from django.db.models import FloatField, IntegerField, BooleanField
from django.db.models import Max, Count, F, Q, Case, When
from django.db.models.functions import Cast
from django.utils.translation import ugettext_lazy as _

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 references
    (publications or patents)
    """
    SOURCES = (
        ('PM', 'PubMed ID'),
        ('PT', 'Patent'),
        ('DO', 'DOI ID')
    )
    id_source_validators = dict(
        PM=re.compile("^[0-9]+$"),
        PT=re.compile("^.*$"),
        DO=re.compile("^.*$"),
    )
    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):
        """
        fetch information from external services
        (Pubmed or Google patents)
        """
        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']

    def clean(self):
        super().clean()
        Bibliography.validate_source_id(self.id_source, self.source)

    def has_external_url(self):
        return self.source == 'PM'

    def get_external_url(self):
        if self.source == 'PM':
            return "https://www.ncbi.nlm.nih.gov/pubmed/" + str(self.id_source)

    @staticmethod
    def validate_source_id(id_source, source):
        id_source_validator = Bibliography.id_source_validators[source]
        if not id_source_validator.match(id_source):
            raise ValidationError(
                dict(
                    id_source=_("Must match pattern %s for this selected source" % id_source_validator.pattern)
                )
            )
        return True

    class Meta:
        verbose_name_plural = "bibliographies"

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


class Taxonomy(AutoFillableModel):
    """
    Taxonomy IDs (from NCBI Taxonomy) 
    and the corresponding human-readable name
    """
    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):
        """
        fetch information from external services
        (NCBI Entrez)
        """
        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):
    """
    Molecular functions (from Gene Ontology) 
    and the corresponding human-readable description
    """
    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):
        """
        fetch information from external services
        (EBI OLS)
        """
        info = get_go_info(self.go_id)
        self.description = info['label']

    @property
    def name(self):
        return self.go_id + ' ' + self.description

    def __str__(self):
        return self.description


class Protein(AutoFillableModel):
    """
    Protein information (from Uniprot) 
    and the corresponding human-readable name
    """
    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):
        """
        fetch information from external services
        (Uniprot) and create Taxonomy/Molecular Functions if needed
        """
        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):
    """
    Domain (i.e. Protein domain) information (from PFAM) 
    """
    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):
        """
        fetch information from external services
        (PFAM)
        """
        info = get_pfam_info(self.pfam_acc)
        self.pfam_id = info['id']
        self.pfam_description = info['description']

    @property
    def name(self):
        return self.pfam_id

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


class ProteinDomainComplex(models.Model):
    """
    Protein-Domain association
    """
    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):
    """
    Protein-Domain association with a "bound complex" role
    """
    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):
    """
    Protein-Domain association with a "partner complex" role
    """

    class Meta:
        verbose_name_plural = "partner complexes"


class Symmetry(models.Model):
    """
    Symmetry of a PPI
    """
    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):
    """
    PPI Family
    """
    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):
    """
    PPI
    """
    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 Complex
    """
    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):
    """
    CompoundManager adds automatically a number of annotations to the results
    of the database query, used for filters and compound card
    """

    def get_queryset(self):
        # @formatter:off
        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()))
        # Lipinsky MW (<=500)
        qs = qs.annotate(lipinsky_mw=Case(When(molecular_weight__lte=500, then=True), default=False, output_field=BooleanField()))
        # Lipinsky hba (<=10)
        qs = qs.annotate(lipinsky_hba=Case(When(nb_acceptor_h__lte=10, then=True), default=False, output_field=BooleanField()))
        # Lipinsky hbd (<5)
        qs = qs.annotate(lipinsky_hbd=Case(When(nb_donor_h__lte=5, then=True), default=False, output_field=BooleanField()))
        # Lipinsky a_log_p (<5)
        qs = qs.annotate(lipinsky_a_log_p=Case(When(a_log_p__lte=5, then=True), default=False, output_field=BooleanField()))
        # Lipinsky global
        qs = qs.annotate(lipinsky_score=Cast(F('lipinsky_mw'), IntegerField())+Cast(F('lipinsky_hba'), IntegerField())+ \
            Cast(F('lipinsky_hbd'), IntegerField()) + Cast(F('lipinsky_a_log_p'), IntegerField()))
        qs = qs.annotate(lipinsky=Case(When(lipinsky_score__gte=3, then=True), default=False, output_field=BooleanField()))
        # Veber hba_hbd (<=12)
        qs = qs.annotate(hba_hbd=F('nb_acceptor_h')+F('nb_donor_h'))
        qs = qs.annotate(veber_hba_hbd=Case(When(hba_hbd__lte=12, then=True), default=False, output_field=BooleanField()))
        # Veber TPSA (<=140)
        qs = qs.annotate(veber_tpsa=Case(When(tpsa__lte=140, then=True), default=False, output_field=BooleanField()))
        # Veber Rotatable Bonds (<=10)
        qs = qs.annotate(veber_rb=Case(When(nb_rotatable_bonds__lte=10, then=True), default=False, output_field=BooleanField()))
        # Veber global (Rotatable bonds and (hba_hbd or tpsa))
        #qs = qs.annotate(veber=F('veber_rb').bitand(F('veber_hba_hbd').bitor(F('veber_tpsa'))))
        qs = qs.annotate(veber=Case(When(Q(Q(nb_rotatable_bonds__lte=10) & (Q(hba_hbd__lte=12) | Q(tpsa__lte=140))), then=True), default=False, output_field=BooleanField()))
        # Pfizer AlogP (<=3)
        qs = qs.annotate(pfizer_a_log_p=Case(When(a_log_p__lte=3, then=True), default=False, output_field=BooleanField()))
        # Pfizer TPSA (>=75)
        qs = qs.annotate(pfizer_tpsa=Case(When(tpsa__gte=75, then=True), default=False, output_field=BooleanField()))
        # Pfizer global (AlogP and TPSA)
        #qs = qs.annotate(pfizer=F('pfizer_a_log_p').bitand(F('pfizer_tpsa')))
        qs = qs.annotate(pfizer=Case(When(Q(Q(a_log_p__lte=3) & Q(tpsa__gte=75)), then=True), default=False, output_field=BooleanField()))
        # PDB ligand available
        qs = qs.annotate(pdb_ligand_av=Cast(Max(Case(When(compoundaction__ligand_id__isnull=False, then=1), default=0, output_field=IntegerField())), BooleanField()))
        # inhibition role
        qs = qs.annotate(inhibition_role=Case(When(compoundactivityresult__modulation_type='I', then=True), default=False, output_field=BooleanField()))
        # binding role
        qs = qs.annotate(binding_role=Case(When(compoundactivityresult__modulation_type='B', then=True), default=False, output_field=BooleanField()))
        # stabilisation role
        qs = qs.annotate(stabilisation_role=Case(When(compoundactivityresult__modulation_type='S', then=True), default=False, output_field=BooleanField()))
        # cellular tests performed
        qs = qs.annotate(celltest_av=Cast(Max(Case(When(compoundactivityresult__test_activity_description__test_type='CELL', then=1), default=0, output_field=IntegerField())), BooleanField()))
        # inhibition tests performed
        qs = qs.annotate(inhitest_av=Cast(Max(Case(When(compoundactivityresult__test_activity_description__test_modulation_type='I', then=1), default=0, output_field=IntegerField())), BooleanField()))
        # stabilisation tests performed
        qs = qs.annotate(stabtest_av=Cast(Max(Case(When(compoundactivityresult__test_activity_description__test_modulation_type='S', then=1), default=0, output_field=IntegerField())), BooleanField()))
        # binding tests performed
        qs = qs.annotate(bindtest_av=Cast(Max(Case(When(compoundactivityresult__test_activity_description__test_modulation_type='B', then=1), default=0, output_field=IntegerField())), BooleanField()))
        # pharmacokinetic tests performed
        qs = qs.annotate(pktest_av=Cast(Max(Case(When(refcompoundbiblio__bibliography__pharmacokinetic=True, then=1), default=0, output_field=IntegerField())), BooleanField()))
        # cytotoxicity tests performedudy
        qs = qs.annotate(cytoxtest_av=Cast(Max(Case(When(refcompoundbiblio__bibliography__cytotox=True, then=1), default=0, output_field=IntegerField())), BooleanField()))
        # in silico st performed
        qs = qs.annotate(insilico_av=Cast(Max(Case(When(refcompoundbiblio__bibliography__in_silico=True, then=1), default=0, output_field=IntegerField())), BooleanField()))
        #@formatter:on
        return qs


class Compound(AutoFillableModel):
    """
    Chemical compound
    """
    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 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):
    """
    Compute the Tanimoto similarity between a given SMILES and the compounds
    then insert the results in CompoundTanimoto
    """
    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
    the table contains all the data as one JSON text in one row
    """
    pca_biplot_data = models.TextField(
        'PCA biplot JSON data', blank=True, null=True)


class LeLleBiplotData(models.Model):
    """
    LE-LLE biplot data
    the table contains all the data as one JSON text in one row
    """
    le_lle_biplot_data = models.TextField(
        'LE-LLE biplot JSON data', blank=True, null=True)


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

    def __str__(self):
        return self.name


class TestActivityDescription(models.Model):
    """
    Activity test descriptions
    """
    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,
        on_delete=models.CASCADE,
    )
    protein_domain_bound_complex = models.ForeignKey(
        ProteinDomainBoundComplex,
        on_delete=models.CASCADE,
    )
    ppi = models.ForeignKey(Ppi, models.CASCADE, blank=True, null=True)
    test_name = models.CharField(
        verbose_name='Test name',
        max_length=100,
    )
    is_primary = models.BooleanField(
        verbose_name='Is primary',
    )
    protein_bound_construct = models.CharField(
        verbose_name='Protein bound construct',
        max_length=5,
        choices=PROTEIN_BOUND_CONSTRUCTS,
        blank=True,
        null=True,
    )
    test_type = models.CharField(
        verbose_name='Test type',
        max_length=5,
        choices=TEST_TYPES,
    )
    test_modulation_type = models.CharField(
        verbose_name='Test modulation type',
        max_length=1,
        choices=TEST_MODULATION_TYPES,
    )
    nb_active_compounds = models.IntegerField(
        verbose_name='Total number of active compounds',
    )
    cell_line = models.ForeignKey(
        CellLine,
        on_delete=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

    @property
    def name(self):
        return self.test_name

    def __str__(self):
        return self.get_test_type_display()


class CompoundActivityResult(models.Model):
    """
    Activity test results on a compound
    """
    MODULATION_TYPES = (
        ('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):
    """
    Cytotoxicity test descriptions
    """
    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):
    """
    Cytotoxicity test results on a compound
    """
    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):
    """
    Pharmacokinetic test descriptions
    """
    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):
    """
    Pharmacokinetic test results on a compound
    """
    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):
    """
    Compound action
    """
    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-Bibliographic reference association
    """
    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):
    """
    Drugbank compound
    """