mandos.model.chembl_support.chembl_targets

Complexity

Total Complexity

31

Size/Duplication

Total Lines	321
Duplicated Lines	0 %

Importance

Changes

0

15 Methods

Rating	Name	Duplication	Size	Complexity
A	TargetType.protein_types()	0	3	1
A	DagTargetLinkType.cross()	0	13	4
A	TargetType.of()	0	8	2
A	ChemblTarget.traverse()	0	16	1
A	TargetType.all_types()	0	3	1
A	TargetType.is_protein()	0	7	1
A	ChemblTarget.api()	0	8	1
A	TargetRelationshipType.of()	0	3	1
A	ChemblTarget.find()	0	20	2
A	DagTargetLinkType.matches()	0	20	4
A	TargetType.is_traversable()	0	8	1
A	TargetType.is_unknown()	0	3	1
B	ChemblTarget._traverse()	0	46	7
A	ChemblTarget.links()	0	21	3
A	TargetFactory.find()	0	20	1

"""
Model of ChEMBL targets and a hierarchy between them as a directed acyclic graph (DAG).
"""
from __future__ import annotations

import abc
import enum
import logging
import re
from dataclasses import dataclass
from typing import Optional, Sequence, Set
from typing import Tuple as Tup

from urllib3.util.retry import MaxRetryError

Unable to import 'urllib3.util.retry'

from pocketutils.core.dot_dict import NestedDotDict

Unable to import 'pocketutils.core.dot_dict'

from mandos.model.chembl_api import ChemblApi

logger = logging.getLogger(__package__)


class TargetNotFoundError(ValueError):

Empty class docstring

    """"""


class TargetType(enum.Enum):
    """
    Enum corresponding to the ChEMBL API field ``target.target_type``.
    """

    single_protein = enum.auto()
    protein_family = enum.auto()
    protein_complex = enum.auto()
    protein_complex_group = enum.auto()
    selectivity_group = enum.auto()
    protein_protein_interaction = enum.auto()
    nucleic_acid = enum.auto()
    chimeric_protein = enum.auto()
    protein_nucleic_acid_complex = enum.auto()
    metal = enum.auto()
    small_molecule = enum.auto()
    subcellular = enum.auto()
    unknown = enum.auto()

    @classmethod
    def of(cls, s: str) -> TargetType:

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

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

Missing function or method docstring

        key = s.replace(" ", "_").replace("-", "_").lower()
        try:
            return TargetType[key]
        except KeyError:
            logger.error(f"Target type {key} not found. Using TargetType.unknown.")

Use lazy % formatting in logging functions

            return TargetType.unknown

    @classmethod
    def protein_types(cls) -> Set[TargetType]:

Missing function or method docstring

        return {s for s in cls if s.is_protein}

    @classmethod
    def all_types(cls) -> Set[TargetType]:

Missing function or method docstring

        return set(TargetType)  # here for symmetry

    @property
    def is_traversable(self) -> bool:

Missing function or method docstring

        return self in {
            TargetType.single_protein,
            TargetType.protein_family,
            TargetType.protein_complex,
            TargetType.protein_complex_group,
            TargetType.selectivity_group,
        }

    @property
    def is_protein(self) -> bool:

Missing function or method docstring

        return self in {
            TargetType.single_protein,
            TargetType.protein_family,
            TargetType.protein_complex,
            TargetType.protein_complex_group,
        }

    @property
    def is_unknown(self) -> bool:

Missing function or method docstring

        return self == TargetType.unknown


class TargetRelationshipType(enum.Enum):

Missing class docstring

    subset_of = enum.auto()
    superset_of = enum.auto()
    overlaps_with = enum.auto()
    equivalent_to = enum.auto()

    @classmethod
    def of(cls, s: str) -> TargetRelationshipType:

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

Missing function or method docstring

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

        return TargetRelationshipType[s.replace(" ", "_").replace("-", "_").lower()]


