pocketutils.tools.base_tools

Complexity

Total Complexity

41

Size/Duplication

Total Lines	311
Duplicated Lines	0 %

Importance

Changes

0

13 Methods

Rating	Name	Duplication	Size	Complexity
A	BaseTools.zip_list()	0	23	2
A	BaseTools.to_true_iterable()	0	13	2
A	BaseTools.forever()	0	10	2
B	BaseTools.zip_strict()	0	40	8
A	BaseTools.__repr__()	0	2	1
A	BaseTools.is_lambda()	0	14	3
A	BaseTools.look()	0	27	1
A	BaseTools.is_true_iterable()	0	16	1
C	BaseTools.get_log_function()	0	35	9
B	BaseTools.only()	0	48	7
A	BaseTools.__str__()	0	2	1
A	BaseTools.null_context()	0	17	1
A	BaseTools.make_writer()	0	18	3

import logging

Missing module docstring

import sys
from contextlib import contextmanager
from typing import (
    Any,
    ByteString,
    Callable,
    Generator,
    Iterable,
    Iterator,
    List,
    Optional,
    Tuple,
    TypeVar,
    Union,
)

from pocketutils.core._internal import look as _look

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

from pocketutils.core.exceptions import LengthMismatchError, MultipleMatchesError, XTypeError

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

from pocketutils.core.input_output import Writeable

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

logger = logging.getLogger("pocketutils")
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)

class BaseTools:

Missing class docstring

    @classmethod
    def is_lambda(cls, function: Any) -> bool:
        """
        Returns whether this is a lambda function. Will return False for non-callables.
        """
        # noinspection PyPep8Naming
        LAMBDA = lambda: 0  # noqa: E731

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

        if not hasattr(function, "__name__"):
            return False  # not a function
        return (
            isinstance(function, type(LAMBDA))
            and function.__name__ == LAMBDA.__name__
            or str(function).startswith("<function <lambda> at ")
            and str(function).endswith(">")
        )

    @classmethod
    def only(
        cls,

Wrong hanging indentation before block (add 4 spaces).

        sequence: Iterable[Any],

Wrong hanging indentation before block (add 4 spaces).

        condition: Union[str, Callable[[Any], bool]] = None,

Wrong hanging indentation before block (add 4 spaces).

        name: str = "collection",

Wrong hanging indentation before block (add 4 spaces).

    ) -> Any:
        """
        Returns either the SINGLE (ONLY) UNIQUE ITEM in the sequence or raises an exception.
        Each item must have __hash__ defined on it.

        Args:
            sequence: A list of any items (untyped)
            condition: If nonnull, consider only those matching this condition
            name: Just a name for the collection to use in an error message

        Returns:
            The first item the sequence.

        Raises:
            LookupError If the sequence is empty
            MultipleMatchesError If there is more than one unique item.
        """

        def _only(sq):

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

            st = set(sq)

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

            if len(st) > 1:
                raise MultipleMatchesError("More then 1 item in " + str(name))
            if len(st) == 0:
                raise LookupError("Empty " + str(name))
            return next(iter(st))

        if condition and isinstance(condition, str):

Unnecessary "elif" after "return"

            return _only(
                [
                    s
                    for s in sequence
                    if (
                        not getattr(s, condition[1:])
                        if condition.startswith("!")
                        else getattr(s, condition)
                    )
                ]
            )
        elif condition:
            return _only([s for s in sequence if condition(s)])
        else:
            return _only(sequence)

    @classmethod
    def zip_strict(cls, *args: Iterable[Any]) -> Generator[Tuple[Any], None, None]:
        """
        Same as zip(), but raises an IndexError if the lengths don't match.

        Args:
            args: Same as with ``zip``

        Yields:
            Tuples corresponding to the input items

        Raises:
            LengthMismatchError: If the lengths of the input iterators don't match
        """
        # we need to catch these cases before or they'll fail
        # in particular, 1 element would fail with a LengthMismatchError
        # and 0 elements would loop forever
        if len(args) < 2:
            yield from zip(*args)
            return
        iters = [iter(axis) for axis in args]
        n_elements = 0
        failures = []
        while len(failures) == 0:
            values = []
            failures = []
            for axis, iterator in enumerate(iters):
                try:
                    values.append(next(iterator))
                except StopIteration:
                    failures.append(axis)
            if len(failures) == 0:
                yield tuple(values)
            elif len(failures) == 1:
                raise LengthMismatchError(
                    f"Too few elements ({n_elements}) along axis {failures[0]}"
                )
            elif len(failures) < len(iters):
                raise LengthMismatchError(f"Too few elements ({n_elements}) along axes {failures}")
            n_elements += 1

    @classmethod
    def zip_list(cls, *args) -> List[Tuple[Any]]:
        """
        Same as :meth:`zip_strict`, but more informative.
        Converts to a list and can provide a more detailed error message.
        Zips two sequences into a list of tuples and raises an
        IndexError if the lengths don't match.

        Args:
            args: Same as with ``zip``

        Yields:
            Tuples corresponding to the input items

        Raises:
            LengthMismatchError: If the lengths of the input iterators don't match
        """
        try:
            return list(cls.zip_strict(*args))
        except LengthMismatchError:
            raise LengthMismatchError(
                "Length mismatch in zip_strict: Sizes are {}".format([len(x) for x in args])
            ) from None

    @classmethod
    def forever(cls) -> Iterator[int]:
        """
        Yields i for i in range(0, infinity).
        Useful for simplifying a i = 0; while True: i += 1 block.
        """
        i = 0
        while True:
            yield i
            i += 1

    @classmethod
    def to_true_iterable(cls, s: Any) -> Iterable[Any]:

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)

        """
        See :meth:`is_true_iterable`.

        Examples:
            - ``to_true_iterable('abc')         # ['abc']``
            - ``to_true_iterable(['ab', 'cd')]  # ['ab', 'cd']``
        """
        if BaseTools.is_true_iterable(s):

