mandos.model

Complexity

Total Complexity

43

Size/Duplication

Total Lines	292
Duplicated Lines	0 %

Importance

Changes

0

20 Methods

Rating	Name	Duplication	Size	Complexity
A	ReflectionUtils.optional_args()	0	13	1
A	ReflectionUtils.subclass_dict()	0	3	1
A	ReflectionUtils.injection()	0	23	2
A	ReflectionUtils.subclasses()	0	10	5
A	ReflectionUtils.default_arg_values()	0	3	1
A	ReflectionUtils.required_args()	0	13	1
A	CleverEnum._unmatched_type()	0	3	1
A	ReflectionUtils._args()	0	10	1
A	ReflectionUtils.get_generic_arg()	0	24	3
A	MandosResources.path()	0	5	2
A	MandosResources.json()	0	4	1
A	MandosResources.a_path()	0	9	1
A	MiscUtils.serialize_list()	0	3	1
A	MiscUtils.empty_df()	0	10	3
A	MiscUtils.utc()	0	3	1
B	CleverEnum.of()	0	24	7
A	MiscUtils.deserialize_list()	0	3	1
A	MandosResources.contains()	0	4	1
A	MiscUtils.ntp_utc()	0	6	1
B	MiscUtils.adjust_filename()	0	16	8

from __future__ import annotations

Missing module docstring

import abc
import enum
import inspect
import sys
import typing
from datetime import datetime
from pathlib import Path
from typing import Any, Mapping, Optional, Sequence, Type, TypeVar, Union

from pocketutils.core.dot_dict import NestedDotDict

Unable to import 'pocketutils.core.dot_dict'

from pocketutils.tools.common_tools import CommonTools

Unable to import 'pocketutils.tools.common_tools'

from suretime import Suretime

Unable to import 'suretime'

from typeddfs import TypedDf

Unable to import 'typeddfs'

from mandos import logger
from mandos.model.settings import MANDOS_SETTINGS


class Api(metaclass=abc.ABCMeta):

Empty class docstring

    """ """


class CompoundNotFoundError(LookupError):

Empty class docstring

    """ """


class InjectionError(LookupError):

Empty class docstring

    """ """


class MultipleMatchesError(ValueError):

Empty class docstring

    """ """


T = TypeVar("T", covariant=True)

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

class ReflectionUtils:

Missing class docstring

    @classmethod
    def get_generic_arg(cls, clazz: Type[T], bound: Optional[Type[T]] = None) -> Type:
        """
        Finds the generic argument (specific TypeVar) of a :py:class:`~typing.Generic` class.
        **Assumes that ``clazz`` only has one type parameter. Always returns the first.**

        Args:
            clazz: The Generic class
            bound: If non-None, requires the returned type to be a subclass of ``bound`` (or equal to it)

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

        Returns:
            The class

        Raises:
            AssertionError: For most errors
        """
        bases = clazz.__orig_bases__
        try:
            param = typing.get_args(bases[0])[0]

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

        except KeyError:
            raise AssertionError(f"Failed to get generic type on {cls}")
        if not issubclass(param, bound):
            raise AssertionError(f"{param} is not a {bound}")
        return param

    @classmethod
    def subclass_dict(cls, clazz: Type[T], concrete: bool = False) -> Mapping[str, Type[T]]:

Missing function or method docstring

        return {c.__name__: c for c in cls.subclasses(clazz, concrete=concrete)}

    @classmethod
    def subclasses(cls, clazz, concrete: bool = False):

Missing function or method docstring

        for subclass in clazz.__subclasses__():
            yield from cls.subclasses(subclass, concrete=concrete)
            if (
                not concrete

Wrong hanging indentation before block (add 4 spaces).

                or not inspect.isabstract(subclass)

Wrong hanging indentation before block (add 4 spaces).

                and not subclass.__name__.startswith("_")

Wrong hanging indentation before block (add 4 spaces).

            ):
                yield subclass

    @classmethod
    def default_arg_values(cls, func) -> Mapping[str, Optional[Any]]:

Missing function or method docstring

        return {k: v.default for k, v in cls.optional_args(func).items()}

    @classmethod
    def required_args(cls, func):
        """
        Finds parameters that lack default values.

        Args:
            func: A function or method

        Returns:
            A dict mapping parameter names to instances of ``MappingProxyType``,
            just as ``inspect.signature(func).parameters`` does.
        """
        return cls._args(func, True)

    @classmethod
    def optional_args(cls, func):
        """
        Finds parameters that have default values.

        Args:
            func: A function or method

        Returns:
            A dict mapping parameter names to instances of ``MappingProxyType``,
            just as ``inspect.signature(func).parameters`` does.
        """
        return cls._args(func, False)

    @classmethod
    def _args(cls, func, req):
        signature = inspect.signature(func)
        return {
            k: v
            for k, v in signature.parameters.items()
            if req
            and v.default is inspect.Parameter.empty
            or not req
            and v.default is not inspect.Parameter.empty
        }

    @classmethod
    def injection(cls, fully_qualified: str, clazz: Type[T]) -> Type[T]:
        """
        Gets a **class** by its fully-resolved class name.

        Args:
            fully_qualified:
            clazz:

        Returns:
            The Type

        Raises:
            InjectionError: If the class was not found
        """
        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(".") :]
        try:
            return getattr(sys.modules[mod], clz)
        except AttributeError:
            raise InjectionError(
                f"Did not find {clazz} by fully-qualified class name {fully_qualified}"
            )


