mandos.entries.multi_searches

Complexity

Total Complexity

14

Size/Duplication

Total Lines	116
Duplicated Lines	0 %

Importance

Changes

0

3 Methods

Rating	Name	Duplication	Size	Complexity
A	MultiSearch.__init__()	0	17	4
A	MultiSearch.search()	0	10	2
B	MultiSearch._build_commands()	0	43	8

"""
Runner.
"""

from __future__ import annotations

import typing
from pathlib import Path
from typing import Optional, Type, Union

Unused Optional imported from typing

import typer

Unable to import 'typer'

from pocketutils.core.dot_dict import NestedDotDict

Unable to import 'pocketutils.core.dot_dict'

from mandos import MandosLogging

Unused MandosLogging imported from mandos

from mandos.entries import EntryMeta
from mandos.entries.api_singletons import Apis
from mandos.entries.entries import Entries, Entry
from mandos.model import InjectionError, ReflectionUtils

Unused ReflectionUtils imported from mandos.model

from mandos.model.settings import MANDOS_SETTINGS

cli = typer.Typer()
Apis.set_default()
Chembl, Pubchem = Apis.Chembl, Apis.Pubchem

EntriesByCmd: typing.Dict[str, Type[Entry]] = {e.cmd(): e for e in Entries}

# these are only permitted in 'meta', not individual searches
meta_keys = {"verbose", "quiet", "check", "log", "to"}


class MultiSearch:
    """
    Ugh.
    """

    # ------------------------
    # TODO: This code is nightmarishly complex.

TODO and FIXME comments should generally be avoided.

    # ------------------------

    def __init__(self, path: Path, config: str):
        self.path = path
        toml = NestedDotDict.read_toml(config)
        self.toml_searches = toml.get_as("search", list, [])
        # 'meta' allows us to set defaults
        # for now, I'm only allowing true "metadata" keys
        self.meta = toml.sub("meta")
        # TODO: allow specifying a directory, not just format (suffix)

TODO and FIXME comments should generally be avoided.

        self.format = self.meta.get_as("to", str, MANDOS_SETTINGS.default_table_suffix)
        if not self.format.startswith("."):
            raise ValueError(
                f"Value to='{self.format}' does not start with '.'. Only a filename extension is permitted."

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

            )
        for key, value in self.meta.items():
            if key not in meta_keys:
                raise ValueError(
                    f"Found {key}={value} in 'meta' of TOML. Only {', '.join(meta_keys)} are supported."

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

                )

    def search(self) -> None:

Missing function or method docstring

        cmds = self._build_commands()
        # this is terrible
        EntryMeta.set_logging(
            quiet=self.meta.get("quiet", False),
            verbose=self.meta.get("verbose", False),
            log=self.meta.get("log", None),
        )
        for key, (ent, params) in cmds.items():

The variable key seems to be unused.

            ent.run(self.path, **{**params, **dict(no_setup=True, check=False)})

    def _build_commands(
        self,

Wrong hanging indentation before block (add 4 spaces).

    ) -> typing.Dict[str, typing.Tuple[Type[Entry], typing.Mapping[str, Union[int, str, float]]]]:
        commands: typing.Dict[
            str, typing.Tuple[Type[Entry], typing.Mapping[str, Union[int, str, float]]]
        ] = {}
        # build up the lit of Entry classes first, and run ``test`` on each one
        # that's to check that the parameters are correct before running anything
        for e in self.toml_searches:

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

            e = NestedDotDict(e)

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

            cmd = e.req_as("source", str)
            key = e.get_as("key", str, cmd)
            try:
                cmd = EntriesByCmd[cmd]
            except KeyError:
                raise InjectionError(f"Search command {cmd} (key {key}) does not exist")
            # use defaults
            params = dict(self.meta)
            # they shouldn't pass any of these args
            if "path" in e:
                raise ValueError(f"Cannot set 'path' in [[search]]")

Using an f-string that does not have any interpolated variables

            for bad in {*meta_keys, "no_setup"}:
                if bad in e:
                    raise ValueError(f"Cannot set '{bad}' in [[search]]; set in meta")
            # update the defaults from 'meta' (e.g. 'verbose')
            # skip the source -- it's the command name
            # stupidly, we need to explicitly add the defaults from the OptionInfo instances
            params.update(cmd.default_param_values().items())
            # do this after: the defaults had path, key, and to
            # params["path"] = self.path
            params["key"] = key
            params["to"] = self.format
            params.update({k: v for k, v in e.items() if k != "source"})
            del params["check"]
            cmd.test(self.path, **{**params, **dict(quiet=True)})
            if key in commands:
                raise ValueError(f"Repeated search key '{key}'")
            commands[key] = (cmd, params)
        if self.meta.get("check", False):

Unnecessary "else" after "return"

            # we already ran check on all of them
            return {}
        else:
            return commands


__all__ = ["MultiSearch"]