rtty-soda 0.1.6__py3-none-any.whl → 0.2.1__py3-none-any.whl

rtty_soda/archivers.py

@@ -1,7 +1,5 @@
-import bz2
-import lzma
-import zlib
 from collections.abc import Callable
+from compression import bz2, lzma, zlib, zstd
 
 __all__ = ["ARCHIVERS", "UNARCHIVERS", "Archiver"]
 
@@ -9,6 +7,10 @@ __all__ = ["ARCHIVERS", "UNARCHIVERS", "Archiver"]
 type Archiver = Callable[[bytes], bytes]
 
 
+def compress_zstd(data: bytes) -> bytes:
+    return zstd.compress(data, level=20)
+
+
 def compress_zlib(data: bytes) -> bytes:
     return zlib.compress(data, level=9)
 
@@ -26,6 +28,10 @@ def compress_lzma(data: bytes) -> bytes:
     )
 
 
+def decompress_zstd(data: bytes) -> bytes:
+    return zstd.decompress(data)
+
+
 def decompress_zlib(data: bytes) -> bytes:
     return zlib.decompress(data)
 
@@ -43,6 +49,7 @@ def noop(data: bytes) -> bytes:
 
 
 ARCHIVERS: dict[str, Archiver] = {
+    "zstd": compress_zstd,
     "zlib": compress_zlib,
     "bz2": compress_bz2,
     "lzma": compress_lzma,
@@ -50,6 +57,7 @@ ARCHIVERS: dict[str, Archiver] = {
 }
 
 UNARCHIVERS: dict[str, Archiver] = {
+    "zstd": decompress_zstd,
     "zlib": decompress_zlib,
     "bz2": decompress_bz2,
     "lzma": decompress_lzma,

rtty_soda/cli_io.py

@@ -1,21 +1,26 @@
 import random
 import re
 import string
-from pathlib import Path
-from typing import TextIO, cast
+from typing import TYPE_CHECKING, TextIO, cast
+
+if TYPE_CHECKING:
+    from pathlib import Path
 
 import click
 
-from rtty_soda.encoders import Encoder, RawEncoder, encode_str
+from rtty_soda.encoders import Encoder, decode_bytes, encode_str
 
 __all__ = [
+    "format_output",
+    "pad_newlines",
     "print_stats",
     "read_bytes",
-    "read_ciphertext_bytes",
-    "read_clean_bytes",
-    "read_plaintext_bytes",
+    "read_encoded_stripped",
+    "read_key_bytes",
+    "read_password_bytes",
     "read_str",
     "remove_whitespace",
+    "split_groups",
     "write_bytes_atomic",
     "write_output",
 ]
@@ -23,35 +28,33 @@ __all__ = [
 
 def read_str(source: Path) -> str:
     with click.open_file(source, mode="rt", encoding="utf-8", errors="strict") as fd:
-        return cast("TextIO", fd).read().strip()
-
-
-def read_bytes(source: Path) -> bytes:
-    return encode_str(read_str(source))
+        return cast("TextIO", fd).read()
 
 
 def remove_whitespace(data: str) -> str:
     return re.sub(r"\s", "", data)
 
 
-def read_clean_bytes(source: Path) -> bytes:
+def read_encoded_stripped(source: Path) -> bytes:
     data = read_str(source)
     data = remove_whitespace(data)
     return encode_str(data)
 
 
-def read_plaintext_bytes(source: Path, in_enc: Encoder) -> bytes:
-    if in_enc == RawEncoder:
+def read_bytes(source: Path, encoder: Encoder) -> bytes:
+    if encoder.is_binary:
         return source.read_bytes()
 
-    return read_bytes(source)
+    return read_encoded_stripped(source)
 
 
-def read_ciphertext_bytes(source: Path, in_enc: Encoder) -> bytes:
-    if in_enc == RawEncoder:
-        return source.read_bytes()
+def read_key_bytes(source: Path, encoder: Encoder) -> bytes:
+    key = read_bytes(source, encoder)
+    return encoder.decode(key)
+
 
-    return read_clean_bytes(source)
+def read_password_bytes(source: Path) -> bytes:
+    return encode_str(read_str(source).strip())
 
 
 def write_bytes_atomic(target: Path, data: bytes) -> None:
@@ -61,16 +64,47 @@ def write_bytes_atomic(target: Path, data: bytes) -> None:
     temp_path.replace(target)
 
 
-def write_output(target: Path | None, data: bytes, out_enc: Encoder) -> None:
-    if target is None or target.stem == "-":
-        if out_enc == RawEncoder:
-            click.confirm(
-                "Print binary output to the terminal?", default=False, abort=True
-            )
+def split_groups(data: str, group_len: int, line_len: int) -> str:
+    step = group_len if group_len > 0 else line_len - 1
+    groups = (data[i : i + step] for i in range(0, len(data), step))
+    result: list[str] = []
+    line: list[str] = []
+    i = 0
+    gpl = line_len // (step + 1)
+    for group in groups:
+        line.append(group)
+        i += 1
+        if i == gpl:
+            result.append(" ".join(line))
+            i = 0
+            line = []
+
+    if line:
+        result.append(" ".join(line))
 
-        click.echo()
-        click.echo(data)
-        click.echo()
+    return "\n".join(result)
+
+
+def pad_newlines(data: str, count: int) -> str:
+    padding = "\n" * count
+    return padding + data.strip() + "\n" + padding
+
+
+def format_output(data: bytes, group_len: int, line_len: int, padding: int) -> bytes:
+    text = decode_bytes(data)
+    if group_len > 0 or line_len > 0:
+        text = split_groups(text, group_len, line_len)
+
+    if padding > 0:
+        text = pad_newlines(text, padding)
+
+    return encode_str(text)
+
+
+def write_output(target: Path | None, data: bytes) -> None:
+    if target is None or target.stem == "-":
+        add_nl = not data.endswith(b"\n")
+        click.echo(data, nl=add_nl)
     else:
         if target.exists():
             click.confirm(

rtty_soda/cryptography/kdf.py

@@ -1,3 +1,4 @@
+from nacl.encoding import RawEncoder
 from nacl.hash import blake2b
 from nacl.public import PrivateKey
 from nacl.pwhash import argon2id
@@ -11,8 +12,6 @@ from nacl.pwhash.argon2id import (
     SALTBYTES,
 )
 
-from rtty_soda.encoders import Encoder, RawEncoder
-
 __all__ = ["KDF_PROFILES", "KdfProfile", "hash_salt", "kdf"]
 
 type KdfProfile = tuple[int, int]
@@ -34,9 +33,17 @@ certainty;
 
 
 def hash_salt(salt: bytes) -> bytes:
-    return blake2b(salt, digest_size=SALTBYTES, encoder=RawEncoder)
+    return blake2b(data=salt, digest_size=SALTBYTES, encoder=RawEncoder)
 
 
-def kdf(password: bytes, profile: KdfProfile, out_enc: Encoder) -> bytes:
+def kdf(password: bytes, profile: KdfProfile) -> bytes:
     salt = hash_salt(password + SALT_MOD)
-    return argon2id.kdf(PrivateKey.SIZE, password, salt, *profile, encoder=out_enc)
+    ops, mem = profile
+    return argon2id.kdf(
+        size=PrivateKey.SIZE,
+        password=password,
+        salt=salt,
+        opslimit=ops,
+        memlimit=mem,
+        encoder=RawEncoder,
+    )

rtty_soda/cryptography/public.py

@@ -1,20 +1,20 @@
+from typing import TYPE_CHECKING
+
+from nacl.encoding import RawEncoder
 from nacl.public import Box, PrivateKey, PublicKey
-from nacl.utils import EncryptedMessage
 
-from rtty_soda.encoders import Encoder
+if TYPE_CHECKING:
+    from nacl.utils import EncryptedMessage
+
 
 __all__ = ["decrypt", "encrypt"]
 
 
-def encrypt(
-    private: PrivateKey, public: PublicKey, data: bytes, out_enc: Encoder
-) -> EncryptedMessage:
-    box = Box(private, public)
-    return box.encrypt(data, encoder=out_enc)
+def encrypt(private: PrivateKey, public: PublicKey, data: bytes) -> EncryptedMessage:
+    box = Box(private_key=private, public_key=public)
+    return box.encrypt(plaintext=data, encoder=RawEncoder)
 
 
-def decrypt(
-    private: PrivateKey, public: PublicKey, data: bytes, in_enc: Encoder
-) -> bytes:
-    box = Box(private, public)
-    return box.decrypt(data, encoder=in_enc)
+def decrypt(private: PrivateKey, public: PublicKey, data: bytes) -> bytes:
+    box = Box(private_key=private, public_key=public)
+    return box.decrypt(ciphertext=data, encoder=RawEncoder)

rtty_soda/cryptography/secret.py

@@ -1,17 +1,20 @@
-from nacl.encoding import Encoder
+from typing import TYPE_CHECKING
+
+from nacl.encoding import RawEncoder
 from nacl.secret import SecretBox
-from nacl.utils import EncryptedMessage
+
+if TYPE_CHECKING:
+    from nacl.utils import EncryptedMessage
+
 
 __all__ = ["decrypt", "encrypt"]
 
 
-def encrypt(
-    key: bytes, data: bytes, key_enc: Encoder, out_enc: Encoder
-) -> EncryptedMessage:
-    box = SecretBox(key, key_enc)
-    return box.encrypt(data, encoder=out_enc)
+def encrypt(key: bytes, data: bytes) -> EncryptedMessage:
+    box = SecretBox(key=key, encoder=RawEncoder)
+    return box.encrypt(plaintext=data, encoder=RawEncoder)
 
 
-def decrypt(key: bytes, data: bytes, key_enc: Encoder, in_enc: Encoder) -> bytes:
-    box = SecretBox(key, key_enc)
-    return box.decrypt(data, encoder=in_enc)
+def decrypt(key: bytes, data: bytes) -> bytes:
+    box = SecretBox(key=key, encoder=RawEncoder)
+    return box.decrypt(ciphertext=data, encoder=RawEncoder)

rtty_soda/encoders/__init__.py

@@ -1,13 +1,16 @@
-from nacl.encoding import Base64Encoder, Encoder, RawEncoder
-
 from .base26_encoder import Base26Encoder
+from .base31_encoder import Base31Encoder
 from .base36_encoder import Base36Encoder
+from .base64_encoder import Base64Encoder
 from .base94_encoder import Base94Encoder
+from .encoder import Encoder
 from .functions import decode_bytes, encode_str
+from .raw_encoder import RawEncoder
 
 __all__ = [
     "ENCODERS",
     "Base26Encoder",
+    "Base31Encoder",
     "Base36Encoder",
     "Base64Encoder",
     "Base94Encoder",
@@ -19,6 +22,7 @@ __all__ = [
 
 ENCODERS: dict[str, Encoder] = {
     "base26": Base26Encoder,
+    "base31": Base31Encoder,
     "base36": Base36Encoder,
     "base64": Base64Encoder,
     "base94": Base94Encoder,

rtty_soda/encoders/base26_encoder.py

@@ -1,6 +1,5 @@
 import string
-
-from nacl.encoding import _Encoder as EncoderABC  # pyright: ignore [reportPrivateUsage]
+from typing import ClassVar
 
 from .functions import base_to_bytes, bytes_to_base, decode_bytes, encode_str
 
@@ -9,7 +8,9 @@ __all__ = ["ALPHABET", "Base26Encoder"]
 ALPHABET = string.ascii_uppercase
 
 
-class Base26Encoder(EncoderABC):
+class Base26Encoder:
+    is_binary: ClassVar = False
+
     @staticmethod
     def encode(data: bytes) -> bytes:
         return encode_str(bytes_to_base(data, ALPHABET))

rtty_soda/encoders/base31_encoder.py

@@ -0,0 +1,19 @@
+from typing import ClassVar
+
+from .functions import base_to_bytes, bytes_to_base, decode_bytes, encode_str
+
+__all__ = ["ALPHABET", "Base31Encoder"]
+
+ALPHABET = "АБВГДЕЖЗИЙКЛМНОПРСТУФХЦЧШЩЬЫЭЮЯ"
+
+
+class Base31Encoder:
+    is_binary: ClassVar = False
+
+    @staticmethod
+    def encode(data: bytes) -> bytes:
+        return encode_str(bytes_to_base(data, ALPHABET))
+
+    @staticmethod
+    def decode(data: bytes) -> bytes:
+        return base_to_bytes(decode_bytes(data), ALPHABET)

rtty_soda/encoders/base36_encoder.py

@@ -1,6 +1,5 @@
 import string
-
-from nacl.encoding import _Encoder as EncoderABC  # pyright: ignore [reportPrivateUsage]
+from typing import ClassVar
 
 from .functions import base_to_bytes, bytes_to_base, decode_bytes, encode_str
 
@@ -9,7 +8,9 @@ __all__ = ["ALPHABET", "Base36Encoder"]
 ALPHABET = string.digits + string.ascii_uppercase
 
 
-class Base36Encoder(EncoderABC):
+class Base36Encoder:
+    is_binary: ClassVar = False
+
     @staticmethod
     def encode(data: bytes) -> bytes:
         return encode_str(bytes_to_base(data, ALPHABET))

rtty_soda/encoders/base64_encoder.py

@@ -0,0 +1,16 @@
+import base64
+from typing import ClassVar
+
+__all__ = ["Base64Encoder"]
+
+
+class Base64Encoder:
+    is_binary: ClassVar = False
+
+    @staticmethod
+    def encode(data: bytes) -> bytes:
+        return base64.b64encode(data)
+
+    @staticmethod
+    def decode(data: bytes) -> bytes:
+        return base64.b64decode(data)

rtty_soda/encoders/base94_encoder.py

@@ -1,4 +1,4 @@
-from nacl.encoding import _Encoder as EncoderABC  # pyright: ignore [reportPrivateUsage]
+from typing import ClassVar
 
 from .functions import base_to_bytes, bytes_to_base, decode_bytes, encode_str
 
@@ -7,7 +7,9 @@ __all__ = ["ALPHABET", "Base94Encoder"]
 ALPHABET = "".join([chr(i) for i in range(33, 127)])
 
 
-class Base94Encoder(EncoderABC):
+class Base94Encoder:
+    is_binary: ClassVar = False
+
     @staticmethod
     def encode(data: bytes) -> bytes:
         return encode_str(bytes_to_base(data, ALPHABET))

rtty_soda/encoders/encoder.py

@@ -0,0 +1,13 @@
+from typing import Protocol
+
+__all__ = ["Encoder"]
+
+
+class Encoder(Protocol):
+    is_binary: bool
+
+    @staticmethod
+    def encode(data: bytes) -> bytes: ...
+
+    @staticmethod
+    def decode(data: bytes) -> bytes: ...

rtty_soda/encoders/functions.py

@@ -1,3 +1,5 @@
+from typing import cast
+
 __all__ = ["base_to_bytes", "bytes_to_base", "decode_bytes", "encode_str"]
 
 
@@ -27,7 +29,7 @@ def base_to_int(source: str, alphabet: str) -> int:
     number = 0
     base = len(alphabet)
     for index, digit in enumerate(reversed(source)):
-        number += alphabet.index(digit) * (base**index)
+        number += alphabet.index(digit) * cast("int", base**index)
 
     return number
 

rtty_soda/encoders/raw_encoder.py

@@ -0,0 +1,15 @@
+from typing import ClassVar
+
+__all__ = ["RawEncoder"]
+
+
+class RawEncoder:
+    is_binary: ClassVar = True
+
+    @staticmethod
+    def encode(data: bytes) -> bytes:
+        return data
+
+    @staticmethod
+    def decode(data: bytes) -> bytes:
+        return data