class CleverEnum(enum.Enum):
    """
    An enum with a ``.of`` method that finds values
    with limited string/value fixing.
    May support an "unmatched" type -- a fallback value when there is no match.
    This is similar to pocketutils' simpler ``SmartEnum``.
    It is mainly useful for enums corresponding to concepts in ChEMBL and PubChem,
    where it's acceptable for the user to input spaces (like the database concepts use)
    rather than the underscores that Python requires.
    """

    @classmethod
    def _unmatched_type(cls) -> Optional[__qualname__]:
        return None

    @classmethod
    def of(cls, s: Union[int, str, __qualname__]) -> __qualname__:

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)

        """
        Turns a string or int into this type.
        Case-insensitive. Replaces `` `` and ``-`` with ``_``.
        """
        if isinstance(s, cls):
            return s
        key = s.replace(" ", "_").replace("-", "_").lower()
        try:
            if isinstance(s, str):

Unnecessary "elif" after "return"

                return cls[key]
            elif isinstance(key, int):
                return cls(key)
            else:
                raise TypeError(f"Lookup type {type(s)} for value {s} not a str or int")
        except KeyError:
            unk = cls._unmatched_type()
            if unk is None:
                raise
            logger.error(f"Value {key} not found. Using TargetType.unknown.")
            if not isinstance(unk, cls):
                raise AssertionError(f"Wrong type {type(unk)} (lookup: {s})")
            return unk


class MandosResources:

Missing class docstring

    @classmethod
    def contains(cls, *nodes: Union[Path, str], suffix: Optional[str] = None) -> bool:
        """Returns whether a resource file (or dir) exists."""
        return cls.path(*nodes, suffix=suffix).exists()

    @classmethod
    def path(cls, *nodes: Union[Path, str], suffix: Optional[str] = None) -> Path:
        """Gets a path of a test resource file under ``resources/``."""
        path = Path(Path(__file__).parent.parent, "resources", *nodes)
        return path.with_suffix(path.suffix if suffix is None else suffix)

    @classmethod
    def a_path(cls, *nodes: Union[Path, str], suffixes: Optional[typing.Set[str]] = None) -> Path:
        """Gets a path of a test resource file under ``resources/``, ignoring suffix."""
        path = Path(Path(__file__).parent.parent, "resources", *nodes)
        return CommonTools.only(
            [
                p
                for p in path.parent.glob(path.stem + "*")
                if p.is_file() and (suffixes is None or p.suffix in suffixes)
            ]
        )

    @classmethod
    def json(cls, *nodes: Union[Path, str], suffix: Optional[str] = None) -> NestedDotDict:
        """Reads a JSON file under ``resources/``."""
        return NestedDotDict.read_json(cls.path(*nodes, suffix=suffix))


class MiscUtils:
    """
    These are here to make sure I always use the same NTP server, etc.
    """

    @classmethod
    def empty_df(cls, clazz: Type[T], reserved: bool = False) -> T:

Missing function or method docstring

        if issubclass(clazz, TypedDf):

Unnecessary "else" after "return"

            if reserved:
                req = clazz.known_names()
            else:
                req = [*clazz.required_index_names(), *clazz.required_columns]
            return clazz({r: [] for r in req})
        else:
            return clazz({})

    @classmethod
    def adjust_filename(cls, to: Optional[Path], default: Union[str, Path], replace: bool) -> Path:

Missing function or method docstring

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

        if to is None:
            path = Path(default)
        elif str(to).startswith("."):
            path = Path(default).with_suffix(str(to))
        elif to.is_dir() or to.suffix == "":
            path = to / default
        else:
            raise AssertionError(str(to))
        path = Path(path)
        if path.exists() and not replace:

Unnecessary "elif" after "raise"

            raise FileExistsError(f"File {path} already exists")
        elif replace:
            logger.info(f"Overwriting existing file {path}.")
        return path

    @classmethod
    def ntp_utc(cls) -> datetime:

Missing function or method docstring

        ntp = Suretime.tagged.now_utc_ntp(
            ntp_server=MANDOS_SETTINGS.ntp_continent, ntp_clock="client-sent"
        )
        return ntp.use_clock_as_dt.dt

    @classmethod
    def utc(cls) -> datetime:

Missing function or method docstring

        return Suretime.tagged.now_utc_sys().dt

    @classmethod
    def serialize_list(cls, lst: Sequence[str]) -> str:

Missing function or method docstring

        return " || ".join([str(x) for x in lst])

    @classmethod
    def deserialize_list(cls, s: str) -> Sequence[str]:

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

        return s.split(" || ")


START_TIME = MiscUtils.utc()
# START_TIMESTAMP = START_TIME.isoformat(timespec="milliseconds")
START_TIMESTAMP = (
    START_TIME.isoformat(timespec="milliseconds").replace(":", "").replace(".", "").replace("-", "")
)


__all__ = [
    "Api",
    "CompoundNotFoundError",
    "MandosResources",
    "CleverEnum",
    "ReflectionUtils",
    "InjectionError",
    "MiscUtils",
    "START_TIME",
    "START_TIMESTAMP",
]