mandos.search.chembl.protein_search

Complexity

Total Complexity

13

Size/Duplication

Total Lines	142
Duplicated Lines	0 %

Importance

Changes

0

8 Methods

Rating	Name	Duplication	Size	Complexity
A	ProteinSearch.traversal_strategy()	0	5	2
A	ProteinSearch.should_include()	0	18	1
A	ProteinSearch.query()	0	2	1
A	ProteinSearch.to_hit()	0	24	1
A	ProteinSearch.process()	0	26	4
A	ProteinSearch.find_all()	0	5	1
A	ProteinSearch.find()	0	16	2
A	ProteinSearch.default_traversal_strategy()	0	3	1

import abc

Missing module docstring

import logging
from dataclasses import dataclass
from typing import Sequence, TypeVar

from pocketutils.core.dot_dict import NestedDotDict

Unable to import 'pocketutils.core.dot_dict'

from mandos.model import AbstractHit, ChemblCompound, Search
from mandos.model.targets import Target, TargetFactory
from mandos.search.chembl.target_traversal_strategy import (
    TargetTraversalStrategies,
    TargetTraversalStrategy,
)

logger = logging.getLogger("mandos")


@dataclass(frozen=True, order=True, repr=True)
class ProteinHit(AbstractHit, metaclass=abc.ABCMeta):
    """
    A protein target entry for a compound.
    """


H = TypeVar("H", bound=ProteinHit, covariant=True)

Class name "H" doesn't conform to PascalCase naming style ('[^\\W\\da-z][^\\W_]+$' pattern)

class ProteinSearch(Search[H], metaclass=abc.ABCMeta):
    """
    Abstract search.
    """

    def find_all(self, compounds: Sequence[str]) -> Sequence[H]:

Missing function or method docstring

        logger.info(

Use lazy % formatting in logging functions

            f"Using traversal strategy {self.traversal_strategy.__class__.__name__} for {self.search_name}"

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

        )
        return super().find_all(compounds)

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

Missing function or method docstring

        raise NotImplementedError()

    @property
    def traversal_strategy(self) -> TargetTraversalStrategy:

Missing function or method docstring

        if self.config.traversal_strategy is None:
            return self.default_traversal_strategy
        return TargetTraversalStrategies.by_name(self.config.traversal_strategy, self.api)

    @property
    def default_traversal_strategy(self) -> TargetTraversalStrategy:

Missing function or method docstring

        raise NotImplementedError()

    def should_include(
        self, lookup: str, compound: ChemblCompound, data: NestedDotDict, target: Target

Wrong hanging indentation before block (add 4 spaces).

    ) -> bool:
        """
        Filter based on the returned (activity/mechanism) data.
        IGNORE filters about the target itself, including whether it's a valid target.
        Return True in these cases (better yet, don't check).

        Args:
            lookup:
            compound:
            data:
            target:

        Returns:

        """
        raise NotImplementedError()

    def to_hit(
        self, lookup: str, compound: ChemblCompound, data: NestedDotDict, best_target: Target

Wrong hanging indentation before block (add 4 spaces).

The argument lookup seems to be unused.

The argument compound seems to be unused.

    ) -> Sequence[H]:
        """
        Gets the desired data as a NestedDotDict from the data from a single element
        returned by ``api_endpoint.filter``.
        This MUST MATCH the constructor, EXCEPT for object_id and object_name,
        which come from traversal and should be added by ``ProteinSearch.to_hit`` (parameter ``best_target``).

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

        Turns the final data into ``H``.
        Note that this has a default behavior but could be overridden to split into multiple hits
        and/or to add additional attributes that might come from ``best_target``.

        Args:
            lookup:
            compound:
            data:
            best_target:

        Returns:
            A sequence of hits.
        """
        h = self.get_h()

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

        return [h(**data, object_id=best_target.chembl, object_name=best_target.name)]

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

        Args:
            lookup:

        Returns:e

        """
        form = self.get_compound(lookup)
        results = self.query(form)
        hits = []
        for result in results:
            result = NestedDotDict(result)
            hits.extend(self.process(lookup, form, result))
        return hits

    def process(self, lookup: str, compound: ChemblCompound, data: NestedDotDict) -> Sequence[H]:
        """

        Args:
            lookup:
            compound:
            data:

        Returns:

        """
        if data.get("target_chembl_id") is None:
            logger.debug(f"target_chembl_id missing from mechanism '{data}' for compound {lookup}")

Use lazy % formatting in logging functions

            return []
        chembl_id = data["target_chembl_id"]
        target_obj = TargetFactory.find(chembl_id, self.api)
        if not self.should_include(lookup, compound, data, target_obj):
            return []
        # traverse() will return the source target if it's a non-traversable type (like DNA)
        # and the subclass decided whether to filter those
        # so don't worry about that here
        ancestors = self.traversal_strategy(target_obj)

self.traversal_strategy does not seem to be callable.

        lst = []
        for ancestor in ancestors:
            lst.extend(self.to_hit(lookup, compound, data, ancestor))
        return lst


__all__ = ["ProteinHit", "ProteinSearch"]