@dataclass(frozen=True, order=True, repr=True)

Missing class docstring

class DagTargetLinkType:
    source_type: TargetType
    rel_type: TargetRelationshipType
    dest_type: TargetType
    words: Optional[Set[str]]

    @classmethod
    def cross(

Missing function or method docstring

        cls,

Wrong hanging indentation before block (add 4 spaces).

        source_types: Set[TargetType],

Wrong hanging indentation before block (add 4 spaces).

        rel_types: Set[TargetRelationshipType],

Wrong hanging indentation before block (add 4 spaces).

        dest_types: Set[TargetType],

Wrong hanging indentation before block (add 4 spaces).

    ) -> Set[DagTargetLinkType]:
        st = set()

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

        for source in source_types:
            for rel in rel_types:
                for dest in dest_types:
                    st.add(DagTargetLinkType(source, rel, dest, None))
        return st

    def matches(

Missing function or method docstring

        self,

Wrong hanging indentation before block (add 4 spaces).

        source: TargetType,

Wrong hanging indentation before block (add 4 spaces).

        rel: TargetRelationshipType,

Wrong hanging indentation before block (add 4 spaces).

        target: TargetType,

Wrong hanging indentation before block (add 4 spaces).

        target_name: Optional[str],

Wrong hanging indentation before block (add 4 spaces).

    ) -> bool:
        if self.words is None:
            words_match = True
        else:
            words_match = False
            for choice in self.words:
                if any((word == choice for word in re.compile(r"[ \-_]+").split(target_name))):

The variable word does not seem to be defined in case the for loop on line 129 is not entered. Are you sure this can never be the case?

                    words_match = True
                    break
        return (
            self.source_type == source
            and self.rel_type == rel
            and self.dest_type == target
            and words_match
        )


@dataclass(frozen=True, order=True, repr=True)

Missing class docstring

class DagTarget:
    depth: int
    is_end: bool
    target: ChemblTarget
    link_type: Optional[DagTargetLinkType]


@dataclass(frozen=True, order=True, repr=True)
class ChemblTarget(metaclass=abc.ABCMeta):
    """
    A target from ChEMBL, from the ``target`` table.
    ChEMBL targets form a DAG via the ``target_relation`` table using links of type "SUPERSET OF" and "SUBSET OF".

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

    (There are additional link types ("OVERLAPS WITH", for ex), which we are ignoring.)
    For some receptors the DAG happens to be a tree. This is not true in general. See the GABAA receptor, for example.

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

    To fetch a target, use the ``find`` factory method.

    Attributes:
        chembl: The CHEMBL ID, starting with 'CHEMBL'
        name: The preferred name (``pref_target_name``)
        type: From the ``target_type`` ChEMBL field
    """

    chembl: str
    name: Optional[str]
    type: TargetType

    @classmethod
    def api(cls) -> ChemblApi:
        """

        Returns:

        """
        raise NotImplementedError()

    @classmethod
    def find(cls, chembl: str) -> ChemblTarget:
        """

        Args:
            chembl:

        Returns:

        """
        try:
            targets = cls.api().target.filter(target_chembl_id=chembl)
        except MaxRetryError:
            raise TargetNotFoundError(f"Failed to find target {chembl}")
        assert len(targets) == 1, f"Found {len(targets)} targets for {chembl}"
        target = NestedDotDict(targets[0])
        return cls(
            chembl=target["target_chembl_id"],
            name=target.get("pref_name"),
            type=TargetType.of(target["target_type"]),
        )

    def links(
        self, rel_types: Set[TargetRelationshipType]

Wrong hanging indentation before block (add 4 spaces).

    ) -> Sequence[Tup[ChemblTarget, TargetRelationshipType]]:
        """
        Gets adjacent targets in the DAG.

        Args:
            rel_types:

        Returns:
        """
        relations = self.__class__.api().target_relation.filter(target_chembl_id=self.chembl)
        links = []
        # "subset" means "up" (it's reversed from what's on the website)
        for superset in relations:
            linked_id = superset["related_target_chembl_id"]
            rel_type = TargetRelationshipType.of(superset["relationship"])
            if rel_type in rel_types:
                linked_target = self.find(linked_id)
                links.append((linked_target, rel_type))
        return sorted(links)

    def traverse(self, permitting: Set[DagTargetLinkType]) -> Set[DagTarget]:
        """
        Traverses the DAG from this node, hopping only to targets with type in the given set.

        Args:
            permitting: The set of target types we're allowed to follow links onto

        Returns:
            The targets in the set, in a breadth-first order (then sorted by CHEMBL ID)
            The int is the depth, starting at 0 (this protein), going to +inf for the highest ancestors

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

        """
        results = set()
        # purposely use the invalid value None for is_root
        self._traverse(DagTarget(0, None, self, None), permitting, results)
        assert not any((x.is_end is None for x in results))

