pocketutils.misc.warning_utils

Complexity

Total Complexity

10

Size/Duplication

Total Lines	87
Duplicated Lines	0 %

Importance

Changes

0

8 Methods

Rating	Name	Duplication	Size	Complexity
A	WarningsConfig.never()	0	6	2
A	WarningsConfig.filter_common()	0	8	1
A	WarningsConfig.simplify_format()	0	13	1
A	WarningsConfig.once()	0	6	2
A	WarningsConfig.filter()	0	5	1
A	WarningsConfig.common_never()	0	8	1
A	WarningsConfig.common_once()	0	4	1
A	WarningsConfig.__init__()	0	2	1

from __future__ import annotations

Missing module docstring

import warnings
from pathlib import Path
from typing import AbstractSet

from pocketutils.core.exceptions import NotConstructableError


class WarningsConfig:
    """
    Convenient API to add warning filters.
    Also provides :meth:`simplify_format`, which sets a less-verbose warning formatter.

    Example:
        >>> (
                GlobalWarningUtils.simplify_format()
                .filter_common()
                .never("Number of features differ")
            )
    """

    def __init__(self):
        raise NotConstructableError(f"Do not instantiate {self.__class__.__name__}")

    @classmethod
    def simplify_format(cls) -> __qualname__:

Undefined variable '__qualname__'

        """
        Common initialization, including setting a better formatter that doesn't say "WARNING:py.warnings:".

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

        """

        def new_formatter(message, category, filename, lineno, line=None):

The argument line seems to be unused.

            cat = category.__name__.replace("Warning", "")
            s = f"{Path(filename).name}:{lineno}: {cat}: {message}"

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

            return s.replace("WARNING:py.warnings:", "")

        warnings.formatwarning = new_formatter
        return cls

    @classmethod
    def filter(cls, **kwargs) -> __qualname__:
        """Same as warnings.filterwarnings."""
        warnings.filterwarnings(**kwargs)
        return cls

    @classmethod
    def never(cls, *substrings: str) -> __qualname__:
        """Adds a filter containing this substring, never showing the warning."""
        for substring in substrings:
            warnings.filterwarnings(message=".*?" + substring + ".*", action="ignore")
        return cls

    @classmethod
    def once(cls, *substrings: str) -> __qualname__:
        """Adds a filter containing this substring, warning only once."""
        for substring in substrings:
            warnings.filterwarnings(message=".*?" + substring + ".*", action="once")
        return cls

    @classmethod
    def filter_common(cls) -> __qualname__:
        """
        Adds filters for common unavoidable warnings from numpy, pandas, scikit-learn, etc.

        See ``common_never_substrings`` and ``common_once_substrings``.
        """
        return cls.never(*cls.common_never()).once(*cls.common_once())

    @classmethod
    def common_never(cls) -> AbstractSet[str]:

Missing function or method docstring

        return {
            "libuv only supports millisecond timer resolution",
            "or '1type' as a synonym of type is deprecated",
            "Series.nonzero() is deprecated and will be removed in a future version",
            "Monkey-patching ssl after ssl has already been imported may lead to errors",
            "your performance may suffer as PyTables will pickle object types that it cannot map directly to c-types",

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

        }

    @classmethod
    def common_once(cls) -> AbstractSet[str]:

Missing function or method docstring

        return {
            "Trying to unpickle estimator",
        }


__all__ = ["WarningsConfig"]