pocketutils.tools.common_tools

Complexity

Total Complexity

45

Size/Duplication

Total Lines	315
Duplicated Lines	0 %

Importance

Changes

0

18 Methods

Rating	Name	Duplication	Size	Complexity
A	CommonTools.limit()	0	4	2
A	CommonTools.iter_rowcol()	0	12	2
A	CommonTools.or_raise()	0	17	5
A	CommonTools.unique()	0	13	1
A	CommonTools.devnull()	0	10	1
A	CommonTools.is_probable_null()	0	20	1
A	CommonTools.first()	0	23	3
A	CommonTools.is_float()	0	10	2
A	CommonTools.is_null()	0	14	3
A	CommonTools.or_null()	0	6	3
A	CommonTools.succeeds()	0	4	1
A	CommonTools.is_empty()	0	26	4
A	CommonTools.parse_bool_flex()	0	20	2
A	CommonTools.parse_bool()	0	15	4
A	CommonTools.try_none()	0	20	2
A	CommonTools.mem_size()	0	12	1
A	CommonTools.iterator_has_elements()	0	11	2
B	CommonTools.multidict()	0	25	6

import sys

Missing module docstring

from collections import defaultdict
from typing import (
    Any,
    Callable,
    Generator,
    Iterable,
    Iterator,
    Mapping,
    Optional,
    Sequence,
    Tuple,
    Type,
    TypeVar,
    Union,
)

import pandas as pd

Unable to import 'pandas'

from pocketutils.core._internal import nicesize

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

from pocketutils.core.exceptions import RefusingRequestError, XKeyError, XValueError

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

from pocketutils.core.input_output import DevNull

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

from pocketutils.tools.base_tools import BaseTools

Y = TypeVar("Y")

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

T = TypeVar("T")

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

Z = TypeVar("Z")

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

Q = TypeVar("Q")

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

class CommonTools(BaseTools):

Missing class docstring

    @classmethod
    def limit(cls, items: Iterable[Q], n: int) -> Generator[Q, None, None]:

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

        for i, x in zip(range(n), items):

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)

The variable i seems to be unused.

            yield x

    @classmethod
    def is_float(cls, s: Any) -> bool:

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)

        """
        Returns whether ``float(s)`` succeeds.
        """
        try:
            float(s)
            return True
        except ValueError:
            return False

    @classmethod
    def try_none(
        cls,

Wrong hanging indentation before block (add 4 spaces).

        function: Callable[[], T],

Wrong hanging indentation before block (add 4 spaces).

        fail_val: Optional[T] = None,

Wrong hanging indentation before block (add 4 spaces).

        exception=Exception,

Wrong hanging indentation before block (add 4 spaces).

    ) -> Optional[T]:
        """
        Returns the value of a function or None if it raised an exception.

        Args:
            function: Try calling this function
            fail_val: Return this value
            exception: Restrict caught exceptions to subclasses of this type
        """
        # noinspection PyBroadException
        try:
            return function()
        except exception:

Catching very general exceptions such as Exception is usually not recommended.

            return fail_val

    @classmethod
    def succeeds(cls, function: Callable[[], Any], exception=Exception) -> bool:
        """Returns True iff ``function`` does not raise an error."""
        return cls.try_none(function, exception=exception) is not None

    @classmethod
    def or_null(cls, x: Any, dtype=lambda s: s, or_else: Any = None) -> Optional[Any]:

The variable s does not seem to be defined.

