mandos.model.settings

Complexity

Total Complexity

23

Size/Duplication

Total Lines	222
Duplicated Lines	0 %

Importance

Changes

0

16 Methods

Rating	Name	Duplication	Size	Complexity
A	Settings.load()	0	37	2
A	Settings.pubchem_cache_path()	0	3	1
A	Settings.chembl_cache_path()	0	3	1
A	Settings.set_path_for_selenium()	0	4	1
A	Settings.all_cache_paths()	0	8	1
A	Settings.empty()	0	3	1
A	Settings.from_file()	0	3	1
A	Settings.chembl_scrape_path()	0	3	1
A	Settings.g2p_cache_path()	0	3	1
A	Settings.hmdb_cache_path()	0	3	1
A	Settings.defaults()	0	3	1
A	Settings.driver_path()	0	3	1
B	Settings.add_to_path()	0	10	6
A	Settings.taxonomy_cache_path()	0	3	1
A	Settings.configure()	0	11	2
A	Settings.__post_init__()	0	2	1

from __future__ import annotations

Missing module docstring

import os
from collections import Set

The name Set does not seem to exist in module collections.

from dataclasses import dataclass
from pathlib import Path
from typing import Type, TypeVar, Any, Mapping, Optional, Collection, Union

import orjson

Unable to import 'orjson'

from chembl_webresource_client.settings import Settings as ChemblSettings

Unable to import 'chembl_webresource_client.settings'

from mandos.model.utils.resources import MandosResources
from pocketutils.core.dot_dict import NestedDotDict

Unable to import 'pocketutils.core.dot_dict'

from pocketutils.core.query_utils import QueryExecutor

Unable to import 'pocketutils.core.query_utils'

from pocketutils.core.exceptions import DirDoesNotExistError, FileDoesNotExistError, ConfigError

Unable to import 'pocketutils.core.exceptions'

Unused FileDoesNotExistError imported from pocketutils.core.exceptions

from pocketutils.tools.common_tools import CommonTools

Unable to import 'pocketutils.tools.common_tools'

from suretime import Suretime

Unable to import 'suretime'

from mandos.model.utils.setup import logger

Imports from package mandos are not grouped

defaults: Mapping[str, Any] = orjson.loads(
    MandosResources.path("default_settings.json").read_text(encoding="utf8")
)
T = TypeVar("T")

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

class Globals:

Missing class docstring

    chembl_settings = ChemblSettings.Instance()
    cwd = os.getcwd()
    where_am_i_installed = Path(__file__).parent.parent.parent
    is_in_ci = CommonTools.parse_bool(os.environ.get("IS_IN_CI", "false"))
    if is_in_ci:
        mandos_path = Path(__file__).parent.parent.parent / "tests" / "resources" / ".mandos-cache"
    else:
        _default_mandos_home = Path.home() / ".mandos"
        env_vars = {k.lower(): v for k, v in os.environ.items()}
        mandos_path = Path(env_vars.get("MANDOS_HOME", _default_mandos_home))
    settings_path = mandos_path / "settings.toml"
    disable_chembl = CommonTools.parse_bool(os.environ.get("MANDOS_NO_CHEMBL", "false"))
    disable_pubchem = CommonTools.parse_bool(os.environ.get("MANDOS_NO_PUBCHEM", "false"))


@dataclass(frozen=True, repr=True)

Empty class docstring

Too many instance attributes (27/7)

class Settings:
    """ """

    is_testing: bool
    ntp_continent: str
    cache_path: Path
    cache_gzip: bool
    chembl_expire_sec: int
    chembl_n_tries: int
    chembl_timeout_sec: int
    chembl_backoff_factor: float
    chembl_query_delay_min: float
    chembl_query_delay_max: float
    chembl_fast_save: bool
    pubchem_expire_sec: int
    pubchem_n_tries: int
    pubchem_timeout_sec: float
    pubchem_backoff_factor: float
    pubchem_query_delay_min: float
    pubchem_query_delay_max: float
    hmdb_expire_sec: int
    hmdb_timeout_sec: float
    hmdb_backoff_factor: float
    hmdb_query_delay_min: float
    hmdb_query_delay_max: float
    taxon_expire_sec: int
    archive_filename_suffix: str
    default_table_suffix: str
    selenium_driver: str
    selenium_driver_path: Optional[Path]

    def __post_init__(self):
        pass

    @property
    def all_cache_paths(self) -> Set[Path]:

Missing function or method docstring

        return {
            self.chembl_cache_path,
            self.pubchem_cache_path,
            self.g2p_cache_path,
            self.hmdb_cache_path,
            self.taxonomy_cache_path,
        }

    @property
    def driver_path(self) -> Path:

Missing function or method docstring

        return self.cache_path / "driver"

    @property
    def chembl_cache_path(self) -> Path:

Missing function or method docstring

        return self.cache_path / "chembl"

    @property
    def chembl_scrape_path(self) -> Path:

Missing function or method docstring

        return self.chembl_cache_path / "scrape"

    @property
    def pubchem_cache_path(self) -> Path:

Missing function or method docstring

        return self.cache_path / "pubchem"

    @property
    def g2p_cache_path(self) -> Path:

Missing function or method docstring

        return self.cache_path / "g2p"

    @property
    def hmdb_cache_path(self) -> Path:

Missing function or method docstring

        return self.cache_path / "hmdb"

    @property
    def taxonomy_cache_path(self) -> Path:

