mandos.entry.utils._arg_utils - Code Metrics - Inspection of "style: sorting" - dmyersturnbull/mandos - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — main ( e5b5eb...6c03a0 )

by Douglas

created 2021-11-05 23:55 UTC

mandos.entry.utils._arg_utils F

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	260
Duplicated Lines	0 %

Importance

Changes

Metric	Value
eloc	225
dl	0
loc	260
rs	2.56
c	0
b	0
f	0
wmc	73

13 Methods

Rating	Name	Size	Complexity
A	ArgUtils.get_target_types()	3	1
A	ArgUtils.get_taxonomy()	16	3
B	ArgUtils.parse_taxa()	24	6
A	ParsedTaxa.empty()	3	1
B	ArgUtils.parse_taxon()	12	8
A	ArgUtils.definition_bullets()	5	1
A	ArgUtils.parse_taxa_ids()	9	3
A	ArgUtils._get_std_taxon()	15	2
B	ArgUtils.list()	19	6
A	ArgUtils.definition_list()	4	1
F	EntryUtils.adjust_dir_name()	34	15
B	EntryUtils._check_suffix()	10	6
F	EntryUtils.adjust_filename()	37	20

How to fix Complexity

from __future__ import annotations


import os
from dataclasses import dataclass
from pathlib import Path
from typing import (
    AbstractSet,
    Any,
    Callable,
    Iterable,
    Mapping,
    Optional,
    Sequence,
    Set,
    Tuple,
    TypeVar,
    Union,
)

import decorateme

from pocketutils.core.exceptions import PathExistsError, XTypeError, XValueError

from pocketutils.misc.typer_utils import Arg, Opt

from pocketutils.tools.filesys_tools import FilesysTools

from pocketutils.tools.path_tools import PathTools

from regex import regex

from typeddfs.df_errors import FilenameSuffixError


from mandos.model.apis.chembl_support.chembl_targets import TargetType
from mandos.model.settings import SETTINGS
from mandos.model.taxonomy import KnownTaxa, Taxonomy

from mandos.model.taxonomy_caches import LazyTaxonomy, TaxonomyFactories
from mandos.model.utils.globals import Globals
from mandos.model.utils.setup import logger

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

_dir_name_pattern = regex.compile(r"([^*]*)(?:\*(\..+))?", flags=regex.V1)


@dataclass(frozen=True, repr=True, order=True)

class ParsedTaxa:
    source: str
    allow: Sequence[Union[int, str]]
    forbid: Sequence[Union[int, str]]
    ancestors: Sequence[Union[int, str]]

    @classmethod
    def empty(cls) -> ParsedTaxa:

        return ParsedTaxa("", [], [], [])


@decorateme.auto_utils()

