mandos.model.searches

Complexity

Total Complexity

10

Size/Duplication

Total Lines	97
Duplicated Lines	0 %

Importance

Changes

0

5 Methods

Rating	Name	Duplication	Size	Complexity
A	Search.get_h()	0	10	1
B	Search.find_all()	0	25	6
A	Search.find()	0	14	1
A	Search.search_name()	0	3	1
A	Search.hit_fields()	0	18	1

import abc

Missing module docstring

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

from mandos.model.hits import AbstractHit
from mandos.model import CompoundNotFoundError

logger = logging.getLogger("mandos")

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

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

class Search(Generic[H], metaclass=abc.ABCMeta):
    """
    Something to search and how to do it.
    """

    @property
    def search_name(self) -> str:

Missing function or method docstring

        return self.__class__.__name__.lower().replace("search", "")

    def find_all(self, inchikeys: Sequence[str]) -> Sequence[H]:
        """
        Loops over every compound and calls ``find``.
        Just comes with better logging.

        Args:
            inchikeys:

        Returns:

        """
        lst = []
        for i, compound in enumerate(inchikeys):
            try:
                x = self.find(compound)

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)

            except CompoundNotFoundError:
                logger.error(f"Failed to find compound {compound}. Skipping.")

Use lazy % formatting in logging functions

                continue
            lst.extend(x)
            logger.debug(f"Found {len(x)} {self.search_name} annotations for {compound}")

Use lazy % formatting in logging functions

            if i > 0 and i % 20 == 0 or i == len(inchikeys) - 1:
                logger.info(

Use lazy % formatting in logging functions

                    f"Found {len(lst)} {self.search_name} annotations for {i} of {len(inchikeys)} compounds"

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

                )
        return lst

    def find(self, inchikey: str) -> Sequence[H]:
        """
        To override.

        Args:
            inchikey:

        Returns:
            Something

        Raises:
            CompoundNotFoundError
        """
        raise NotImplementedError()

    @classmethod
    def hit_fields(cls) -> Sequence[str]:
        """
        Gets the fields in the Hit type parameter.

        Returns:

        """
        # Okay, there's a lot of magic going on here
        # We need to access the _parameter_ H on cls -- raw `H` doesn't work
        # get_args and __orig_bases__ do this for us
        # then dataclasses.fields gives us the dataclass fields
        # there's also actual_h.__annotations__, but that doesn't include ClassVar and InitVar
        # (not that we're using those)
        # If this magic is too magical, we can make this an abstract method
        # But that would be a lot of excess code and it might be less modular
        actual_h = typing.get_args(cls.get_h())[0]

The Module typing does not seem to have a member named get_args.

        return [f.name for f in dataclasses.fields(actual_h)]

    @classmethod
    def get_h(cls):
        """
        What is my hit type?

        Returns:

        """
        # noinspection PyUnresolvedReferences
        return cls.__orig_bases__[0]

The Class Search does not seem to have a member named __orig_bases__.

__all__ = ["Search"]