pocketutils.misc.j

Complexity

Total Complexity

27

Size/Duplication

Total Lines	167
Duplicated Lines	0 %

Importance

Changes

0

18 Methods

Rating	Name	Duplication	Size	Complexity
A	J._color()	0	5	3
A	J.hyperlink()	0	3	1
A	JFonts.mine()	0	22	2
A	JFonts.every()	0	18	1
A	J.full()	0	5	3
A	J.blue()	0	3	1
A	J.html()	0	3	1
A	J.bold()	0	3	1
A	J.colored()	0	3	1
A	J.styled()	0	18	4
A	J.md()	0	3	1
A	J.code()	0	3	1
A	J.bold_colored()	0	3	1
A	J.confirm()	0	5	2
A	J.red()	0	3	1
A	JFonts.one()	0	6	1
A	J.full_width()	0	3	1
A	J.green()	0	3	1

from typing import Optional

Missing module docstring

import pandas as pd

Unable to import 'pandas'

import regex

Unable to import 'regex'

from IPython.display import HTML, Markdown, display

Unable to import 'IPython.display'

_color_pattern = regex.compile("#?[A-Z0-9a-z]{6}", flags=regex.V1)


# noinspection PyTypeChecker
class J:

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

    """
    Convenience user tools to display HTML text in Jupyter notebooks.
    """

    from IPython.display import clear_output, display

Import outside toplevel (IPython.display.clear_output, IPython.display.display)

The import display was already done on line 5. You should be able to
remove this line.

Unable to import 'IPython.display'

    from IPython.utils import io as __io

Import outside toplevel (IPython.utils.io)

Unable to import 'IPython.utils'

    RED, GREEN, BLUE, PURPLE, CYAN, BOLD = (
        "#cc0000",
        "#008800",
        "#0000cc",
        "#880099",
        "#007777",
        "600",
    )

    @classmethod
    def full_width(cls, percent: bool = 100):

Missing function or method docstring

        display(HTML("<style>.container { width:" + str(percent) + "% !important; }</style>"))

    @classmethod
    def full(cls, df: pd.DataFrame) -> None:

Argument name "df" 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

        with pd.option_context("display.max_rows", 10 ** 10):
            with pd.option_context("display.max_columns", 10 ** 10):
                display(df)

    @classmethod
    def confirm(cls, msg: Optional[str] = None) -> bool:

Missing function or method docstring

        # return Tools.confirm(lambda: cls.blue("Confirm? [yes/no]" if msg is None else msg))
        cls.bold_colored("Confirm? [yes/no]" if msg is None else msg, cls.BLUE)
        return cls.__io.ask_yes_no("")

    @classmethod
    def hyperlink(cls, text: str, url: str) -> None:

Missing function or method docstring

        display(HTML(f'<a href="{url}">{text}</a>'))

    @classmethod
    def red(cls, text: str) -> None:

Missing function or method docstring

        cls.colored(text, cls.RED)

    @classmethod
    def blue(cls, text: str) -> None:

Missing function or method docstring

        cls.colored(text, cls.BLUE)

    @classmethod
    def green(cls, text: str) -> None:

Missing function or method docstring

        cls.colored(text, cls.GREEN)

    @classmethod
    def bold(cls, text: str) -> None:

Missing function or method docstring

        cls.styled(text, font_weight=cls.BOLD)

    @classmethod
    def colored(cls, text: str, color: str, **kwargs) -> None:

Missing function or method docstring

        cls.styled(text, color=cls._color(color), **kwargs)

    @classmethod
    def bold_colored(cls, text: str, color: str) -> None:

Missing function or method docstring

        cls.styled(text, color=color, font_weight=cls.BOLD)

    @classmethod
    def code(cls, text: str, **kwargs) -> None:

Missing function or method docstring

        cls.styled(text, white_space="pre", font_family="monospace", **kwargs)

    @classmethod
    def md(cls, text: str) -> None:

Method name "md" 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

        display(Markdown(text))

    @classmethod
    def html(cls, text: str) -> None:

Missing function or method docstring

        display(HTML(text))

    @classmethod
    def styled(cls, text: str, *main, **css: str) -> None:
        """
        Display a span element styled with free CSS arguments.

        Args:
            text: The text to include in an HTML span
            main: Any free text of CSS, or a list of parameters
            css: Any free dict of CSS style parameters; spaces and underscores in the keys will be replaced with hypens

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

        """
        main = ";".join(main)
        css = ";".join(
            "{}: {}".format(k.replace("_", "-").replace(" ", "-"), str(v)) for k, v in css.items()
        )
        if len(main) > 0 and not main.endswith(";"):
            main += ";"
        z = (main + css) if (main + css).endswith(";") else (main + css + ";")

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

        display(HTML('<span style="{}">{}</span>'.format(z, text)))

    @classmethod
    def _color(cls, color: str) -> str:
        if _color_pattern.fullmatch(color) is None:
            raise ValueError(f"Invalid hex color {color}")
        return color if color.startswith("#") else "#" + color


class JFonts:
    """
    Renders HTML for matplotlib fonts.
    """

    @classmethod
    def one(cls, name: str) -> None:
        """
        Shows a single typeface as itself. Ex; will show Helvetica in Helvetica.
        """
        J.html(f'<p style="font-family:{name};">{name}</p>')

    @classmethod
    def mine(cls) -> None:
        """
        Shows all typefaces currently in the matplotlib rcParams.
        Each typeface is rendered as itself. Ex; will show Helvetica in Helvetica.
        Each font family (``plt.rcParams['font.family']``) is shown separately, with all its fonts underneath.

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

        """
        import matplotlib.pyplot as plt

Import outside toplevel (matplotlib.pyplot)

Unable to import 'matplotlib.pyplot'

        for family in plt.rcParams["font.family"]:
            items = "\n".join(
                [
                    f'<li style="font-family:{family};">{family}</li>'
                    for font in plt.rcParams.get("font." + family, [])
                ]
            )
            J.html(
                (
                    '<h4 style="padding-bottom:0;margin-bottom:0;">{}:</h4>\n'
                    '<ul style="padding-top:0;margin-top:0;margin-bottom:0;margin-top:0;">\n'
                    "{}\n</ul>"
                ).format(family, items)
            )

    @classmethod
    def every(cls, n_cols: int = 4) -> None:
        """
        Shows an HTML table of all typefaces rendered as themselves. Ex; will show Helvetica in Helvetica.

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

        Displays as an HTML table with `n_cols`.
        Thanks to https://jonathansoma.com/lede/data-studio/matplotlib/list-all-fonts-available-in-matplotlib-plus-samples/.

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

        Args:
            n_cols: Number of columns in the created HTML table
        """
        from matplotlib.font_manager import fontManager

Import outside toplevel (matplotlib.font_manager.fontManager)

Unable to import 'matplotlib.font_manager'

        def _show_font(name: str):
            return f"<p style='font-family:{name};'>{name}</p>"

        fonts = set([f.name for f in fontManager.ttflist])

Consider using a set comprehension

        code = "\n".join([_show_font(font) for font in sorted(fonts)])
        J.html(f'<div style="column-count: {n_cols};">{code}</div>')


__all__ = ["J", "JFonts"]