class ArgUtils:
    @classmethod
    def definition_bullets(cls, dct: Mapping[Any, Any], colon: str = ": ", indent: int = 12) -> str:

        joiner = os.linesep * 2 + " " * indent
        jesus = [f" - {k}{colon}{v}" for k, v in dct.items()]
        return joiner.join(jesus)

    @classmethod
    def definition_list(cls, dct: Mapping[Any, Any], colon: str = ": ", sep: str = "; ") -> str:

        jesus = [f"{k}{colon}{v}" for k, v in dct.items()]
        return sep.join(jesus)

    @classmethod
    def list(

        cls,

        lst: Iterable[Any],

        *,

        attr: Union[None, str, Callable[[Any], Any]] = None,

        sep: str = ", ",

    ) -> str:
        x = []

        for v in lst:

            if attr is None and hasattr(v, "name"):
                x += [v.name]

            elif attr is None:
                x += [str(v)]

            elif isinstance(attr, str):
                x += [str(getattr(v, attr))]

            else:
                x += [str(attr(v))]

        return sep.join(x)

    @classmethod
    def get_taxonomy(

        cls,

        taxa: Optional[str],

        *,

        local_only: bool = False,

        allow_forbid: bool = True,

    ) -> Optional[LazyTaxonomy]:
        if taxa is None or len(taxa) == 0:
            return None
        parsed = cls.parse_taxa(taxa, allow_forbid=allow_forbid)
        return TaxonomyFactories.get_smart_taxonomy(
            allow=parsed.allow,
            forbid=parsed.forbid,
            ancestors=parsed.ancestors,
            local_only=local_only,
        )

    @classmethod
    def parse_taxa(

        cls,

        taxa: Optional[str],

        *,

        allow_forbid: bool = True,

    ) -> ParsedTaxa:
        if taxa is None or taxa == "":
            return ParsedTaxa.empty()
        ancestors = f"{KnownTaxa.cellular},{KnownTaxa.viral}"
        if ":" in taxa:
            ancestors = taxa.split(":", 1)[1]
            taxa = taxa.split(":", 1)[0]
        taxa_objs = [t.strip() for t in taxa.split(",") if len(t.strip()) > 0]
        allow = [t.strip().lstrip("+") for t in taxa_objs if not t.startswith("-")]
        forbid = [t.strip().lstrip("-") for t in taxa_objs if t.startswith("-")]
        ancestors = [t.strip() for t in ancestors.split(",")]
        if not allow_forbid and len(forbid) > 0:
            raise XValueError(f"Cannot use '-' in {taxa}")
        return ParsedTaxa(
            source=taxa,
            allow=[ArgUtils.parse_taxon(t, id_only=False) for t in allow],
            forbid=[ArgUtils.parse_taxon(t, id_only=False) for t in forbid],
            ancestors=[ArgUtils.parse_taxon(t, id_only=True) for t in ancestors],
        )

    @classmethod
    def parse_taxa_ids(cls, taxa: str) -> Sequence[int]:
        """
        Does not allow negatives.
        """
        if taxa is None or taxa == "":
            return []
        taxa = [t.strip() for t in taxa.split(",") if len(t.strip()) > 0]
        return [ArgUtils.parse_taxon(t, id_only=True) for t in taxa]

    @classmethod
    def parse_taxon(cls, taxon: Union[int, str], *, id_only: bool = False) -> Union[int, str]:

        std = cls._get_std_taxon(taxon)
        if isinstance(taxon, str) and taxon in std:
            return std
        if isinstance(taxon, str) and not id_only:

            return taxon
        elif isinstance(taxon, str) and taxon.isdigit():
            return int(taxon)
        if id_only:
            raise XTypeError(f"Taxon {taxon} must be an ID")
        raise XTypeError(f"Taxon {taxon} must be an ID or name")

    @classmethod
    def _get_std_taxon(cls, taxa: str) -> str:
        x = dict(

            vertebrata=KnownTaxa.vertebrata,
            vertebrate=KnownTaxa.vertebrata,
            vertebrates=KnownTaxa.vertebrata,
            cellular=KnownTaxa.cellular,
            cell=KnownTaxa.cellular,
            cells=KnownTaxa.cellular,
            viral=KnownTaxa.viral,
            virus=KnownTaxa.viral,
            viruses=KnownTaxa.viral,
            all=f"{Globals.cellular_taxon},{Globals.viral_taxon}",

        ).get(taxa)
        return taxa if x is None else str(x)

    @staticmethod
    def get_target_types(st: str) -> Set[str]:

        return {s.name for s in TargetType.resolve(st)}


@decorateme.auto_utils()

class EntryUtils:
    @classmethod
    def adjust_filename(

        cls,

        to: Optional[Path],

        default: Union[str, Path],

        replace: bool,

        *,

        suffixes: Union[None, AbstractSet[str], Callable[[Union[Path, str]], Any]] = None,

        quiet: bool = False,

    ) -> Path:
        if to is None:
            path = Path(default)
        elif str(to).startswith("."):
            path = Path(default).with_suffix(str(to))
        elif str(to).startswith("*."):
            path = Path(default).with_suffix(str(to)[1:])
        elif to.is_dir() or to.suffix == "":
            path = to / default
        else:
            path = Path(to)
        path = Path(path)
        if os.name == "nt" and SETTINGS.sanitize_paths:
            new_path = Path(*PathTools.sanitize_nodes(path.parts, is_file=True))
            if new_path.resolve() != path.resolve():
                if not quiet:
                    logger.warning(f"Sanitized filename {path} → {new_path}")
                path = new_path
        info = FilesysTools.get_info(path)
        if info.exists and not info.is_file and not info.is_socket and not info.is_char_device:
            raise PathExistsError(f"Path {path} exists and is not a file")
        if info.exists and not replace:
            raise PathExistsError(f"File {path} already exists")
        cls._check_suffix(path.suffix, suffixes)
        if info.exists and replace and not quiet:
            logger.info(f"Overwriting existing file {path}")
        logger.log("TRACE" if quiet else "INFO", f"Output file is {path}")
        return path

    @classmethod
    def adjust_dir_name(

        cls,

        to: Optional[Path],

        default: Union[str, Path],

        *,

        suffixes: Union[None, AbstractSet[str], Callable[[Union[Path, str]], Any]] = None,

        quiet: bool = False,

    ) -> Tuple[Path, str]:
        out_dir = Path(default)
        suffix = SETTINGS.table_suffix
        if to is not None:
            m: regex.Match = _dir_name_pattern.fullmatch(str(to))

            out_dir = default if m.group(1) == "" else m.group(1)
            if m.group(2) is not None and m.group(2) != "":
                suffix = m.group(2)
            if out_dir.startswith(".") and not quiet:
                logger.warning(f"Writing to {out_dir} — was it meant as a suffix instead?")
            out_dir = Path(out_dir)
        if os.name == "nt" and SETTINGS.sanitize_paths:
            new_dir = Path(*PathTools.sanitize_nodes(out_dir._parts, is_file=False))