Argument 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 ``None`` if the operation ``dtype`` on ``x`` failed; returns the result otherwise.
        """
        return or_else if cls.is_null(x) else dtype(x)

    @classmethod
    def or_raise(

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

        cls,

Wrong hanging indentation before block (add 4 spaces).

        x: Any,

Wrong hanging indentation before block (add 4 spaces).

        dtype=lambda s: s,

The variable s does not seem to be defined.

Wrong hanging indentation before block (add 4 spaces).

        or_else: Union[None, BaseException, Type[BaseException]] = None,

Wrong hanging indentation before block (add 4 spaces).

    ) -> Any:
        """
        Returns ``dtype(x)`` if ``x`` is not None, or raises ``or_else``.
        """
        if or_else is None:
            or_else = LookupError(f"Value is {x}")
        elif isinstance(or_else, type):
            or_else = or_else(f"Value is {x}")
        if cls.is_null(x):
            raise or_else
        return dtype(x)

    @classmethod
    def iterator_has_elements(cls, x: Iterator[Any]) -> bool:

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

        """
        Returns False iff ``next(x)`` raises a ``StopIteration``.
        WARNING: Tries to call ``next(x)``, progressing iterators. Don't use ``x`` after calling this.

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

        Note that calling ``iterator_has_elements([5])`` will raise a `TypeError`

        Args:
            x: Must be an Iterator
        """
        return cls.succeeds(lambda: next(x), StopIteration)

    @classmethod
    def is_null(cls, x: Any) -> bool:

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

        """
        Returns True if:
            - x is ``None``
            - x is ``float('NaN')``
            - ``pd.isna(x)``
        """
        try:
            if pd.isna(x):
                return True
        except (ValueError, TypeError):
            pass
        return x is None or x == float("NaN")

    @classmethod
    def is_empty(cls, x: Any) -> bool:

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

        """
        Returns True iff either:
            - x is None
            - pd.is_na(x)
            - x is something with 0 length
            - x is iterable and has 0 elements (will call ``__iter__``)

        Raises:
            RefusingRequestError If ``x`` is an Iterator. Calling this would empty the iterator, which is dangerous.

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

        """
        if isinstance(x, Iterator):

Second argument of isinstance is not a type

            raise RefusingRequestError("Do not call is_empty on an iterator.")
        try:
            if pd.isna(x):
                return True
        except (ValueError, TypeError):
            pass
        return (
            x is None
            or x == float("NaN")
            or hasattr(x, "__len__")
            and len(x) == 0
            or hasattr(x, "__iter__")
            and len(list(iter(x))) == 0
        )

    @classmethod
    def is_probable_null(cls, x: Any) -> bool:

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

        """
        Returns True iff either:
            - x is None
            - pd.isna(x)
            - x is something with 0 length
            - x is iterable and has 0 elements (will call ``__iter__``)
            - a str(x) is 'nan', 'n/a', 'null', or 'none'; case-insensitive

        Things that are **NOT** probable nulls:
            - "na"
            - 0
            - [None]

        Raises:
            TypeError If ``x`` is an Iterator.
                      Calling this would empty the iterator, which is dangerous.
        """
        return cls.is_empty(x) or str(x).lower() in ["nan", "n/a", "null", "none"]

    @classmethod
    def unique(cls, sequence: Iterable[T]) -> Sequence[T]:
        """
        Returns the unique items in `sequence`, in the order they appear in the iteration.

        Args:
            sequence: Any once-iterable sequence

        Returns:
            An ordered List of unique elements
        """
        seen = set()
        return [x for x in sequence if not (x in seen or seen.add(x))]

    @classmethod
    def first(cls, collection: Iterable[Any], attr: Optional[str] = None) -> Optional[Any]:
        """
        Gets the first element.

        WARNING: Tries to call ``next(x)``, progressing iterators.

        Args:
            collection: Any iterable
            attr: The name of the attribute that might be defined on the elements,
                or None to indicate the elements themselves should be used

        Returns:
            - The attribute of the first element if ``attr`` is defined on an element
            - None if the the sequence is empty
            - None if the sequence has no attribute ``attr``
        """
        try:
            # note: calling iter on an iterator creates a view only
            x = next(iter(collection))

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 x if attr is None else cls.look(x, attr)
        except StopIteration:
            return None

    @classmethod
    def iter_rowcol(cls, n_rows: int, n_cols: int) -> Generator[Tuple[int, int], None, None]:
        """
        An iterator over (row column) pairs for a row-first grid traversal.

        Example:
            .. code-block::
                it = CommonTools.iter_rowcol(5, 3)
                [next(it) for _ in range(5)]  # [(0,0),(0,1),(0,2),(1,0),(1,1)]
        """
        for i in range(n_rows * n_cols):
            yield i // n_cols, i % n_cols

    @classmethod
    def multidict(
        cls,

Wrong hanging indentation before block (add 4 spaces).

        sequence: Iterable[Z],

Wrong hanging indentation before block (add 4 spaces).

        key_attr: Union[str, Iterable[str], Callable[[Y], Z]],

Wrong hanging indentation before block (add 4 spaces).

        skip_none: bool = False,

Wrong hanging indentation before block (add 4 spaces).

    ) -> Mapping[Y, Sequence[Z]]:
        """
        Builds a mapping from keys to multiple values.
        Builds a mapping of some attribute in ``sequence`` to
        the containing elements of ``sequence``.

        Args:
            sequence: Any iterable
            key_attr: Usually string like 'attr1.attr2'; see `look`
            skip_none: If None, raises a `KeyError` if the key is missing for any item; otherwise, skips it

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

        """
        dct = defaultdict(lambda: [])
        for item in sequence:
            v = CommonTools.look(item, key_attr)

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 not skip_none and v is None:
                raise XKeyError(f"No {key_attr} in {item}", key=key_attr)
            if v is not None:
                dct[v].append(item)
        return dct

    @classmethod
    def mem_size(cls, obj) -> str:
        """
        Returns the size of the object in memory as a human-readable string.

        Args:
            obj: Any Python object

        Returns:
            A human-readable size with units
        """
        return nicesize(sys.getsizeof(obj))

    @classmethod
    def devnull(cls):
        """
        Yields a 'writer' that does nothing.

        Example:
            >>> with CommonTools.devnull() as devnull:
            >>>     devnull.write('hello')
        """
        yield DevNull()

    @classmethod
    def parse_bool(cls, s: str) -> bool:

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)

        """
        Parses a 'true'/'false' string to a bool, ignoring case.

        Raises:
            ValueError: If neither true nor false
        """
        if isinstance(s, bool):
            return s
        if s.lower() == "false":
            return False
        if s.lower() == "true":
            return True
        raise XValueError(f"{s} is not true/false", value=s)

    @classmethod
    def parse_bool_flex(cls, s: str) -> bool:

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)

        """
        Parses a 'true'/'false'/'yes'/'no'/... string to a bool, ignoring case.

        Allowed:
            - "true", "t", "yes", "y", "1", "+"
            - "false", "f", "no", "n", "0", "-"

        Raises:
            XValueError: If neither true nor false
        """
        mp = {

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

            **{v: True for v in {"true", "t", "yes", "y", "1", "+"}},
            **{v: False for v in {"false", "f", "no", "n", "0", "-"}},
        }
        v = mp.get(s.lower())

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 v is None:
            raise XValueError(f"{s.lower()} is not in {','.join(mp.keys())}", value=s)
        return v


__all__ = ["CommonTools"]