mandos.search.chembl.target_predictions

Complexity

Total Complexity

21

Size/Duplication

Total Lines	149
Duplicated Lines	0 %

Importance

Changes

0

6 Methods

Rating	Name	Duplication	Size	Complexity
B	TargetPredictionSearch.process()	0	44	5
B	TargetPredictionSearch.__init__()	0	29	5
A	TargetPredictionSearch.find()	0	8	2
A	TargetPredictionSearch.data_source()	0	3	1
A	TargetPredictionSearch.page()	0	3	1
B	TargetPredictionSearch._get_taxon()	0	17	7

from __future__ import annotations

Missing module docstring

from typing import Sequence, Optional, Tuple, Set

import numpy as np

Unable to import 'numpy'

from mandos.model.apis.chembl_support.chembl_target_graphs import (
    ChemblTargetGraphFactory,
    ChemblTargetGraph,
)
from mandos.model.apis.chembl_support.chembl_targets import TargetFactory
from pocketutils.tools.string_tools import StringTools

Unable to import 'pocketutils.tools.string_tools'

Unused StringTools imported from pocketutils.tools.string_tools

from mandos import logger

Imports from package mandos are not grouped

from mandos.model.taxonomy import Taxonomy, Taxon
from typeddfs import TypedDf

Unable to import 'typeddfs'

from mandos.model.apis.chembl_api import ChemblApi

Imports from package mandos are not grouped

from mandos.model.apis.chembl_scrape_api import (
    ChemblScrapePage,
    ChemblScrapeApi,
    ChemblTargetPredictionTable,
)
from mandos.model.apis.chembl_support import ChemblCompound
from mandos.model.apis.chembl_support.chembl_utils import ChemblUtils
from mandos.search.chembl import ChemblScrapeSearch
from mandos.model.concrete_hits import ChemblTargetPredictionHit
from mandos.search.chembl.target_traversal import TargetTraversalStrategies

P = ChemblScrapePage.target_predictions
T = ChemblTargetPredictionTable


class TargetPredictionSearch(ChemblScrapeSearch[ChemblTargetPredictionHit]):

Empty class docstring

    """ """

    @classmethod
    def page(cls) -> ChemblScrapePage:

Missing function or method docstring

        return ChemblScrapePage.target_predictions

    def __init__(

Too many arguments (11/5)

        self,

Wrong hanging indentation before block (add 4 spaces).

        key: str,

Wrong hanging indentation before block (add 4 spaces).

        api: ChemblApi,

Wrong hanging indentation before block (add 4 spaces).

        scrape: ChemblScrapeApi,

Wrong hanging indentation before block (add 4 spaces).

        taxa: Sequence[Taxonomy],

Wrong hanging indentation before block (add 4 spaces).

        traversal: str,

Wrong hanging indentation before block (add 4 spaces).

        target_types: Set[str],

Wrong hanging indentation before block (add 4 spaces).

        required_level: int = 70,

Wrong hanging indentation before block (add 4 spaces).

        min_threshold: float = 1.0,

Wrong hanging indentation before block (add 4 spaces).

        binding_score: float = 1.0,

Wrong hanging indentation before block (add 4 spaces).

        nonbinding_score: float = 1.0,

Wrong hanging indentation before block (add 4 spaces).

    ):
        super().__init__(key, api, scrape)
        self.taxa = taxa
        self.traversal_strategy = TargetTraversalStrategies.by_name(traversal, self.api)
        self.target_types = target_types
        if required_level not in [70, 80, 90]:
            raise ValueError(f"required_level must be 70, 80, or 90, not {required_level}")
        if min_threshold <= 0:
            raise ValueError(f"min_threshold must be positive, not {min_threshold}")
        if binding_score <= 0:
            raise ValueError(f"binding_score must be positive, not {binding_score}")
        if nonbinding_score <= 0:
            raise ValueError(f"nonbinding_score must be positive, not {nonbinding_score}")
        self.required_level = required_level
        self.min_threshold = min_threshold
        self.binding_score = binding_score
        self.nonbinding_score = nonbinding_score

    @property
    def data_source(self) -> str:

Missing function or method docstring

        return "ChEMBL :: target predictions"

    def find(self, lookup: str) -> Sequence[ChemblTargetPredictionHit]:

Missing function or method docstring

        ch = ChemblUtils(self.api).get_compound_dot_dict(lookup)

Variable name "ch" doesn't conform to snake_case naming style ('([^\\W\\dA-Z][^\\WA-Z]2,|_[^\\WA-Z]*|__[^\\WA-Z\\d_][^\\WA-Z]+__)$' pattern)

        compound = ChemblUtils(self.api).compound_dot_dict_to_obj(ch)
        table: TypedDf = self.scrape.fetch_predictions(compound.chid)
        hits = []
        for row in table.itertuples():
            hits.extend(self.process(lookup, compound, row))
        return hits

    def process(

Missing function or method docstring

This function exceeds the maximum number of variables (19/15).

        self, lookup: str, compound: ChemblCompound, row

Wrong hanging indentation before block (add 4 spaces).

    ) -> Sequence[ChemblTargetPredictionHit]:
        tax_id, tax_name = self._get_taxon(row.target_organism)
        if tax_id is tax_name is None:
            return []
        thresh = row.activity_threshold
        if row.activity_threshold < self.min_threshold:
            return []
        factory = TargetFactory(self.api)
        target_obj = factory.find(row.target_chembl_id)
        graph_factory = ChemblTargetGraphFactory.create(self.api, factory)
        graph = graph_factory.at_target(target_obj)
        ancestors: Sequence[ChemblTargetGraph] = self.traversal_strategy(graph)
        lst = []
        for ancestor in ancestors:
            for conf_t, conf_v in zip(
                [70, 80, 90], [row.confidence_70, row.confidence_80, row.confidence_90]

Wrong hanging indentation before block (add 4 spaces).

            ):
                predicate = f"binding:{conf_v.yes_no_mixed}"
                weight = (
                    np.sqrt(thresh)
                    * abs(conf_t / (100 - conf_t) * conf_v.score)
                    / 4
                    / np.sqrt(self.min_threshold)
                )
                hit = self._create_hit(
                    c_origin=lookup,
                    c_matched=compound.inchikey,
                    c_id=compound.chid,
                    c_name=compound.name,
                    predicate=predicate,
                    object_id=ancestor.chembl,
                    object_name=ancestor.name,
                    data_source=self.data_source,
                    exact_target_id=row.target_chembl_id,
                    exact_target_name=row.target_pref_name,
                    weight=weight,
                    prediction=conf_v,
                    confidence_set=conf_t,
                    threshold=thresh,
                )
                lst.append(hit)
        return lst

    def _get_taxon(self, organism: str) -> Tuple[Optional[int], Optional[str]]:
        if len(self.taxa) == 0:  # allow all
            return None, organism
        matches = {}
        for tax in self.taxa:
            matches += tax.get_by_id_or_name(organism)
        if len(matches) == 0:
            logger.debug(f"Taxon {organism} not in set. Excluding.")
            return None, None
        best: Taxon = next(iter(matches))
        if best.scientific_name != organism and best.mnemonic != organism:

Consider merging these comparisons with "in" to 'organism not in (best.scientific_name, best.mnemonic)'

            logger.warning(f"Organism {organism} matched to {best.scientific_name} by common name")
        if len(matches) > 1:
            logger.warning(
                f"Multiple matches for taxon {organism}: {matches}; using {best.scientific_name}"
            )
        return best.id, organism


__all__ = ["TargetPredictionSearch"]