Missing function or method docstring

        return self.cache_path / "taxonomy"

    @classmethod
    def from_file(cls, path: Path) -> Settings:

Missing function or method docstring

        return cls.load(NestedDotDict.read_toml(path))

    @classmethod
    def empty(cls) -> Settings:

Missing function or method docstring

        return cls.load(NestedDotDict({}))

    @classmethod
    def load(cls, data: NestedDotDict) -> Settings:

Missing function or method docstring

        def get(s: str, t: Type[T]) -> T:

Argument name "t" 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)

            try:
                return data.get_as(s, t, defaults[s])
            except TypeError:
                raise ConfigError(f"Key {s}={data.get(s), defaults[s]} is not of type {t}")

        _continent = Suretime.Types.NtpContinents.of
        return cls(
            is_testing=get("is_testing", bool),
            ntp_continent=get("continent_code", _continent),
            cache_path=Path(get("cache.path", str)).expanduser(),
            cache_gzip=get("cache.gzip", bool),
            chembl_expire_sec=get("query.chembl.expire_sec", int),
            chembl_n_tries=get("query.chembl.n_tries", int),
            chembl_fast_save=get("query.chembl.fast_save", bool),
            chembl_timeout_sec=get("query.chembl.timeout_sec", int),
            chembl_backoff_factor=get("query.chembl.backoff_factor", float),
            chembl_query_delay_min=get("query.chembl.delay_sec", float),
            chembl_query_delay_max=get("query.chembl.delay_sec", float),
            pubchem_expire_sec=get("query.pubchem.expire_sec", int),
            pubchem_timeout_sec=get("query.pubchem.timeout_sec", int),
            pubchem_backoff_factor=get("query.pubchem.backoff_factor", float),
            pubchem_query_delay_min=get("query.pubchem.delay_sec", float),
            pubchem_query_delay_max=get("query.pubchem.delay_sec", float),
            pubchem_n_tries=get("query.pubchem.n_tries", int),
            hmdb_expire_sec=get("query.hmdb.expire_sec", int),
            hmdb_timeout_sec=get("query.hmdb.timeout_sec", int),
            hmdb_backoff_factor=get("query.hmdb.backoff_factor", float),
            hmdb_query_delay_min=get("query.hmdb.delay_sec", float),
            hmdb_query_delay_max=get("query.hmdb.delay_sec", float),
            taxon_expire_sec=get("query.taxa.expire_sec", int),
            archive_filename_suffix=get("cache.archive_filename_suffix", str),
            default_table_suffix=get("default_table_suffix", str),
            selenium_driver=get("selenium_driver", str).title(),
            selenium_driver_path=get("selenium_driver_path", Path),
        )

    @classmethod
    def defaults(cls) -> Mapping[str, Any]:

Missing function or method docstring

        return dict(defaults)

    def configure(self):

Empty method docstring

        """ """
        if not Globals.disable_chembl:
            instance = Globals.chembl_settings
            instance.CACHING = True
            instance.CACHE_NAME = str(self.chembl_cache_path / "chembl.sqlite")
            instance.TOTAL_RETRIES = self.chembl_n_tries
            instance.FAST_SAVE = self.chembl_fast_save
            instance.TIMEOUT = self.chembl_timeout_sec
            instance.BACKOFF_FACTOR = self.chembl_backoff_factor
            instance.CACHE_EXPIRE = self.chembl_expire_sec

    @classmethod
    def set_path_for_selenium(cls) -> None:

Missing function or method docstring

        cls.add_to_path(
            [MANDOS_SETTINGS.driver_path, MandosResources.dir(), Globals.where_am_i_installed]
        )

    @classmethod
    def add_to_path(cls, paths: Collection[Union[None, str, Path]]) -> None:

Missing function or method docstring

        paths = {Path(p) for p in paths if p is not None}
        for path in paths:
            if path.exists() and not path.is_dir() and not path.is_mount():
                raise DirDoesNotExistError(f"Path {path} is not a directory or mount")
        paths = os.pathsep.join({str(p) for p in paths})
        if len(paths) > 0:
            os.environ["PATH"] += os.pathsep + paths
        logger.debug(f"Added to PATH: {paths}")


if Globals.settings_path.exists():
    MANDOS_SETTINGS = Settings.from_file(Globals.settings_path)
    logger.info(f"Read settings at {Globals.settings_path}")
else:
    MANDOS_SETTINGS = Settings.empty()
    logger.info(f"Using defaults (no file at {Globals.settings_path})")
MANDOS_SETTINGS.configure()
logger.debug(f"Setting ChEMBL cache to {MANDOS_SETTINGS.chembl_cache_path}")


class QueryExecutors:

Missing class docstring

    chembl = QueryExecutor(
        MANDOS_SETTINGS.chembl_query_delay_min, MANDOS_SETTINGS.chembl_query_delay_max
    )
    pubchem = QueryExecutor(
        MANDOS_SETTINGS.pubchem_query_delay_min, MANDOS_SETTINGS.pubchem_query_delay_max
    )
    hmdb = QueryExecutor(
        MANDOS_SETTINGS.pubchem_query_delay_min, MANDOS_SETTINGS.pubchem_query_delay_max
    )


QUERY_EXECUTORS = QueryExecutors

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

__all__ = ["MANDOS_SETTINGS", "QUERY_EXECUTORS"]