mandos.chembl_api

Complexity

Total Complexity

29

Size/Duplication

Total Lines	273
Duplicated Lines	0 %

Importance

Changes

0

28 Methods

Rating	Name	Duplication	Size	Complexity
A	ChemblApi.drug()	0	3	1
A	ChemblApi.target_relation()	0	3	1
A	ChemblApi.atc_class()	0	3	1
A	ChemblEntrypoint.wrap()	0	20	1
A	ChemblApi.protein_class()	0	3	1
A	ChemblApi.molecule_form()	0	3	1
A	ChemblFilterQuery.__getitem__()	0	2	1
A	ChemblApi.wrap()	0	17	1
A	ChemblApi.target_prediction()	0	3	1
A	ChemblApi.target()	0	3	1
A	ChemblFilterQuery.wrap()	0	27	1
A	ChemblEntrypoint.filter()	0	2	1
A	ChemblFilterQuery.__iter__()	0	2	1
A	ChemblFilterQuery.mock()	0	26	1
A	ChemblFilterQuery.only()	0	11	1
A	ChemblApi.mechanism()	0	3	1
A	ChemblFilterQuery.__len__()	0	2	1
A	ChemblApi.go_slim()	0	3	1
A	ChemblApi.organism()	0	3	1
A	ChemblApi.activity()	0	3	1
A	ChemblApi.assay()	0	3	1
A	ChemblApi.mock()	0	17	1
A	ChemblApi.__getattribute__()	0	2	1
A	ChemblEntrypoint.get()	0	2	1
A	ChemblEntrypoint.mock()	0	28	2
A	ChemblApi.drug_indication()	0	3	1
A	ChemblApi.molecule()	0	3	1
A	ChemblApi.target_component()	0	3	1

"""
An abstraction for the ChEMBL REST API.
Designed to facilitate testing, but also improves static type checking.
"""
from __future__ import annotations

import abc
import logging
from typing import Any, Callable, Iterator, Mapping, Optional, Sequence, Set, List, Union, Iterable

Unused Set imported from typing

Unused List imported from typing

Unused Union imported from typing

Unused Iterable imported from typing

from pocketutils.core.dot_dict import NestedDotDict

Unable to import 'pocketutils.core.dot_dict'

logger = logging.getLogger("mandos")

from mandos import MandosResources

Import "from mandos import MandosResources" should be placed at the top of the module

Unused MandosResources imported from mandos

class ChemblFilterQuery(metaclass=abc.ABCMeta):
    """
    Wraps the result of calling ``filter`` on a ChEMBL query.
    Supports iterating over results (``__iter__`), getting a single item (``__getitem__`), and calling ``only(lst)``.

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

    """

    def only(self, items: Sequence[str]) -> ChemblFilterQuery:
        """
        Turns this into a query for a single record.

        Args:
            items:

        Returns:

        """
        raise NotImplementedError()

    def __getitem__(self, item: int) -> NestedDotDict:
        raise NotImplementedError()

    def __len__(self) -> int:
        raise NotImplementedError()

    def __iter__(self) -> Iterator[NestedDotDict]:
        raise NotImplementedError()

    @classmethod
    def mock(cls, items: Sequence[dict]):
        """
        Mocks.

        Args:
            items:

        Returns:

        """

        class F(ChemblFilterQuery):

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

Missing class docstring

            def only(self, _: Sequence[str]) -> ChemblFilterQuery:
                return self

            def __getitem__(self, item: int) -> NestedDotDict:
                return NestedDotDict(items[item])

            def __len__(self) -> int:
                return len(items)

            def __iter__(self) -> Iterator[NestedDotDict]:
                return iter([NestedDotDict(x) for x in items])

        return F()

    @classmethod
    def wrap(cls, query):
        """
        Wraps.

        Args:
            query:

        Returns:

        """

        class F(ChemblFilterQuery):

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

Missing class docstring

            def only(self, items: Sequence[str]) -> ChemblFilterQuery:
                # TODO technically not returning this

TODO and FIXME comments should generally be avoided.

                return getattr(query, "only")(items)

            def __getitem__(self, item: int) -> NestedDotDict:
                return NestedDotDict(query[item])

            def __len__(self) -> int:
                return len(query)

            def __iter__(self) -> Iterator[NestedDotDict]:
                return iter([NestedDotDict(x) for x in query])

        return F()


class ChemblEntrypoint:
    """
    Wraps just part of a node in the ChEMBL REST API.
    Ex ``Chembl.target``.
    """

    def filter(self, **kwargs) -> ChemblFilterQuery:

Missing function or method docstring

        raise NotImplementedError()

    def get(self, arg: str) -> Optional[NestedDotDict]:

Missing function or method docstring

        raise NotImplementedError()

    @classmethod
    def mock(
        cls,

Wrong hanging indentation before block (add 4 spaces).

        get_items: Mapping[str, dict],

Wrong hanging indentation before block (add 4 spaces).

        filter_items: Optional[Callable[[Mapping[str, Any]], Sequence[dict]]] = None,

Wrong hanging indentation before block (add 4 spaces).

    ) -> ChemblEntrypoint:
        """

        Args:
            get_items: Map from single arg for calling ``get`` to the item to return
            filter_items: Map from kwarg-set for calling ``filter`` to the list of items to return;
                          If None, returns ``items`` in all cases

        Returns:

        """

        class X(ChemblEntrypoint):

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

Missing class docstring

            def filter(self, **kwargs) -> ChemblFilterQuery:
                if filter_items is None:
                    return ChemblFilterQuery.mock(list(get_items.values()))
                items = filter_items(kwargs)
                return ChemblFilterQuery.mock(items)

            def get(self, arg: str) -> Optional[NestedDotDict]:
                return NestedDotDict(get_items[arg])

        return X()

    @classmethod
    def wrap(cls, obj) -> ChemblEntrypoint:
        """

        Args:
            obj:

        Returns:

        """

        class X(ChemblEntrypoint):

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

Missing class docstring

            def filter(self, **kwargs) -> ChemblFilterQuery:
                query = getattr(obj, "filter")(**kwargs)
                return ChemblFilterQuery.wrap(query)

            def get(self, arg: str) -> Optional[NestedDotDict]:
                return NestedDotDict(getattr(obj, "get")(arg))

        return X()


class ChemblApi(metaclass=abc.ABCMeta):
    """
    Wraps the whole ChEMBL API.
    """

    @property
    def activity(self) -> ChemblEntrypoint:

Missing function or method docstring

        return self.__dict__["activity"]

    @property
    def assay(self) -> ChemblEntrypoint:

Missing function or method docstring

        return self.__dict__["assay"]

    @property
    def atc_class(self) -> ChemblEntrypoint:

Missing function or method docstring

        return self.__dict__["atc_class"]

    @property
    def drug(self) -> ChemblEntrypoint:

Missing function or method docstring

        return self.__dict__["drug"]

    @property
    def drug_indication(self) -> ChemblEntrypoint:

Missing function or method docstring

        return self.__dict__["drug_indication"]

    @property
    def mechanism(self) -> ChemblEntrypoint:

Missing function or method docstring

        return self.__dict__["mechanism"]

    @property
    def molecule(self) -> ChemblEntrypoint:

Missing function or method docstring

        return self.__dict__["molecule"]

    @property
    def molecule_form(self) -> ChemblEntrypoint:

Missing function or method docstring

        return self.__dict__["molecule_form"]

    @property
    def organism(self) -> ChemblEntrypoint:

Missing function or method docstring

        return self.__dict__["mechanism"]

    @property
    def go_slim(self) -> ChemblEntrypoint:

Missing function or method docstring

        return self.__dict__["go_slim"]

    @property
    def target(self) -> ChemblEntrypoint:

Missing function or method docstring

        return self.__dict__["target"]

    @property
    def target_relation(self) -> ChemblEntrypoint:

Missing function or method docstring

        return self.__dict__["target_relation"]

    @property
    def protein_class(self) -> ChemblEntrypoint:

Missing function or method docstring

        return self.__dict__["protein_class"]

    @property
    def target_component(self) -> ChemblEntrypoint:

Missing function or method docstring

        return self.__dict__["target_component"]

    @property
    def target_prediction(self) -> ChemblEntrypoint:

Missing function or method docstring

        return self.__dict__["target_prediction"]

    def __getattribute__(self, item: str) -> ChemblEntrypoint:
        raise NotImplementedError()

    @classmethod
    def mock(cls, entrypoints: Mapping[str, ChemblEntrypoint]) -> ChemblApi:
        """
        Mocks.

        Args:
            entrypoints:

        Returns:

        """

        class X(ChemblApi):

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

Missing class docstring

            def __getattribute__(self, item: str) -> ChemblEntrypoint:
                return entrypoints[item]

        return X()

    @classmethod
    def wrap(cls, obj) -> ChemblApi:
        """
        Wraps.

        Args:
            obj:

        Returns:

        """

        class X(ChemblApi):

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

Missing class docstring

            def __getattribute__(self, item: str) -> ChemblEntrypoint:
                return ChemblEntrypoint.wrap(getattr(obj, item))

        return X()


__all__ = [
    "ChemblApi",
    "ChemblEntrypoint",
    "ChemblFilterQuery",
]