The variable x does not seem to be defined.

        return results

    @classmethod
    def _traverse(
        cls, source: DagTarget, permitting: Set[DagTargetLinkType], results: Set[DagTarget]

Wrong hanging indentation before block (add 4 spaces).

    ) -> None:
        # recursive method called from traverse
        # this got really complex
        # basically, we just want to:
        # for each link (relationship) to another target:
        # for every allowed link type (DagTargetLinkType), try:
        # if the link type is acceptable, add the found target and associated link type, and break
        # all good if we've already traversed this
        if source.target.chembl in {s.target.chembl for s in results}:
            return
        # find all links from ChEMBL, then filter to only the valid links
        # do not traverse yet -- we just want to find these links
        link_candidates = source.target.links({q.rel_type for q in permitting})
        links = []
        for linked_target, rel_type in link_candidates:
            # try out all of the link types that could match
            # getting to the link_target by way of any of them is fine
            # although the DagTarget takes the link_type, we'll just go ahead and break if we find one acceptable link

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

            # the links are already sorted, so that should be fine
            # (otherwise, we just end up with redundant targets)
            for permitted in permitting:
                if permitted.matches(
                    source.target.type, rel_type, linked_target.type, linked_target.name

Wrong hanging indentation before block (add 4 spaces).

                ):
                    link_type = DagTargetLinkType(
                        source.target.type, rel_type, linked_target.type, permitted.words
                    )
                    # purposely use the invalid value None for is_root
                    linked = DagTarget(source.depth + 1, None, linked_target, link_type)
                    links.append(linked)
                    break
        # now, we'll add our own (breadth-first, remember)
        # we know whether we're at an "end" node by whether we found any links
        # note that this is an invariant of the node (and permitted link types): it doesn't depend on traversal order

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

        is_at_end = len(links) == 0
        results.add(DagTarget(source.depth, is_at_end, source.target, source.link_type))
        # alright! now traverse on the links
        for link in links:
            # this check is needed
            # otherwise we can go superset --- subset --- superset ---
            # or just --- overlaps with --- overlaps with ---
            if link not in results:
                cls._traverse(link, permitting, results)


class TargetFactory:
    """
    Factory for ``Target`` that injects a ``ChemblApi``.
    """

    @classmethod
    def find(cls, chembl: str, api: ChemblApi) -> ChemblTarget:
        """

        Args:
            chembl:
            api:

        Returns:
            A ``Target`` instance from a newly created subclass of that class
        """

        @dataclass(frozen=True, order=True, repr=True)
        class _Target(ChemblTarget):
            @classmethod
            def api(cls) -> ChemblApi:
                return api

        _Target.__name__ = "Target:" + chembl
        return _Target.find(chembl)


__all__ = [
    "TargetType",
    "TargetRelationshipType",
    "ChemblTarget",
    "DagTarget",
    "TargetFactory",
    "DagTargetLinkType",
    "TargetNotFoundError",
]