pocketutils.tools.io_tools

Complexity

Total Complexity

37

Size/Duplication

Total Lines	243
Duplicated Lines	0 %

Importance

Changes

0

31 Methods

Rating	Name	Duplication	Size	Complexity
A	Base32HexBech.name()	0	3	1
A	Base32HexBechTilde.name()	0	3	1
A	Base64UrlTilde.name()	0	3	1
A	Base16.encode()	0	2	1
A	Base64Url.decode()	0	2	1
A	Base2048.encode()	0	2	1
A	Base32HexTilde.decode()	0	2	1
A	Base32Bech.name()	0	3	1
A	Base32Hex.encode()	0	2	1
A	Base64Url.encode()	0	2	1
A	IoTools.decode()	0	5	2
A	Base32HexTilde.encode()	0	2	1
A	_Alphabet32Enc.decode()	0	4	1
B	IoTools.hash_digest()	0	21	5
A	Base64UrlTilde.encode()	0	2	1
A	Base16.decode()	0	2	1
A	_Alphabet32Enc.encode()	0	4	1
A	Base85.encode()	0	2	1
A	Base32.encode()	0	2	1
A	Enc.name()	0	3	1
A	IoTools.encode()	0	5	2
A	Base2048.decode()	0	2	1
A	Enc.decode()	0	2	1
A	Base32Hex.decode()	0	2	1
A	Base85.decode()	0	2	1
A	Base64.decode()	0	2	1
A	Base32BechTilde.name()	0	3	1
A	Base64UrlTilde.decode()	0	2	1
A	Base32.decode()	0	2	1
A	Base64.encode()	0	2	1
A	Enc.encode()	0	2	1

import abc

Missing module docstring

import base64
import binascii
import hashlib
from typing import Literal, SupportsBytes

The name Literal does not seem to exist in module typing.

try:
    import base2048
except ImportError:
    base2048 = None


Encoding = (
    Literal["2048"]  # for fun
    | Literal["base85"]
    | Literal["base64"]
    | Literal["base64url"]
    | Literal["base64url-tilde"]
    | Literal["base32"]
    | Literal["base32-tilde"]
    | Literal["base32hex"]
    | Literal["base32hex-tilde"]
    | Literal["base32-bech32"]
    | Literal["base32-bech32-tilde"]
    | Literal["base32hex-bech32"]
    | Literal["base32hex-bech32-tilde"]
    | Literal["base16"]
    | Literal["hex"]
)

HashAlgorithm = (
    Literal["shake_256"]
    | Literal["shake_128"]
    | Literal["sha3_512"]
    | Literal["sha3_384"]
    | Literal["sha3_256"]
    | Literal["sha3_224"]
    | Literal["sha2_512"]
    | Literal["sha2_256"]
    | Literal["sha2_224"]
    | Literal["sha1"]
    | Literal["md5"]
    | Literal["crc32"]
)


class Enc(metaclass=abc.ABCMeta):

Missing class docstring

    @property
    def name(self) -> str:

Missing function or method docstring

        return self.__class__.__name__.lower()

    def encode(self, d: bytes) -> str:

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

        raise NotImplementedError()

    def decode(self, d: str) -> bytes:

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

        raise NotImplementedError()


class Base16(Enc):

Missing class docstring

    def encode(self, d: bytes) -> str:
        return base64.b16encode(d).decode(encoding="ascii")

    def decode(self, d: str) -> bytes:
        return base64.b16decode(d)


class Base32(Enc):

Missing class docstring

    def encode(self, d: bytes) -> str:
        return base64.b32encode(d).decode(encoding="ascii")

    def decode(self, d: str) -> bytes:
        return base64.b32decode(d)


class Base64(Enc):

Missing class docstring

    def encode(self, d: bytes) -> str:
        return base64.standard_b64encode(d).decode(encoding="ascii")

    def decode(self, d: str) -> bytes:
        return base64.standard_b64decode(d)


class Base64Url(Enc):

Missing class docstring

    def encode(self, d: bytes) -> str:
        return base64.urlsafe_b64encode(d).decode(encoding="ascii")

    def decode(self, d: str) -> bytes:
        return base64.urlsafe_b64decode(d)


class Base32Hex(Enc):

Missing class docstring

    def encode(self, d: bytes) -> str:
        return base64.b32hexencode(d).decode(encoding="ascii")

The Module base64 does not seem to have a member named b32hexencode.

    def decode(self, d: str) -> bytes:
        return base64.b32hexdecode(d)

The Module base64 does not seem to have a member named b32hexdecode.

class Base32HexTilde(Enc):

Missing class docstring

    def encode(self, d: bytes) -> str:
        return base64.b32hexencode(d).decode(encoding="ascii").replace("=", "~")

The Module base64 does not seem to have a member named b32hexencode.

    def decode(self, d: str) -> bytes:
        return base64.b32hexdecode(d.replace("=", "~"))