class MyParent:
    def __init__(self):
        self._x = 1;
        self.y = 2;

class MyChild(MyParent):
    def some_method(self):
        return self._x    # Ok, since accessed from a child class

class AnotherClass:
    def some_method(self, instance_of_my_child):
        return instance_of_my_child._x   # Would be flagged as AnotherClass is not
                                         # a child class of MyParent
            if new_dir.resolve() != out_dir.resolve():
                logger.warning(f"Sanitized directory {out_dir} → {new_dir}")
                out_dir = new_dir
        info = FilesysTools.get_info(out_dir)
        if info.exists and not info.is_dir:
            raise PathExistsError(f"Path {out_dir} already exists but and is not a directory")
        cls._check_suffix(suffix, suffixes)
        if info.exists:
            n_files = len(list(out_dir.iterdir()))
            if n_files > 0 and not quiet:
                logger.debug(f"Directory {out_dir} is non-emtpy")
        logger.debug(f"Output dir is {out_dir} (suffix: {suffix})")
        return out_dir, suffix

    @classmethod
    def _check_suffix(cls, suffix, suffixes):
        if suffixes is not None and callable(suffixes):
            try:
                suffixes(suffix)  # make sure it's ok
            except FilenameSuffixError:
                raise XValueError(f"Unsupported file format {suffix}")
        elif suffixes is not None:
            if suffix not in suffixes:
                raise XValueError(f"Unsupported file format {suffix}")


__all__ = ["Arg", "ArgUtils", "EntryUtils", "Opt"]


1			from __future__ import annotations
			0 ignored issues – show introduced 2021-09-06 00:54 UTC by Report Bug Copy Issue Report Missing module docstring Loading history...
2
3			import os
4			from dataclasses import dataclass
5			from pathlib import Path
6			from typing import (
7			AbstractSet,
8			Any,
9			Callable,
10			Iterable,
11			Mapping,
12			Optional,
13			Sequence,
14			Set,
15			Tuple,
16			TypeVar,
17			Union,
18			)
19
20			import decorateme
			0 ignored issues – show introduced 2021-10-28 02:14 UTC by Report Bug Copy Issue Report Unable to import 'decorateme' Loading history...
21			from pocketutils.core.exceptions import PathExistsError, XTypeError, XValueError
			0 ignored issues – show introduced 2021-09-23 03:01 UTC by Report Bug Copy Issue Report Unable to import 'pocketutils.core.exceptions' Loading history...
22			from pocketutils.misc.typer_utils import Arg, Opt
			0 ignored issues – show introduced 2021-10-12 03:37 UTC by Report Bug Copy Issue Report Unable to import 'pocketutils.misc.typer_utils' Loading history...
23			from pocketutils.tools.filesys_tools import FilesysTools
			0 ignored issues – show introduced 2021-10-28 02:14 UTC by Report Bug Copy Issue Report Unable to import 'pocketutils.tools.filesys_tools' Loading history...
24			from pocketutils.tools.path_tools import PathTools
			0 ignored issues – show introduced 2021-03-21 02:08 UTC by Report Bug Copy Issue Report Unable to import 'pocketutils.tools.path_tools' Loading history...
25			from regex import regex
			0 ignored issues – show introduced 2021-09-29 03:10 UTC by Report Bug Copy Issue Report Unable to import 'regex' Loading history...
26			from typeddfs.df_errors import FilenameSuffixError
			0 ignored issues – show introduced 2021-09-29 03:10 UTC by Report Bug Copy Issue Report Unable to import 'typeddfs.df_errors' Loading history...
27
28			from mandos.model.apis.chembl_support.chembl_targets import TargetType
29			from mandos.model.settings import SETTINGS
30			from mandos.model.taxonomy import KnownTaxa, Taxonomy
			0 ignored issues – show Unused Code introduced 2021-11-04 01:02 UTC by Report Bug Copy Issue Report Unused Taxonomy imported from mandos.model.taxonomy Loading history...
31			from mandos.model.taxonomy_caches import LazyTaxonomy, TaxonomyFactories

dmyersturnbull / mandos

Push — main ( e5b5eb...6c03a0 )

mandos.entry.utils._arg_utils F

Complexity

Size/Duplication

Importance

13 Methods

How to fix Complexity

Complexity

Duplication Side-by-Side

Filter issues like