mandos.analysis._plot_utils

Complexity

Total Complexity

34

Size/Duplication

Total Lines	222
Duplicated Lines	0 %

Importance

Changes

0

13 Methods

Rating	Name	Duplication	Size	Complexity
A	MandosPlotStyling.context()	0	13	3
A	MandosPlotStyling.guess_data_type()	0	9	3
B	MandosPlotStyling.choose_palette()	0	22	6
A	MandosPlotStyling._are_floats_divergent()	0	4	1
A	MandosPlotStyling.get_palette()	0	8	3
A	MandosPlotStyling._to_numerical()	0	6	2
A	MandosPlotStyling.list_named_palettes()	0	6	1
A	MandosPlotStyling._to_colors()	0	8	3
A	VizResources.__init__()	0	7	1
A	MandosPlotUtils.save()	0	5	1
A	VizResources._get_named_cmaps()	0	14	3
A	MandosPlotStyling._to_inch()	0	12	4
A	MandosPlotStyling.fig_width_and_height()	0	16	3

"""

Empty module docstring

"""
from __future__ import annotations

import enum
from pathlib import Path
from typing import Union, Optional, Tuple, Mapping, Any, Generator, Sequence, Set

import numpy as np

Unable to import 'numpy'

import pandas as pd

Unable to import 'pandas'

from matplotlib import pyplot as plt

Unable to import 'matplotlib'

from matplotlib.colors import LinearSegmentedColormap, Colormap, ListedColormap, to_hex

Unable to import 'matplotlib.colors'

from matplotlib.figure import Figure

Unable to import 'matplotlib.figure'

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'

# noinspection PyProtectedMember
from seaborn.palettes import SEABORN_PALETTES

Unable to import 'seaborn.palettes'

from typeddfs import TypedDfs

Unable to import 'typeddfs'

from mandos.model.utils.setup import logger

Unused logger imported from mandos.model.utils.setup

from mandos.model.utils import CleverEnum
from mandos.model.utils.misc_utils import MiscUtils
from mandos.model.utils.resources import MandosResources

try:
    import seaborn as sns
    from matplotlib.axes import Axes

Imports from package matplotlib are not grouped

    from matplotlib.figure import Figure

The import Figure was already done on line 14. You should be able to
remove this line.

except ImportError:
    sns = None
    Axes = None
    Figure = None


class DataType(CleverEnum):

Missing class docstring

    qualitative = enum.auto()
    sequential = enum.auto()
    divergent = enum.auto()


class VizResources:

Missing class docstring

    def __init__(self):
        self.override_settings = MandosResources.json_dict("viz", "style_override.json")
        self.dims = MandosResources.json_dict("viz", "page_dims.json")
        palettes = MandosResources.json_dict("viz", "palettes.json")
        self.named_palettes = palettes["named"]
        self.default_palettes = palettes["defaults"]
        self.named_cmaps = self._get_named_cmaps()

    def _get_named_cmaps(self) -> Mapping[str, Colormap]:
        cmaps = {}
        for name, cmap in self.named_palettes.items():
            cmap = NestedDotDict(cmap)
            seq = cmap.req_list_as("sequence", str)
            seq = [to_hex(c) for c in seq]
            cat = cmap.req_as("categorical", bool)
            if cat:
                cmaps[name] = ListedColormap(seq)
            else:
                nan, under, over = cmap.get("nan"), cmap.get("under"), cmap.get("over")
                cmap = LinearSegmentedColormap.from_list(name, seq)
                cmap.set_extremes(bad=nan, under=under, over=over)
        return cmaps


VIZ_RESOURCES = VizResources()


class MandosPlotStyling:

Missing class docstring

    @classmethod
    def list_named_palettes(cls) -> Set[str]:

Missing function or method docstring

        return {
            *VIZ_RESOURCES.named_palettes.keys(),
            *SEABORN_PALETTES,
            *plt.colormaps(),
        }

    @classmethod
    def choose_palette(

Missing function or method docstring

        cls,

Wrong hanging indentation before block (add 4 spaces).

        data: pd.DataFrame,

Wrong hanging indentation before block (add 4 spaces).

        col: Optional[str],

Wrong hanging indentation before block (add 4 spaces).

        palette: Optional[str],

Wrong hanging indentation before block (add 4 spaces).

    ) -> Union[None, Colormap, Mapping[str, str]]:
        if col is None:
            return None
        unique = data[col].unique()
        dtype = cls.guess_data_type(data)
        if palette is None:
            palette = cls.get_palette(None, dtype)
        if dtype is DataType.qualitative:
            if not isinstance(palette, ListedColormap):
                raise TypeError(f"{palette} is not a valid choice for {dtype}")
            if len(unique) > len(palette.colors):
                raise ValueError(
                    f"Palette (N={len(palette.colors)}) too small for {len(unique)} items"
                )
            return {i: j for i, j in CommonTools.zip_strict(unique, map(to_hex, palette.colors))}