The Module base64 does not seem to have a member named b32hexdecode.

class Base2048(Enc):

Missing class docstring

    def encode(self, d: bytes) -> str:
        return base2048.encode(d).decode(encoding="ascii")

    def decode(self, d: str) -> bytes:
        return base2048.decode(d)


class _Alphabet32Enc(Enc):
    _base32_alphabet = ""
    _to_alphabet = ""

    def encode(self, d: bytes) -> str:
        encoded = base64.b32encode(d).decode(encoding="ascii")
        alphabet = dict(zip(self._base32_alphabet, self._to_alphabet))
        return "".join([alphabet[v] for v in encoded])

    def decode(self, d: str) -> bytes:
        alphabet = dict(zip(self._to_alphabet, self._base32_alphabet))
        d = "".join([alphabet[v] for v in d])
        return base64.b32hexdecode(d)

The Module base64 does not seem to have a member named b32hexdecode.

class Base32Bech(_Alphabet32Enc):

Missing class docstring

    _base32_alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567="
    _to_alphabet = "qpzry9x8gf2tvdw0s3jn54khce6mua7l="

    @property
    def name(self) -> str:
        return "base32-bech"


class Base32BechTilde(_Alphabet32Enc):

Missing class docstring

    _base32_alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567="
    _to_alphabet = "qpzry9x8gf2tvdw0s3jn54khce6mua7l~"

    @property
    def name(self) -> str:
        return "base32-bech-tilde"


class Base32HexBech(_Alphabet32Enc):

Missing class docstring

    _base32_alphabet = "0123456789ABCDEFGHIJKLMNOPQRSTUV="
    _to_alphabet = "023456789acdefghjklmnpqrstuvwxyz="

    @property
    def name(self) -> str:
        return "base32hex-bech"


class Base32HexBechTilde(_Alphabet32Enc):

Missing class docstring

    _base32_alphabet = "0123456789ABCDEFGHIJKLMNOPQRSTUV="
    _to_alphabet = "023456789acdefghjklmnpqrstuvwxyz~"

    @property
    def name(self) -> str:
        return "base32hex-bech-tilde"


class Base64UrlTilde(Enc):

Missing class docstring

    @property
    def name(self) -> str:
        return "base64url-tilde"

    def encode(self, d: bytes) -> str:
        return base64.urlsafe_b64encode(d).decode(encoding="ascii").replace("=", "~")

    def decode(self, d: str) -> bytes:
        return base64.urlsafe_b64decode(d.replace("~", "="))


class Base85(Enc):

Missing class docstring

    def encode(self, d: bytes) -> str:
        return base64.b85encode(d).decode(encoding="ascii")

    def decode(self, d: str) -> bytes:
        return base64.b85decode(d)


ENCODINGS = {
    e.name: e
    for e in [
        Base16,
        Base32,
        Base32Hex,
        Base32HexTilde,
        Base32Bech,
        Base32HexBech,
        Base32BechTilde,
        Base32HexBechTilde,
        Base64,
        Base64Url,
        Base64UrlTilde,
        Base85,
        Base2048,
    ]
}


class IoTools:

Missing class docstring

    @classmethod
    def hash_digest(

Missing function or method docstring

        cls,

Wrong hanging indentation before block (add 4 spaces).

        data: SupportsBytes | str,

Wrong hanging indentation before block (add 4 spaces).

        algorithm: HashAlgorithm,

Wrong hanging indentation before block (add 4 spaces).

        *,

Wrong hanging indentation before block (add 4 spaces).

        digest_length: int | None = None,

No space allowed around keyword argument assignment

Wrong hanging indentation before block (add 4 spaces).

        **kwargs,

Wrong hanging indentation before block (add 4 spaces).

    ) -> bytes:
        kwargs = dict(usedforsecurity=False) | kwargs
        x = data.encode("utf-8") if isinstance(data, str) else bytes(data)

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)

        if algorithm == "crc32":

Unnecessary "elif" after "return"

            return bytes(binascii.crc32(x))
        elif algorithm.startswith("shake_"):
            m = getattr(hashlib, algorithm)(**kwargs)

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

            m.update(x)
            return m.digest(128 if digest_length is None else digest_length)
        else:
            m = hashlib.new(algorithm, **kwargs)

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

            m.update(x)
            return m.digest()

    @classmethod
    def encode(cls, d: bytes, to: Encoding = "base64"):

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

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

        if to not in ENCODINGS:
            raise ValueError(f"Unknown encoding {to}")
        return ENCODINGS[to].encode(d)

    @classmethod
    def decode(cls, d: bytes, to: Encoding = "base64"):

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

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

        if to not in ENCODINGS:
            raise ValueError(f"Unknown encoding {to}")
        return ENCODINGS[to].decode(d)


__all__ = ["IoTools"]