pocketutils.misc.notifiers_utils

Complexity

Total Complexity

15

Size/Duplication

Total Lines	75
Duplicated Lines	0 %

Importance

Changes

0

8 Methods

Rating	Name	Duplication	Size	Complexity
A	Notifier.from_dict()	0	5	1
A	Notifier.__repr__()	0	2	1
A	Notifier.__post_init__()	0	5	3
A	Notifier.__str__()	0	2	1
A	Notifier.from_json_file()	0	5	1
B	Notifier.notify()	0	11	6
A	Notifier.services()	0	3	1
A	Notifier.from_toml_file()	0	5	1

from __future__ import annotations

Missing module docstring

import logging
from collections import Mapping

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

from dataclasses import dataclass
from typing import AbstractSet, Any, Callable, Sequence, Union

from notifiers import notify

Unable to import 'notifiers'

from notifiers.core import Response, get_notifier

Unable to import 'notifiers.core'

from pocketutils.core import PathLike

The name core does not seem to exist in module pocketutils.

Cannot import 'pocketutils.core' due to syntax error 'invalid syntax (<unknown>, line 134)'

from pocketutils.core.dot_dict import NestedDotDict

The name core does not seem to exist in module pocketutils.

from pocketutils.core.exceptions import XValueError

The name core does not seem to exist in module pocketutils.

logger = logging.getLogger("pocketutils")


@dataclass(frozen=True)
class Notifier:
    """
    A simple config for notifiers from a .json or .toml file.
    """

    __config: Mapping[str, Mapping[str, Union[int, str, bool]]]
    _warn: Union[bool, Callable[[Response], Any]] = True

    @property
    def services(self) -> AbstractSet[str]:

Missing function or method docstring

        return self.__config.keys()

    @classmethod
    def from_json_file(

Missing function or method docstring

        cls, path: PathLike, *, warn: Union[bool, Callable[[Response], Any]] = True

Wrong hanging indentation before block (add 4 spaces).

    ) -> Notifier:
        return cls.from_dict(NestedDotDict.read_json(path), warn=warn)

    @classmethod
    def from_toml_file(

Missing function or method docstring

        cls, path: PathLike, *, warn: Union[bool, Callable[[Response], Any]] = True

Wrong hanging indentation before block (add 4 spaces).

    ) -> Notifier:
        return cls.from_dict(NestedDotDict.read_toml(path), warn=warn)

    @classmethod
    def from_dict(

Missing function or method docstring

        cls, dct: Sequence[Any], *, warn: Union[bool, Callable[[Response], Any]] = True

Wrong hanging indentation before block (add 4 spaces).

    ) -> Notifier:
        return Notifier({x["services"]: x["defaults"] for x in dct}, _warn=warn)

    def __post_init__(self):
        for k, v in self.__config.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)

            if "message" in v:
                raise XValueError(f"Do not include message in defaults")

Using an f-string that does not have any interpolated variables

            get_notifier(provider_name=k, strict=True)  # test

    def notify(self, message: str) -> Mapping[str, Response]:

Missing function or method docstring

        returns = {}
        for service, defaults in self.__config.items():
            r = notify(service, message=message, **defaults)

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

            returns[service] = r
            if self._warn and not r.ok and not defaults.get("raise_on_errors", False):
                if callable(self._warn):
                    self._warn(r)
                else:
                    logger.error(f"Error ({r.status}) notifying via {service}: {r.errors}")

Use lazy % formatting in logging functions

        return returns

    def __repr__(self):
        return f"{self.__class__.__name__}({', '.join(self.services)})"

    def __str__(self):
        return repr(self)


__all__ = ["Notifier"]