mandos.search.chembl.target_traversal_strategy

Complexity

Total Complexity

18

Size/Duplication

Total Lines	273
Duplicated Lines	0 %

Importance

Changes

0

11 Methods

Rating	Name	Duplication	Size	Complexity
A	TargetTraversalStrategies.strategy1()	0	3	1
A	TargetTraversalStrategy1.__call__()	0	29	1
A	TargetTraversalStrategies.create()	0	20	1
A	TargetTraversalStrategy0.__call__()	0	7	1
A	TargetTraversalStrategy.api()	0	3	1
A	TargetTraversalStrategies.by_name()	0	17	1
A	TargetTraversalStrategies.strategy2()	0	3	1
A	TargetTraversalStrategy.__call__()	0	7	1
A	TargetTraversalStrategies.strategy0()	0	3	1
C	TargetTraversalStrategy2.__call__()	0	136	8
A	TargetTraversalStrategy.traverse()	0	2	1

import abc

Missing module docstring

import sys
from typing import Sequence, Type

from mandos.chembl_api import ChemblApi
from mandos.model.targets import DagTargetLinkType, Target, TargetRelationshipType, TargetType


class TargetTraversalStrategy(metaclass=abc.ABCMeta):

Empty class docstring

    """"""

    @classmethod
    def api(cls) -> ChemblApi:

Missing function or method docstring

        raise NotImplementedError()

    def traverse(self, target: Target) -> Sequence[Target]:

Missing function or method docstring

        return self.__call__(target)

    def __call__(self, target: Target) -> Sequence[Target]:
        """

        Returns:

        """
        raise NotImplementedError()


class TargetTraversalStrategy0(TargetTraversalStrategy, metaclass=abc.ABCMeta):

Empty class docstring

    """"""

    def __call__(self, target: Target) -> Sequence[Target]:
        """

        Returns:

        """
        return [target]


class TargetTraversalStrategy1(TargetTraversalStrategy, metaclass=abc.ABCMeta):

Empty class docstring

    """"""

    def __call__(self, target: Target) -> Sequence[Target]:
        """
        Returns:

        """
        edges = {
            DagTargetLinkType(
                TargetType.selectivity_group,
                TargetRelationshipType.superset_of,
                TargetType.protein_complex_group,
            ),
            DagTargetLinkType(
                TargetType.protein_complex_group,
                TargetRelationshipType.subset_of,
                TargetType.protein_complex_group,
            ),
            DagTargetLinkType(
                TargetType.selectivity_group,
                TargetRelationshipType.superset_of,
                TargetType.protein_family,
            ),
            DagTargetLinkType(
                TargetType.protein_family,
                TargetRelationshipType.subset_of,
                TargetType.protein_family,
            ),
        }
        found = target.traverse(edges)
        return [f.target for f in found if f.is_end]


class TargetTraversalStrategy2(TargetTraversalStrategy, metaclass=abc.ABCMeta):

