mandos.model.apis.chembl_api

Complexity

Total Complexity

29

Size/Duplication

Total Lines	270
Duplicated Lines	0 %

Importance

Changes

0

28 Methods

Rating	Name	Duplication	Size	Complexity
A	ChemblApi.molecule_form()	0	3	1
A	ChemblEntrypoint.filter()	0	2	1
A	ChemblApi.target_relation()	0	3	1
A	ChemblFilterQuery.__len__()	0	2	1
A	ChemblApi.go_slim()	0	3	1
A	ChemblApi.wrap()	0	17	1
A	ChemblApi.drug()	0	3	1
A	ChemblEntrypoint.wrap()	0	20	1
A	ChemblFilterQuery.only()	0	11	1
A	ChemblApi.activity()	0	3	1
A	ChemblFilterQuery.mock()	0	26	1
A	ChemblFilterQuery.wrap()	0	27	1
A	ChemblApi.drug_indication()	0	3	1
A	ChemblApi.protein_class()	0	3	1
A	ChemblApi.target_component()	0	3	1
A	ChemblApi.mock()	0	17	1
A	ChemblApi.target()	0	3	1
A	ChemblApi.atc_class()	0	3	1
A	ChemblFilterQuery.__getitem__()	0	2	1
A	ChemblFilterQuery.__iter__()	0	2	1
A	ChemblApi.__getattribute__()	0	2	1
A	ChemblApi.molecule()	0	3	1
A	ChemblApi.organism()	0	3	1
A	ChemblEntrypoint.mock()	0	28	2
A	ChemblEntrypoint.get()	0	2	1
A	ChemblApi.assay()	0	3	1
A	ChemblApi.target_prediction()	0	3	1
A	ChemblApi.mechanism()	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
from typing import Any, Callable, Iterator, Mapping, Optional, Sequence

from pocketutils.core.dot_dict import NestedDotDict

Unable to import 'pocketutils.core.dot_dict'

from mandos import logger

Unused logger 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):

Missing class docstring

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

            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",
]