pocketutils.core._internal

Complexity

Total Complexity

21

Size/Duplication

Total Lines	132
Duplicated Lines	0 %

Importance

Changes

0

3 Functions

Rating	Name	Duplication	Size	Complexity
A	nicesize()	0	22	4
C	look()	0	20	10
A	null_context()	0	2	1

from __future__ import annotations

Missing module docstring

import logging
import operator
import os
import sys
from pathlib import PurePath
from typing import Any, Callable, Iterable, Optional, TypeVar, Union

T = TypeVar("T", covariant=True)

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

Y = TypeVar("Y")

Class name "Y" 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)

logger = logging.getLogger("pocketutils")

PathLike = Union[str, PurePath, os.PathLike]


class PathLikeUtils:

Missing class docstring

    @classmethod
    def isinstance(cls, value: Any):

Missing function or method docstring

        return (
            isinstance(value, str) or isinstance(value, os.PathLike) or isinstance(value, PurePath)

Consider merging these isinstance calls to isinstance(value, (PurePath, os.PathLike, str))

        )


if sys.version_info < (3, 9):
    # TODO remove both of these on 0.5 release, breaking backwards-compat

TODO and FIXME comments should generally be avoided.

    # This breaks on Python 3.9
    # https://github.com/dmyersturnbull/pocketutils/issues/2
    PathLike.isinstance = PathLikeUtils.isinstance
    # and this just provides backwards-compat until 0.5 release
    pathlike_isinstance = PathLikeUtils.isinstance


class Pretty:

Missing class docstring

    @classmethod
    def condensed(cls, item, depth=1):

Missing function or method docstring

        if isinstance(item, dict):

Unnecessary "else" after "return"

            return (
                "{\n"
                + "\n".join(
                    [
                        "\t" * (depth + 1) + k + " = " + cls.condensed(v, depth + 1)
                        for k, v in item.items()
                    ]
                )
                + "\n"
                + "\t" * depth
                + "}"
            )
        else:
            return str(item)

    @classmethod
    def expanded(cls, item, depth=1):

Missing function or method docstring

        if isinstance(item, dict):

Unnecessary "elif" after "return"

            return (
                "{\n"
                + "\n".join(
                    [
                        "\t" * (depth + 1) + k + " = " + cls.expanded(v, depth + 1)
                        for k, v in item.items()
                    ]
                )
                + "\n"
                + "\t" * depth
                + "}"
            )
        elif isinstance(item, (list, set)):
            return (
                "[\n"
                + "\n".join(["\t" * (depth + 1) + cls.expanded(v, depth + 1) for v in item])
                + "\n"
                + "\t" * depth
                + "]"
            )
        else:
            return str(item)


def nicesize(nbytes: int, space: str = "") -> str:
    """
    Uses IEC 1998 units, such as KiB (1024).
        nbytes: Number of bytes
        space: Separator between digits and units

        Returns:
            Formatted string
    """
    data = {
        "PiB": 1024 ** 5,
        "TiB": 1024 ** 4,
        "GiB": 1024 ** 3,
        "MiB": 1024 ** 2,
        "KiB": 1024 ** 1,
    }
    for suffix, scale in data.items():
        if nbytes >= scale:
            break
    else:
        scale, suffix = 1, "B"
    return str(nbytes // scale) + space + suffix


def look(obj: Y, attrs: Union[str, Iterable[str], Callable[[Y], Z]]) -> Optional[Z]:
    """
    See VeryCommonTools.look.
    """
    if attrs is None:
        return obj
    if not isinstance(attrs, str) and hasattr(attrs, "__len__") and len(attrs) == 0:
        return obj
    if isinstance(attrs, str):
        attrs = operator.attrgetter(attrs)
    elif isinstance(attrs, Iterable) and all((isinstance(a, str) for a in attrs)):

The variable a does not seem to be defined.

Second argument of isinstance is not a type

        attrs = operator.attrgetter(".".join(attrs))
    elif not callable(attrs):
        raise TypeError(
            f"Type {type(attrs)} unrecognized for key/attrib. Must be a function, string, or sequence of strings"

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

        )
    try:
        return attrs(obj)
    except AttributeError:
        return None


def null_context():

Missing function or method docstring

    yield


__all__ = ["nicesize", "look", "logger", "Pretty", "PathLike", "PathLikeUtils"]