Unnecessary use of a comprehension

        return palette

    @classmethod
    def get_palette(cls, name: Optional[str], data_type: Union[DataType, str]) -> Colormap:

Missing function or method docstring

        data_type = DataType.of(data_type)
        if name is None:
            name = VIZ_RESOURCES.default_palettes[data_type.name]
        if name in VIZ_RESOURCES.named_cmaps:
            return VIZ_RESOURCES.named_cmaps[name]
        return sns.color_palette(name, as_cmap=True)

    @classmethod
    def guess_data_type(cls, data: Sequence[Union[str, float]]) -> DataType:

Missing function or method docstring

        numerical = cls._to_numerical(data)
        if numerical is None:
            return DataType.qualitative
        is_divergent = cls._are_floats_divergent(data)
        if is_divergent:
            return DataType.divergent
        return DataType.sequential

    @classmethod
    def _to_colors(cls, data: Sequence[Union[float, str]]) -> Optional[Sequence[str]]:
        if not all((isinstance(d, str)) for d in data):
            return None
        try:
            return [to_hex(c) for c in data]
        except ValueError:
            return None

    @classmethod
    def _to_numerical(cls, data: Sequence[Union[str, float]]) -> Optional[Sequence[float]]:

Either all return statements in a function should return an expression, or none of them should.

        try:
            [float(d) for d in data]
        except ValueError:
            return None

    @classmethod
    def _are_floats_divergent(cls, data: Sequence[float]):
        signs = {np.sign(d) for d in data if d != 0 and not np.isnan(d) and not np.isinf(d)}
        return len(signs) == 2

    @classmethod
    def context(
        cls, style: Union[None, str, Path], kwargs: Optional[Mapping[str, Any]]

Wrong hanging indentation before block (add 4 spaces).

    ) -> Generator[None, None, None]:
        """
        Override these from the default style.
        This will be called once, at startup.
        """
        new_kwargs = dict(VIZ_RESOURCES.override_settings["allow_change"])
        if kwargs is not None:
            new_kwargs.update(kwargs)
        with plt.rc_context(new_kwargs, style):
            yield

    @classmethod
    def fig_width_and_height(cls, size: str) -> Tuple[float, float]:

Missing function or method docstring

        if size is None:
            return plt.rcParams["figure.figsize"]
        axis_to_str = {
            i: d.strip() for i, d in enumerate(size.replace(" × ", " by ").split(" by "))
        }
        try:
            default_inch = plt.rcParams["figure.figsize"]
            width = cls._to_inch(axis_to_str.get(0), VIZ_RESOURCES.dims["widths"], default_inch[0])
            height = cls._to_inch(
                axis_to_str.get(1), VIZ_RESOURCES.dims["heights"], default_inch[1]
            )
        except ValueError:
            raise ValueError(f"Strange --size format in '{size}'")
        return width, height

    @classmethod
    def _to_inch(

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)

        cls, s: Optional[str], standards: Mapping[str, float], default_inch: float

Wrong hanging indentation before block (add 4 spaces).

    ) -> float:
        if s is None or len(s) == "":
            return default_inch
        try:
            return float(s)
        except ValueError:
            pass
        x = standards.get(s, s)

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)

        return MiscUtils.canonicalize_quantity(x, "[length]").to("inch").magnitude


class MandosPlotUtils:

Missing class docstring

    @classmethod
    def save(cls, figure: Figure, path: Path) -> None:

Missing function or method docstring

        path.parent.mkdir(parents=True, exist_ok=True)
        figure.savefig(str(path))
        figure.clear()


CompoundStyleDf = (
    TypedDfs.typed("CompoundStyleDf").require("inchikey", dtype=str).strict(cols=False).secure()
).build()

PredicateObjectStyleDf = (
    TypedDfs.typed("PredicateObjectStyleDf")
    .require("predicate", "object", dtype=str)
    .strict(cols=False)
    .secure()
).build()

PhiPsiStyleDf = (
    TypedDfs.typed("PhiPsiStyleDf").require("phi", "psi", dtype=str).strict(cols=False).secure()
).build()


__all__ = [
    "sns",
    "plt",
    "Figure",
    "Axes",
    "MandosPlotStyling",
    "MandosPlotUtils",
    "CompoundStyleDf",
    "PredicateObjectStyleDf",
    "VIZ_RESOURCES",
]