mandos.search.chembl.activity_search

Complexity

Total Complexity

29

Size/Duplication

Total Lines	140
Duplicated Lines	0 %

Importance

Changes

0

6 Methods

Rating	Name	Duplication	Size	Complexity
F	ActivitySearch.should_include()	0	45	21
A	ActivitySearch.to_hit()	0	7	1
A	ActivitySearch.default_traversal_strategy()	0	3	1
A	ActivityHit.predicate()	0	3	1
A	ActivitySearch.query()	0	14	3
A	ActivitySearch._extract()	0	20	2

import logging

Missing module docstring

from dataclasses import dataclass
from typing import Sequence
import re

from pocketutils.core.dot_dict import NestedDotDict

Unable to import 'pocketutils.core.dot_dict'

from mandos.model import ChemblCompound
from mandos.model.targets import Target
from mandos.search.chembl.protein_search import ProteinHit, ProteinSearch
from mandos.search.chembl.target_traversal_strategy import (
    TargetTraversalStrategy,
    TargetTraversalStrategies,
)

logger = logging.getLogger("mandos")


@dataclass(frozen=True, order=True, repr=True)
class ActivityHit(ProteinHit):
    """
    An "activity" hit for a compound.
    """

    taxon_id: int
    taxon_name: str
    pchembl: float
    std_type: str
    src_id: str
    exact_target_id: str

    @property
    def predicate(self) -> str:
        return "activity"


class ActivitySearch(ProteinSearch[ActivityHit]):
    """
    Search for ``activity``.
    """

    @property
    def default_traversal_strategy(self) -> TargetTraversalStrategy:

Missing function or method docstring

        return TargetTraversalStrategies.strategy0(self.api)

    def query(self, parent_form: ChemblCompound) -> Sequence[NestedDotDict]:

Missing function or method docstring

        def set_to_regex(values) -> str:
            return "(" + "|".join([f"(?:{re.escape(v)})" for v in values]) + ")"

        filters = dict(
            parent_molecule_chembl_id=parent_form.chid,
            assay_type__iregex=set_to_regex(self.config.allowed_assay_types),
            standard_relation__iregex=set_to_regex(self.config.allowed_relations),
            pchembl_value__isnull=False if self.config.require_pchembl else None,
            target_organism__isnull=False if self.config.require_taxon else None,
        )
        # I'd rather not figure out how the API interprets None, so remove them
        filters = {k: v for k, v in filters.items() if v is not None}
        return list(self.api.activity.filter(**filters))

    def should_include(

Missing function or method docstring

        self, lookup: str, compound: ChemblCompound, data: NestedDotDict, target: Target

Wrong hanging indentation before block (add 4 spaces).

The argument compound seems to be unused.

    ) -> bool:
        if (
            data.get_as("data_validity_comment", lambda s: s.lower())

Wrong hanging indentation before block (add 4 spaces).

Too many boolean expressions in if statement (11/5)

            in {s.lower() for s in self.config.banned_flags}

Wrong hanging indentation before block (add 4 spaces).

            or data.req_as("standard_relation", str) not in self.config.allowed_relations

Wrong hanging indentation before block (add 4 spaces).

            or data.req_as("assay_type", str) not in self.config.allowed_assay_types

Wrong hanging indentation before block (add 4 spaces).

            or data.get("target_tax_id") is None

Wrong hanging indentation before block (add 4 spaces).

            and self.config.require_taxon

Wrong hanging indentation before block (add 4 spaces).

            or data.get_as("target_tax_id", int) not in self.tax

Wrong hanging indentation before block (add 4 spaces).

            and self.config.require_taxon

Wrong hanging indentation before block (add 4 spaces).

            or data.get("pchembl_value") is None

Wrong hanging indentation before block (add 4 spaces).

            and self.config.require_pchembl

Wrong hanging indentation before block (add 4 spaces).

            or data.req_as("pchembl_value", float) < self.config.min_pchembl

Wrong hanging indentation before block (add 4 spaces).

            and self.config.require_pchembl

Wrong hanging indentation before block (add 4 spaces).

        ):
            return False
        if data.get("data_validity_comment") is not None:
            logger.warning(

Use lazy % formatting in logging functions

                f"Activity annotation for {lookup} has flag '{data.get('data_validity_comment')} (ok)"

This line is too long as per the coding-style (102/100).

            )
        # The `target_organism` doesn't always match the `assay_organism`
        # Ex: see assay CHEMBL823141 / document CHEMBL1135642 for homo sapiens in xenopus laevis
        # However, it's often something like yeast expressing a human / mouse / etc receptor
        # So there's no need to filter by it
        assay = self.api.assay.get(data.req_as("assay_chembl_id", str))
        confidence_score = assay.get("confidence_score")
        if target.type.name.lower() not in {s.lower() for s in self.config.allowed_target_types}:
            logger.warning(f"Excluding {target} with type {target.type}")

Use lazy % formatting in logging functions

            return False
        if self.config.require_confidence_score:
            if confidence_score is None or confidence_score < self.config.min_confidence_score:
                return False
            # Even if we supposedly allow the target type, it doesn't make sense for some confidence scores

This line is too long as per the coding-style (107/100).

            # Some of these are non-protein types]
            # And if it's unknown, we don't know what to do with it
            if (
                target.type.is_unknown

Wrong hanging indentation before block (add 4 spaces).

                or target.type.is_strange

Wrong hanging indentation before block (add 4 spaces).

                and self.config.min_confidence_score > 3

Wrong hanging indentation before block (add 4 spaces).

            ):
                logger.warning(f"Excluding {target} with type {target.type}")

Use lazy % formatting in logging functions

                return False
        return True

    def to_hit(

Missing function or method docstring

        self, lookup: str, compound: ChemblCompound, data: NestedDotDict, target: Target

Wrong hanging indentation before block (add 4 spaces).

    ) -> Sequence[ActivityHit]:
        # these must match the constructor of the Hit,
        # EXCEPT for object_id and object_name, which come from traversal
        x = self._extract(lookup, compound, data)

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

        return [ActivityHit(**x, object_id=target.chembl, object_name=target.name)]

    def _extract(self, lookup: str, compound: ChemblCompound, data: NestedDotDict) -> NestedDotDict:
        # we know these exist from the query
        organism = data.req_as("target_organism", str)
        tax_id = data.req_as("target_tax_id", int)
        tax = self.tax.req(tax_id)
        if organism != tax.name:
            logger.warning(f"Target organism {organism} is not {tax.name}")

Use lazy % formatting in logging functions

        return NestedDotDict(
            dict(
                record_id=data.req_as("activity_id", str),
                compound_id=compound.chid,
                inchikey=compound.inchikey,
                compound_name=compound.name,
                compound_lookup=lookup,
                taxon_id=tax.id,
                taxon_name=tax.name,
                pchembl=data.req_as("pchembl_value", float),
                std_type=data.req_as("standard_type", str),
                src_id=data.req_as("src_id", str),
                exact_target_id=data.req_as("target_chembl_id", str),
            )
        )


__all__ = ["ActivityHit", "ActivitySearch"]