pocketutils.misc.magic_template

Complexity

Total Complexity

32

Size/Duplication

Total Lines	108
Duplicated Lines	0 %

Importance

Changes

0

10 Methods

Rating	Name	Duplication	Size	Complexity
A	MagicTemplate.add()	0	3	1
A	MagicTemplate.register_magic()	0	6	2
A	MagicTemplate.__init__()	0	4	1
D	MagicTemplate.add_datetime()	0	29	13
A	MagicTemplate.parse()	0	2	1
A	MagicTemplate.add_version()	0	10	3
A	MagicTemplate._fill()	0	7	2
A	MagicTemplate.__replace()	0	13	5
A	MagicTemplate.from_text()	0	3	2
A	MagicTemplate.from_path()	0	4	2

from __future__ import annotations

Missing module docstring

import logging
from datetime import datetime
from pathlib import Path
from typing import Any, Callable, Optional, Union

from pocketutils.core import LazyWrap, PathLike

logger = logging.getLogger("pocketutils")


class MagicTemplate:

Missing class docstring

    @classmethod
    def from_path(cls, path: PathLike, *, prefix: str = "${{", suffix: str = "}}") -> __qualname__:

Undefined variable '__qualname__'

Missing function or method docstring

        return MagicTemplate(
            reader=lambda: Path(path).read_text(encoding="utf8"), prefix=prefix, suffix=suffix
        )

    @classmethod
    def from_text(cls, text: str, *, prefix: str = "${{", suffix: str = "}}") -> __qualname__:

Missing function or method docstring

        return MagicTemplate(reader=lambda: text, prefix=prefix, suffix=suffix)

    def __init__(self, *, reader: Callable[[], str], prefix: str = "${{", suffix: str = "}}"):
        self._reader = reader
        self._entries = {}
        self._prefix, self._suffix = prefix, suffix

    def add(self, key: str, value: Union[Any, Callable[[str], str]]) -> __qualname__:

Missing function or method docstring

        self._entries[key] = value
        return self

    def add_version(self, semantic_version: str) -> __qualname__:

Missing function or method docstring

        self._entries.update(
            {
                "version": semantic_version,
                "major": semantic_version.split(".")[0],
                "minor": semantic_version.split(".")[1] if semantic_version.count(".") > 0 else "-",
                "patch": semantic_version.split(".")[2] if semantic_version.count(".") > 1 else "-",
            }
        )
        return self

    def add_datetime(self, at: Optional[datetime] = None) -> __qualname__:

Missing function or method docstring

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

        if at is None:
            now = LazyWrap.new_type("datetime", datetime.now)()
        else:
            now = LazyWrap.new_type("datetime", lambda: at)()
        self._entries.update(
            {
                "year": lambda _: str(now.get().year),
                "month": lambda _: str(now.get().month),
                "day": lambda _: str(now.get().day),
                "hour": lambda _: str(now.get().hour),
                "minute": lambda _: str(now.get().minute),
                "second": lambda _: str(now.get().second),
                "datestr": lambda _: str(now.get().date()),
                "timestr": lambda _: str(now.get().time()),
                "datetuple": lambda _: str((now.get().year, now.get().month, now.get().day)),
                "datetime": lambda _: str(
                    (
                        now.get().year,
                        now.get().month,
                        now.get().day,
                        now.get().hour,
                        now.get().minute,
                        now.get().second,
                    )
                ),
            }
        )
        return self

    def register_magic(self, name: str, shell=None) -> None:

Missing function or method docstring

        if shell is None:
            from IPython import get_ipython

Unable to import 'IPython'

Import outside toplevel (IPython.get_ipython)

            shell = get_ipython()
        shell.register_magic_function(self._fill, magic_kind="line_cell", magic_name=name)

    def parse(self, line: str = "") -> str:

Missing function or method docstring

        return self.__replace(self._reader(), line)

    def _fill(self, line, shell=None):
        if shell is None:
            from IPython import get_ipython

Unable to import 'IPython'

Import outside toplevel (IPython.get_ipython)

            shell = get_ipython()
        text = self.__replace(self._reader(), line)
        shell.set_next_input(text, replace=True)

    def __replace(self, r: str, line: str):

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

        for k, v in self._entries.items():

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

            k = self._prefix + k + self._suffix
            if k in r:
                try:
                    if callable(v):
                        r = r.replace(k, v(line))
                    else:
                        r = r.replace(k, str(v))
                except Exception:
                    logger.error(f"Failed replacing {k}")

Use lazy % formatting in logging functions

                    raise
        return r


__all__ = ["MagicTemplate"]