models.py

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

from __future__ import unicode_literals

import operator
import re

from django.conf import settings
from django.contrib.auth import get_user_model
from django.core.exceptions import ValidationError
from django.db import models, transaction
from django.db.models import FloatField, IntegerField, BooleanField
from django.db.models import Max, Count, F, Q, Case, When, Subquery, OuterRef
from django.db.models.functions import Cast
from django.urls import reverse
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, get_doi_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):
        auto_fill_needed = not self.is_autofill_done()
        if kwargs.get('autofill') is True or auto_fill_needed:
            auto_fill_needed = True
            self.autofill()
        if 'autofill' in kwargs:
            del kwargs['autofill']
        super(AutoFillableModel, self).save(*args, **kwargs)
        if auto_fill_needed:
            self.autofill_post_save()

    def autofill(self):
        raise NotImplementedError()

    def autofill_post_save(self):
        """
        method called after the save is done, usefull for settings m2m relations
        :return:
        """
        pass

    def is_autofill_done(self):
        return True


class Bibliography(AutoFillableModel):
    """
    Bibliography references
    (publications or patents)
    """
    SOURCES = (
        ('PM', 'PubMed ID'),
        ('PT', 'Patent'),
        ('DO', 'DOI')
    )
    id_source_validators = dict(
        PM=re.compile("^[0-9]+$"),
        PT=re.compile("^.*$"),
        DO=re.compile("^10.\d{4,9}/.+$"),
    )
    source = models.CharField(
        'Bibliographic type', max_length=2, choices=SOURCES, default=SOURCES[0][0])
    id_source = models.CharField('Bibliographic ID', max_length=25)
    title = models.TextField('Title')
    journal_name = models.TextField('Journal name', null=True, blank=True)
    authors_list = models.TextField('Authors list')
    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)
        elif self.source == 'PT':
            info = get_google_patent_info(self.id_source)
        elif self.source == 'DO':
            info = get_doi_info(self.id_source)
        else:
            raise NotImplementedError()
        self.title = info['title']
        self.journal_name = info['journal_name']
        self.authors_list = info['authors_list']
        self.biblio_year = info['biblio_year']

    def is_autofill_done(self):
        return len(self.title) > 0

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

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

    def get_external_url(self):
        if self.source == 'PM':
            return "https://www.ncbi.nlm.nih.gov/pubmed/" + str(self.id_source)
        if self.source == 'DO':
            return "https://doi.org/" + 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"
        verbose_name = "Bibliography"

    def data_and_study(self):
        ret = []
        for f in [
            "cytotox",
            "xray",
            "in_silico",
            "in_vitro",
            "in_cellulo",
            "in_vivo",
            "pharmacokinetic",
        ]:
            if getattr(self, f, False):
                ret.append(self._meta.get_field(f).verbose_name.title())
        return ", ".join(ret)

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

    def get_absolute_url(self):
        return reverse('biblio-view', kwargs={'biblio_pk': self.pk})


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

    def is_autofill_done(self):
        return self.description is not None and len(self.description) > 0

    @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)
    domains = models.ManyToManyField('Domain')

    @transaction.atomic
    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']

        gene_names = info['gene_names']
        # put whatever name it find
        self.gene_name = gene_names[0]['name']
        # then try to find the primary, if present
        for gene_name in gene_names:
            if gene_name["type"] == "primary":
                self.gene_name = gene_name["name"]
                break

        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
        self.__info = info

    def autofill_post_save(self):
        info = self.__info
        for go_id in info['molecular_functions']:
            mol_function, created = MolecularFunction.objects.get_or_create(go_id=go_id)
            self.molecular_functions.add(mol_function)

        for domain_id in info['domains']:
            domain, created = Domain.objects.get_or_create(pfam_acc=domain_id)
            self.domains.add(domain)

    def is_autofill_done(self):
        return len(self.gene_name) > 0

    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, blank=True, default="")

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

    def is_autofill_done(self):
        return self.pfam_id is not None and len(self.pfam_id) > 0

    @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, null=True, blank=True)
    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(
        _('ppp_copy_nb_per_p')
    )

    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, blank=True)
    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 get_absolute_url(self):
        return reverse('ppi-view', kwargs={'ppi_pk': self.pk})

    def is_autofill_done(self):
        return 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
        """
        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(
        verbose_name=_('cc_nb_verbose_name'),
        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_old(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=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=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()))
        # number of tests available
        qs = qs.annotate(tests_av=Count('compoundactivityresult', distinct=True))
        # @formatter:on
        return qs


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

    pubs = models.IntegerField(
        verbose_name='Number of publications', null=True, blank=True
    )    
    best_activity = models.DecimalField(
        'Best activity', max_digits=12, decimal_places=10, null=True, blank=True)
    best_activity_ppi_family_name = models.CharField('Best activity PPI family name', max_length=30, null=True, blank=True)
    le = models.FloatField(
        verbose_name='Ligand efficiency', null=True, blank=True
    )
    lle = models.FloatField(
        verbose_name='Lipophilic efficiency', null=True, blank=True
    )
    lipinsky_mw = models.BooleanField('MW ok for Lipinsky', null=True, blank=True)
    lipinsky_hba = models.BooleanField('Hydrogen bond acceptors ok for Lipinsky', null=True, blank=True)
    lipinsky_hbd = models.BooleanField('Hydrogen bond donors ok for Lipinsky', null=True, blank=True)
    lipinsky_a_log_p = models.BooleanField('A log P ok for Lipinsky', null=True, blank=True)
    lipinsky_score = models.IntegerField(
        verbose_name='Lipinsky score', null=True, blank=True
    )
    lipinsky = models.BooleanField('Lipinsky ok', null=True, blank=True)
    hba_hbd = models.IntegerField(
        verbose_name='Sum of Hydrogen bond acceptors and donors', null=True, blank=True
    )
    veber_hba_hbd = models.BooleanField('HBA+HBD ok for Veber', null=True, blank=True)
    veber_tpsa = models.BooleanField('TPSA ok for Veber', null=True, blank=True)
    veber_rb = models.BooleanField('Rotatable bonds ok for Veber', null=True, blank=True)
    veber = models.BooleanField('Veber ok', null=True, blank=True)
    pfizer_a_log_p = models.BooleanField('A log P ok for Pfizer', null=True, blank=True)
    pfizer_tpsa = models.BooleanField('TPSA ok for Pfizer', null=True, blank=True)
    pfizer = models.BooleanField('Pfizer ok', null=True, blank=True)
    pdb_ligand_av = models.BooleanField('PDB ligand available', null=True, blank=True)
    inhibition_role = models.BooleanField('Inhibition role', null=True, blank=True)
    binding_role = models.BooleanField('Binding role', null=True, blank=True)
    stabilisation_role = models.BooleanField('Stabilisation role', null=True, blank=True)
    celltest_av = models.BooleanField('Cellular tests performed', null=True, blank=True)
    inhitest_av = models.BooleanField('Inhibition tests performed', null=True, blank=True)
    stabtest_av = models.BooleanField('Stabilisation tests performed', null=True, blank=True)
    bindtest_av = models.BooleanField('Binding tests performed', null=True, blank=True)
    pktest_av = models.BooleanField('Pharmacokinetic tests performed', null=True, blank=True)
    cytoxtest_av = models.BooleanField('Cytotoxicity tests performed', null=True, blank=True)
    insilico_av = models.BooleanField('In silico tests performed', null=True, blank=True)
    tests_av = models.IntegerField(verbose_name='Number of tests available', null=True, blank=True)


    class Meta:
        ordering = ['id']
        indexes = [
            models.Index(fields=['molecular_weight']),
            models.Index(fields=['a_log_p']),
            models.Index(fields=['nb_donor_h']),
            models.Index(fields=['nb_acceptor_h']),
            models.Index(fields=['tpsa']),
            models.Index(fields=['nb_rotatable_bonds']),
            models.Index(fields=['nb_aromatic_sssr']),
            models.Index(fields=['nb_chiral_centers']),
            models.Index(fields=['fsp3']),
            models.Index(fields=['pubs']),
            models.Index(fields=['best_activity']),
            models.Index(fields=['le']),
            models.Index(fields=['lle']),
        ]
        # indexes = [
        #     models.Index(fields=['lipinsky']),
        #     models.Index(fields=['veber']),
        #     models.Index(fields=['pfizer']),
        #     models.Index(fields=['pdb_ligand_av']),
        #     models.Index(fields=['inhibition_role']),
        #     models.Index(fields=['binding_role']),
        #     models.Index(fields=['stabilisation_role']),
        #     models.Index(fields=['binding_role']),
        # ]

    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