Empty class docstring

    """"""

    def __call__(self, target: Target) -> Sequence[Target]:
        """

        Returns:

        """
        # traverse the DAG up and down, following only desired links
        # some links from complex to complex group are "overlaps with"
        # ex: CHEMBL4296059
        # it's also rare to need going from a selectivity group "down" to complex group / family / etc.

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

        # usually they have a link upwards
        # so...
        # If it's a single protein, it's too risk to traverse up into complexes
        # That's because lots of proteins *occasionally* make complexes, and there are some weird ones

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

        # BUT We want to catch some obvious cases like GABA A subunits
        # ChEMBL calls many of these "something subunit something"
        # This is the only time we'll allow going directly from protein to complex
        # In this case, we'll also disallow links form protein to family,
        # just because we're pretty sure it's a subunit
        # But we can go from single protein to complex to complex group to family
        if (
            target.type

Wrong hanging indentation before block (add 4 spaces).

            in [

Wrong hanging indentation before block (add 4 spaces).

                TargetType.single_protein,
                TargetType.protein_family,
                TargetType.protein_complex,
                TargetType.protein_complex_group,
            ]
            and ("subunit" in target.name.split(" ") or "chain" in target.name.split(" "))

Wrong hanging indentation before block (add 4 spaces).

        ):
            edges = {
                DagTargetLinkType(
                    TargetType.single_protein,
                    TargetRelationshipType.subset_of,
                    TargetType.protein_complex,
                ),
                DagTargetLinkType(
                    TargetType.protein_complex,
                    TargetRelationshipType.subset_of,
                    TargetType.protein_complex_group,
                ),
                DagTargetLinkType(
                    TargetType.protein_complex,
                    TargetRelationshipType.overlaps_with,
                    TargetType.protein_complex_group,
                ),
                DagTargetLinkType(
                    TargetType.protein_complex_group,
                    TargetRelationshipType.subset_of,
                    TargetType.protein_complex_group,
                ),
                DagTargetLinkType(
                    TargetType.protein_complex_group,
                    TargetRelationshipType.subset_of,
                    TargetType.protein_family,
                ),
                DagTargetLinkType(
                    TargetType.protein_family,
                    TargetRelationshipType.subset_of,
                    TargetType.protein_family,
                ),
            }
        elif target.type in [TargetType.single_protein, TargetType.protein_family]:
            edges = {
                DagTargetLinkType(
                    TargetType.single_protein,
                    TargetRelationshipType.subset_of,
                    TargetType.protein_family,
                ),
                DagTargetLinkType(
                    TargetType.protein_family,
                    TargetRelationshipType.subset_of,
                    TargetType.protein_family,
                ),
            }
        elif target.type in [TargetType.protein_complex, TargetType.protein_complex_group]:
            edges = {
                DagTargetLinkType(
                    TargetType.protein_complex,
                    TargetRelationshipType.subset_of,
                    TargetType.protein_complex_group,
                ),
                DagTargetLinkType(
                    TargetType.protein_complex,
                    TargetRelationshipType.overlaps_with,
                    TargetType.protein_complex_group,
                ),
                DagTargetLinkType(
                    TargetType.protein_complex_group,
                    TargetRelationshipType.subset_of,
                    TargetType.protein_complex_group,
                ),
                DagTargetLinkType(
                    TargetType.protein_complex_group,
                    TargetRelationshipType.subset_of,
                    TargetType.protein_family,
                ),
                DagTargetLinkType(
                    TargetType.protein_family,
                    TargetRelationshipType.subset_of,
                    TargetType.protein_family,
                ),
            }
        elif target.type == TargetType.selectivity_group:
            edges = {
                DagTargetLinkType(
                    TargetType.selectivity_group,
                    TargetRelationshipType.superset_of,
                    TargetType.protein_complex_group,
                ),
                DagTargetLinkType(
                    TargetType.protein_complex_group,
                    TargetRelationshipType.subset_of,
                    TargetType.protein_complex_group,
                ),
                DagTargetLinkType(
                    TargetType.selectivity_group,
                    TargetRelationshipType.superset_of,
                    TargetType.protein_family,
                ),
                DagTargetLinkType(
                    TargetType.protein_family,
                    TargetRelationshipType.subset_of,
                    TargetType.protein_family,
                ),
            }
        else:
            return [target]
        for edge in set(edges):
            edges.add(
                DagTargetLinkType(
                    edge.source_type, TargetRelationshipType.equivalent_to, edge.dest_type
                )
            )
        found = target.traverse(edges)
        return [f.target for f in found if f.is_end]


class TargetTraversalStrategies:
    """
    Factory.
    """

    @classmethod
    def by_name(cls, fully_qualified: str, api: ChemblApi) -> TargetTraversalStrategy:
        """
        For dependency injection.

        Args:
            fully_qualified:
            api:

        Returns:

        """
        s = fully_qualified

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

        mod = s[: s.rfind(".")]
        clz = s[s.rfind(".") :]
        x = getattr(sys.modules[mod], clz)

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 cls.create(x, api)

    @classmethod
    def strategy0(cls, api: ChemblApi) -> TargetTraversalStrategy:

Missing function or method docstring

        return cls.create(TargetTraversalStrategy0, api)

    @classmethod
    def strategy1(cls, api: ChemblApi) -> TargetTraversalStrategy:

Missing function or method docstring

        return cls.create(TargetTraversalStrategy1, api)

    @classmethod
    def strategy2(cls, api: ChemblApi) -> TargetTraversalStrategy:

Missing function or method docstring

        return cls.create(TargetTraversalStrategy2, api)

    @classmethod
    def create(cls, clz: Type[TargetTraversalStrategy], api: ChemblApi) -> TargetTraversalStrategy:
        """
        Factory method.

        Args:
            clz:
            api:

        Returns:

        """

        class X(clz):

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

Missing class docstring

            @classmethod
            def api(cls) -> ChemblApi:

Missing function or method docstring

                return api

        X.__name__ = clz.__name__
        return X()


__all__ = ["TargetTraversalStrategy", "TargetTraversalStrategies"]