Unnecessary "else" after "return"

            return s
        else:
            return [s]

    @classmethod
    def is_true_iterable(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 ``s`` is a probably "proper" iterable.
        In other words, iterable but not a string or bytes.

        .. caution::
            This is not fully reliable.
            Types that do not define ``__iter__`` but are iterable
            via ``__getitem__`` will not be included.
        """
        return (
            s is not None
            and isinstance(s, Iterable)

Second argument of isinstance is not a type

            and not isinstance(s, str)
            and not isinstance(s, ByteString)

Second argument of isinstance is not a type

        )

    @classmethod
    @contextmanager
    def null_context(cls) -> Generator[None, None, None]:
        """
        Returns an empty context (literally just yields).
        Useful to simplify when a generator needs to be used depending on a switch.
        Ex::
            if verbose_flag:
                do_something()
            else:
                with Tools.silenced():
                    do_something()
        Can become::
            with (Tools.null_context() if verbose else Tools.silenced()):
                do_something()
        """
        yield

    @classmethod
    def look(cls, obj: Y, attrs: Union[str, Iterable[str], Callable[[Y], Z]]) -> Optional[Z]:
        """
        Follows a dotted syntax for getting an item nested in class attributes.
        Returns the value of a chain of attributes on object ``obj``,
        or None any object in that chain is None or lacks the next attribute.

        Example:
            Get a kitten's breed::

                BaseTools.look(kitten), 'breed.name')  # either None or a string

        Args:
            obj: Any object
            attrs: One of:
                - A string in the form attr1.attr2, translating to ``obj.attr1``
                - An iterable of strings of the attributes
                - A function that maps ``obj`` to its output;
                   equivalent to calling `attrs(obj)` but returning None on ``AttributeError``.

        Returns:
            Either None or the type of the attribute

        Raises:
            TypeError:
        """
        return _look(obj, attrs)

    @classmethod
    def make_writer(cls, writer: Union[Writeable, Callable[[str], Any]]):

Missing function or method docstring

        if Writeable.isinstance(writer):

Unnecessary "elif" after "return"

            return writer
        elif callable(writer):

            class W_(Writeable):

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

Missing class docstring

                def write(self, msg):
                    writer(msg)

                def flush(self):
                    pass

                def close(self):
                    pass

            return W_()
        raise XTypeError(f"{type(writer)} cannot be wrapped into a Writeable")

    @classmethod
    def get_log_function(

Too many return statements (7/6)

        cls, log: Union[None, str, Callable[[str], None], Any]

Wrong hanging indentation before block (add 4 spaces).

    ) -> Callable[[str], None]:
        """
        Gets a logging function from user input.
        The rules are:
            - If None, uses logger.info
            - If 'print' or 'stdout',  use sys.stdout.write
            - If 'stderr', use sys.stderr.write
            - If another str or int, try using that logger level (raises an error if invalid)
            - If callable, returns it
            - If it has a callable method called 'write', uses that

        Returns:
            A function of the log message that returns None
        """
        if log is None:

Unnecessary "elif" after "return"

            return logger.info
        elif isinstance(log, str) and log.lower() in ["print", "stdout"]:
            # noinspection PyTypeChecker
            return sys.stdout.write
        elif log == "stderr":
            # noinspection PyTypeChecker
            return sys.stderr.write
        elif isinstance(log, int):
            return getattr(logger, logging.getLevelName(log).lower())
        elif isinstance(log, str):
            return getattr(logger, log.lower())
        elif callable(log):
            return log
        elif hasattr(log, "write"):
            return log.write
        else:
            raise XTypeError(f"Log type {type(log)} not known", actual=str(type(log)))

    def __repr__(self):
        return self.__class__.__name__

    def __str__(self):
        return self.__class__.__name__


__all__ = ["BaseTools"]