models.py

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

from __future__ import unicode_literals

import operator
import re
import sys

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 django_celery_results.models import TaskResult
from django.dispatch import receiver
from django.db.models.signals import post_save

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 setting 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(r"^[0-9]+$"),
        PT=re.compile(r"^.*$"),
        DO=re.compile(r"^10.\d{4,9}/.+$"),
    )
    source = models.CharField(
        "Bibliographic type", max_length=2, choices=SOURCES, default=SOURCES[0][0]
    )
    id_source = models.TextField("Bibliographic ID")
    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=_(
                        f"Must match pattern {id_source_validator.pattern}"
                        " for this selected source"
                    )
                )
            )
        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, blank=True, null=True
    )
    short_name = models.CharField("Short name", max_length=50)
    gene_name = models.CharField("Gene name", max_length=30, blank=True, null=True)
    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
        try:
            self.gene_name = gene_names[0]["name"]
        except IndexError:
            pass
        # 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.entry_name) > 0

    def __str__(self):
        return "{} ({})".format(
            self.uniprot_id, self.recommended_name_long or self.short_name
        )


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 f"{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.short_name, 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=256)
    identifier = models.CharField("Identifier", max_length=32, null=True, blank=True)

    def __str__(self):
        return "%s (%s)" % (self.name, self.identifier)


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(sorted(bound_protein_names))
        partner_str = ",".join(sorted(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 CompoundsManager(models.Manager):
    def for_user(self, current_user):
        """
        Get compounds visible to a given user
        i.e. validated or created by the user or
        all of them if the user is an admin
        """
        qs = self.get_queryset()
        if current_user.is_anonymous:
            qs = qs.exclude(compoundaction__ppi__contribution__validated=False)
        elif not current_user.is_superuser:
            qs = qs.exclude(
                Q(compoundaction__ppi__contribution__validated=False),
                ~Q(compoundaction__ppi__contribution__contributor=current_user),
            )
        return qs

    def validated(self):
        """
        Get validated compounds
        """
        return (
            super()
            .get_queryset()
            .exclude(compoundaction__ppi__contribution__validated=False)
        )


class Compound(AutoFillableModel):
    """
    Chemical compound
    """

    objects = CompoundsManager()

    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
    )
    ligand_id = models.CharField("PDB Ligand ID", max_length=3, 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
    )
    families = models.TextField("PPI family names", 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"]),
        ]
        # default_manager_name = 'ippidb.models.ValidatedCompoundsManager'
        # 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"))