codext 1.16.1__tar.gz → 1.16.3__tar.gz

{codext-1.16.1 → codext-1.16.3}/.github/workflows/python-package.yml

@@ -65,7 +65,7 @@ jobs:
     - uses: actions/checkout@v5
       with:
         fetch-depth: 0
-        ref: ${{ github.head_ref || github.ref_name }}
+        ref: ${{ (github.event_name == 'pull_request' || github.event_name == 'pull_request_target') && github.event.pull_request.head.sha || github.sha }}
     - name: Set up Python ${{ env.python_version }}
       uses: actions/setup-python@v6
       with:

{codext-1.16.1 → codext-1.16.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codext
-Version: 1.16.1
+Version: 1.16.3
 Summary: Native codecs extension
 Author-email: Alexandre D'Hondt <alexandre.dhondt@gmail.com>
 License:                     GNU GENERAL PUBLIC LICENSE
@@ -1034,12 +1034,14 @@ This category also contains `ascii85`, `adobe`, `[x]btoa`, `zeromq` with the `ba
 - [X] `barbie-N`: aka Barbie Typewriter (*N* belongs to [1, 4])
 - [X] `beaufort`: aka Beaufort Cipher (variant of Vigenere Cipher)
 - [X] `citrix`: aka Citrix CTX1 password encoding
+- [X] `phillips`: aka Phillips Cipher (polyalphabetic block cipher with 8 key squares)
 - [X] `polybius`: aka Polybius Square Cipher
 - [X] `railfence`: aka Rail Fence Cipher
 - [X] `rotN`: aka Caesar cipher (*N* belongs to [1,25])
 - [X] `scytaleN`: encrypts using the number of letters on the rod (*N* belongs to [1,[)
 - [X] `shiftN`: shift ordinals (*N* belongs to [1,255])
 - [X] `trithemius`: aka Trithemius Cipher (variant of Vigenere Cipher)
+- [X] `vic`: aka VIC Cipher
 - [X] `vigenere`: aka Vigenere Cipher
 - [X] `xorN`: XOR with a single byte (*N* belongs to [1,255])
 

{codext-1.16.1 → codext-1.16.3}/README.md

@@ -336,12 +336,14 @@ This category also contains `ascii85`, `adobe`, `[x]btoa`, `zeromq` with the `ba
 - [X] `barbie-N`: aka Barbie Typewriter (*N* belongs to [1, 4])
 - [X] `beaufort`: aka Beaufort Cipher (variant of Vigenere Cipher)
 - [X] `citrix`: aka Citrix CTX1 password encoding
+- [X] `phillips`: aka Phillips Cipher (polyalphabetic block cipher with 8 key squares)
 - [X] `polybius`: aka Polybius Square Cipher
 - [X] `railfence`: aka Rail Fence Cipher
 - [X] `rotN`: aka Caesar cipher (*N* belongs to [1,25])
 - [X] `scytaleN`: encrypts using the number of letters on the rod (*N* belongs to [1,[)
 - [X] `shiftN`: shift ordinals (*N* belongs to [1,255])
 - [X] `trithemius`: aka Trithemius Cipher (variant of Vigenere Cipher)
+- [X] `vic`: aka VIC Cipher
 - [X] `vigenere`: aka Vigenere Cipher
 - [X] `xorN`: XOR with a single byte (*N* belongs to [1,255])
 

{codext-1.16.1 → codext-1.16.3}/docs/pages/enc/crypto.md

@@ -162,6 +162,25 @@ This implements the Citrix CTX1 password encoding algorithm.
 
 -----
 
+### Phillips Cipher
+
+This implements Phillips cipher, a polyalphabetic code using 8 grids generated with one keyword.
+
+**Codec** | **Conversions** | **Aliases** | **Comment**
+:---: | :---: | --- | ---
+`phillips` | text <-> phillips ciphertext | `phillips-key`, `phillips_password`, ... |
+
+```python
+>>> codext.encode("this is a test", "phillips_mysuperkey")
+'ZCNM NM E XKMVZ'
+>>> codext.encode("Another Test String", "phillips-PaSsWoRd")
+'SMEZKBE LBON OLEHQHV'
+>>> codext.decode("SMEZKBE LBON OLEHQHV", "phillips-password")
+'ANOTHER TEST STRINGX'
+```
+
+-----
+
 ### Polybius Square Cipher
 
 This implements the well-known Polybius Square cipher, using the square with the alphabet in normal order as the default. It can be used dynamically with a custom alphabet.
@@ -255,6 +274,30 @@ This is a variant of the [Vigenere Cipher](#vigenere-cipher) with key `"ABCDEFGH
 
 -----
 
+### VIC Cipher
+
+The VIC cipher combines a straddling checkerboard substitution (converting letters to a stream of digits) and an over-encryption based on a modulo-10 sum with eventually a conversion from digits to text.
+
+**Codec** | **Conversions** | **Aliases** | **Comment**
+:---: | :---: | --- | ---
+`vic` | text <-> VIC digit/text ciphertext | `vic-keyword`, `vic-key-12`, `vic-^-26-0248`, `vic-*-73-534T` | optional checkerboard keyword or alphabet marker, blank positions (exactly 2 distinct digits), over-encryption key (digits), "`T`" marker for text conversion
+
+Alphabet markers:
+- `*`: uses "`ABC[...]XYZ./`" (uppercase letters + "`./`")
+- `^`: uses "`./ZYX[...]CBA`" ("`./`" + reversed uppercase letters)
+
+```python
+>>> import codext
+>>> codext.encode("VICTOR", "vic-^-26-0248T")
+'VVXYWYY.XYJ'
+>>> codext.decode("VVXYWYY.XYJ", "vic-^-26-0248T")
+'VICTOR2'  # trailing superfluous letter because of text conversion
+>>> codext.encode("LONGTESTSTRING", "vic-^-85-72564")
+'5031237844273727064454072378'
+```
+
+-----
+
 ### Vigenere Cipher
 
 This is a dynamic encoding, that is, it holds the key. There is no default key, meaning that `vigenere` as the encoding scheme throws a `LookupError` indicating that the _key must be a non-empty alphabetic string_.

codext-1.16.3/src/codext/VERSION.txt

@@ -0,0 +1 @@
+1.16.3

{codext-1.16.1 → codext-1.16.3}/src/codext/base/_base.py

@@ -130,6 +130,10 @@ def base_encode(input, charset, errors="strict", exc=BaseEncodeError):
     while i > 0:
         i, c = divmod(i, n)
         r = charset[c] + r
+    # preserve leading zero bytes: big-integer bases such as Base58 map each
+    # leading null byte of the input to a leading charset[0] character
+    if not isinstance(input, int):
+        r = charset[0] * (len(input) - len(input.lstrip("\x00"))) + r
     return r
 
 
@@ -151,7 +155,8 @@ def base_decode(input, charset, errors="strict", exc=BaseDecodeError):
             i = i * n + charset.index(c)
         except ValueError:
             handle_error("base", errors, exc, decode=True)(c, k, dec(i), "base%d" % n)
-    return dec(i)
+    # restore the leading zero bytes encoded as leading charset[0] characters
+    return chr(0) * (len(input) - len(input.lstrip(charset[0]))) + dec(i)
 
 
 # base codec factory functions

{codext-1.16.1 → codext-1.16.3}/src/codext/base/base45.py

@@ -34,7 +34,10 @@ def base45_encode(mode):
     b45 = _get_charset(B45, mode)
     def encode(text, errors="strict"):
         t, s = b(text), ""
-        for i in range(0, len(text), 2):
+        # iterate over the byte sequence (t), not len(text): when the input
+        # holds non-ASCII characters, b(text) is longer than text and using
+        # len(text) silently drops the trailing bytes
+        for i in range(0, len(t), 2):
             n = 256 * __ord(t[i])
             try:
                 n += __ord(t[i+1])
@@ -54,7 +57,7 @@ def base45_decode(mode):
     def decode(text, errors="strict"):
         t, s = b(text), ""
         ehandler = handle_error("base45", errors, decode=True)
-        for i in range(0, len(text), 3):
+        for i in range(0, len(t), 3):
             try:
                 n = b45[__chr(t[i])]
             except KeyError:

{codext-1.16.1 → codext-1.16.3}/src/codext/crypto/__init__.py

@@ -4,11 +4,13 @@ from .atbash import *
 from .bacon import *
 from .barbie import *
 from .citrix import *
+from .phillips import *
 from .polybius import *
 from .railfence import *
 from .rot import *
 from .scytale import *
 from .shift import *
+from .vic import *
 from .vigenere import *
 from .xor import *
 

codext-1.16.3/src/codext/crypto/phillips.py

@@ -0,0 +1,130 @@
+# -*- coding: UTF-8 -*-
+"""Phillips Cipher Codec - phillips content encoding.
+
+The Phillips cipher is a polyalphabetic substitution cipher using 8 key squares.  The first square is a 5×5 grid built
+ from a keyword (I and J share one cell).  Seven additional squares are derived by sequentially swapping adjacent rows
+ in a descending bubble pattern.  Plaintext is divided into blocks of T letters (default 5); each letter is individually
+ enciphered by shifting its grid position right by DH columns and down by DV rows (both default to 1), wrapping
+ around with toroidal topology.  J is treated as I.
+
+Parameters:
+  key        -- keyword used to seed the initial 5×5 grid (required)
+  block_size -- number of letters per grid-cycle block, 1–25 (default 5)
+  dh         -- horizontal (column) shift for encryption, 1–4 (default 1)
+  dv         -- vertical (row) shift for encryption, 1–4 (default 1)
+
+This codec:
+- en/decodes strings from str to str
+- en/decodes strings from bytes to bytes
+- decodes file content to str (read)
+- encodes file content from str to bytes (write)
+
+Reference: https://www.dcode.fr/phillips-cipher
+"""
+from ..__common__ import *
+
+
+__examples__ = {
+    'enc(phillips)':               None,
+    'enc(phillips-key)':           {'ATTACK': "HUUHLL", 'TESTME': "UFZUSM", 'ABCDEF': "HCLMFA"},
+    'enc(phillips-key-5-1-2)':     {'This is a Test String': "KPVBVHTCRHCHCGQBT"},
+    'dec(phillips-key-5-1-2)':     {'KPVBVHTCRHCHCGQBT': "THISISATESTSTRING"},
+    'enc-dec(phillips-key)':       ["ATTACK", "TESTME", "ABCDEF"],
+    'enc-dec(phillips-secret)':    ["HELLOWORLD", "ATTACKATDAWN"],
+    'enc-dec(phillips-key-2)':     ["ATTACK", "TESTME"],
+    'enc-dec(phillips-key-5-2)':   ["ATTACK"],
+    'enc-dec(phillips-key-5-1-2)': ["ATTACK"],
+}
+__guess__ = ["phillips-key", "phillips-secret", "phillips-password"]
+
+
+_ALPHABET = "ABCDEFGHIKLMNOPQRSTUVWXYZ"
+
+
+def __make_grids(key):
+    """Return all 8 grids built by a descending bubble-swap row permutation."""
+    seen, letters = set(), []
+    for c in key.upper().replace("J", "I") + _ALPHABET:
+        if c in set(_ALPHABET) and c not in seen:
+            letters.append(c)
+            seen.add(c)
+    grid = [letters[i * 5:(i + 1) * 5] for i in range(5)]
+    grids = [grid]
+    for k in range(7):
+        r = k % 4
+        grid = [row[:] for row in grid]
+        grid[r], grid[r + 1] = grid[r + 1], grid[r]
+        grids.append(grid)
+    return grids
+
+
+def _shift_text(text, grids, block_size, dh, dv, errors, decode=False):
+    t = ensure_str(text).upper().replace("J", "I")
+    pos_maps = [
+        {ch: (r, c) for r, row in enumerate(grid) for c, ch in enumerate(row)}
+        for grid in grids
+    ]
+    _h = handle_error("phillips", errors, decode=decode)
+    r, i = "", 0
+    for pos, c in enumerate(t):
+        if c == " ":
+            continue
+        if c not in set(_ALPHABET):
+            r += _h(c, pos, r)
+            continue
+        grid_idx = (i // block_size) % 8
+        grid = grids[grid_idx]
+        s, col = pos_maps[grid_idx][c]
+        r += grid[(s + dv) % 5][(col + dh) % 5]
+        i += 1
+    return r, len(text)
+
+
+def _make_cipher(key, block_size, dh, dv):
+    _key = (key or "").strip()
+    try:
+        block_size = int(block_size) if block_size else 5
+    except (ValueError, TypeError):
+        raise LookupError(f"Bad parameter for encoding 'phillips': block_size must be an integer, got {block_size}")
+    if not (1 <= block_size <= 25):
+        raise LookupError("Bad parameter for encoding 'phillips': block_size must be between 1 and 25, got "
+                          f"{block_size}")
+    try:
+        dh = int(dh) if dh else 1
+    except (ValueError, TypeError):
+        raise LookupError(f"Bad parameter for encoding 'phillips': dh must be an integer, got {dh}")
+    if not (1 <= dh <= 4):
+        raise LookupError(f"Bad parameter for encoding 'phillips': dh must be between 1 and 4, got {dh}")
+    try:
+        dv = int(dv) if dv else 1
+    except (ValueError, TypeError):
+        raise LookupError(f"Bad parameter for encoding 'phillips': dv must be an integer, got {dv}")
+    if not (1 <= dv <= 4):
+        raise LookupError(f"Bad parameter for encoding 'phillips': dv must be between 1 and 4, got {dv}")
+    return _key, block_size, dh, dv, __make_grids(_key) if _key and _key.isalpha() else None
+
+
+def phillips_encode(key, block_size=None, dh=None, dv=None):
+    _key, block_size, dh, dv, grids = _make_cipher(key, block_size, dh, dv)
+    def encode(text, errors="strict"):
+        if grids is None:
+            raise LookupError("Bad parameter for encoding 'phillips': "
+                              "key must be a non-empty alphabetic string")
+        return _shift_text(text, grids, block_size, dh, dv, errors)
+    return encode
+
+
+def phillips_decode(key, block_size=None, dh=None, dv=None):
+    _key, block_size, dh, dv, grids = _make_cipher(key, block_size, dh, dv)
+    def decode(text, errors="strict"):
+        if grids is None:
+            raise LookupError("Bad parameter for decoding 'phillips': "
+                              "key must be a non-empty alphabetic string")
+        return _shift_text(text, grids, block_size, -dh, -dv, errors, True)
+    return decode
+
+
+add("phillips", phillips_encode, phillips_decode,
+    r"^phillips(?:[-_]cipher)?(?:[-_]([a-zA-Z]+))?(?:[-_]([1-9]|1[0-9]|2[0-5]))?(?:[-_]([1-4]))?(?:[-_]([1-4]))?$",
+    printables_rate=1., penalty=.1)
+

codext-1.16.3/src/codext/crypto/vic.py

@@ -0,0 +1,142 @@
+# -*- coding: UTF-8 -*-
+"""Vic Cipher Codec - vic content encoding.
+
+This codec:
+- en/decodes strings from str to str
+- en/decodes strings from bytes to bytes
+- decodes file content to str (read)
+- encodes file content from str to bytes (write)
+"""
+from itertools import cycle
+from string import ascii_uppercase as UC
+
+from ..__common__ import *
+
+
+__examples__ = {
+    'dec(vic-test-33)':         None,
+    'dec(vic-*-12-1234T':       {'BBXMBDMBCBBHEMC': "THISISATEST"},
+    'dec(vic-^-26-0248T)':      {'VVXYWYY.XYJ': "VICTOR2"},  # '2' because of superfluous extra letter from substitution
+    'enc(vic-test-12-ABC)':     None,
+    'enc(vic-*-12-1234T':       {'This is a Test': "BBXMBDMBCBBHEMC"},
+    'enc(vic-^-26-0248)':       {'VICTOR': "88547440546"},
+    'enc(vic-^-26-0248T)':      {'VICTOR': "VVXYWYY.XYJ"},
+    'enc-dec(vic-^-26)':        ["TEST", "LONGTESTSTRING", "VICTOR"],
+    'enc-dec(vic-^-85-72564)':  ["TEST", "LONGTESTSTRING", "VICTOR"],
+    'enc-dec(vic-^-85-54321T)': ["TEST", "LONGTESTSTRING", "VICTOR"],
+}
+__guess__ = ["vic"]
+
+
+def __build_alphabet(key, alphabet=UC, reverse=False):
+    """Return the 28-letter alphabet derived from the input key."""
+    seen, result = set(), ""
+    for c in (key or "").upper():
+        if c.isalpha() and c not in seen:
+            result += c
+            seen.add(c)
+    for c in (alphabet[::-1] if reverse else alphabet):
+        if c not in seen:
+            result += c
+    return "./" + result if reverse else result + "./"
+
+
+def __build_checkerboard(alphabet, blank1=1, blank2=2):
+    """Build encode/decode lookup tables for the straddling checkerboard.
+
+    Layout with digit1=2 and digit2=6:
+         0  1 [2] 3  4  5 [6] 7  8  9
+      0: *  *     *  *  *     *  *  *
+      2: *  *  *  *  *  *  *  *  *  *
+      6: *  *  *  *  *  *  *  *  *  *
+    """
+    if blank1 == blank2:
+        raise LookupError(f"Bad parameter for encoding 'vic': blank1 and blank2 cannot be identical")
+    enc, dec, i = {}, {}, 0
+    # top row
+    for col in range(10):
+        if col not in (blank1, blank2):
+            enc[alphabet[i]] = str(col)
+            i += 1
+    # second row ; header digit is 'blank1'
+    for col in range(10):
+        enc[alphabet[i]] = str(blank1) + str(col)
+        i += 1
+    # third row ; header digit is 'blank2'
+    for col in range(10):
+        enc[alphabet[i]] = str(blank2) + str(col)
+        i += 1
+    return enc, {v: k for k, v in enc.items()}
+
+
+def __set_params(key, blanks, numeric_key):
+    return (UC if key == "*" else UC[::-1] if key == "^" else key).upper(), \
+           tuple(map(int, str(blanks) or "12")), \
+           str(numeric_key or "").rstrip("T"), \
+           key == "^", \
+           str(numeric_key or " ")[-1] == "T"
+
+
+def vic_encode(key=None, blanks=None, numeric_key=None):
+    key, blanks, numeric_key, rev, txt = __set_params(key, blanks, numeric_key)
+    enc_map, dec_map = __build_checkerboard(__build_alphabet(key, reverse=rev), blanks[0], blanks[1])
+    def _encode(text, errors="strict"):
+        _h = handle_error("vic", errors)
+        digits, nk_i, nk_l = [], 0, len(numeric_key or "")
+        for pos, c in enumerate(ensure_str(text).upper().replace(" ", "")):
+            # 1) encode with the straddling checkerboard
+            c = enc_map[c] if c in enc_map else _h(c, pos, "".join(digits))
+            # 2) if numeric_key is defined, over-encrypt digits
+            if numeric_key and c.isdigit():
+                for ci in c:
+                    digits.append(str((int(ci) + int(numeric_key[nk_i % nk_l])) % 10))
+                    nk_i += 1
+            else:
+                digits.append(c)
+        r = "".join(d for d in digits if d)
+        # 3) if text mode, convert digits to text
+        if txt:
+            i, r0, l, r = 0, r, len(r), ""
+            while i < len(r0):
+                if int(r0[i]) in blanks:
+                    r += dec_map[r0[i] + ("0" if i == l - 1 else r0[i+1])]
+                    i += 1
+                else:
+                    r += dec_map[r0[i]]
+                i += 1
+        return r, len(r)
+    return _encode
+
+
+def vic_decode(key=None, blanks=None, numeric_key=None):
+    key, blanks, numeric_key, rev, txt = __set_params(key, blanks, numeric_key)
+    enc_map, dec_map = __build_checkerboard(__build_alphabet(key, reverse=rev), blanks[0], blanks[1])
+    def _decode(text, errors="strict"):
+        _h = handle_error("vic", errors, decode=True)
+        # 1) if text mode, convert text to digits
+        text = "".join(enc_map[c] for c in ensure_str(text)) if txt else ensure_str(text)
+        # 2) if numeric_key is defined, over-decrypt
+        digits, nk_i, nk_l = [], 0, len(numeric_key or "")
+        for pos, c in enumerate(text):
+            if numeric_key and c.isdigit():
+                for ci in c:
+                    digits.append(str((int(c) - int(numeric_key[nk_i % nk_l])) % 10))
+                    nk_i += 1
+            else:
+                digits.append(c if c.isdigit() else _h(c, pos, "".join(digits)))
+        # 3) decode with the straddling checkerboard
+        i, r, r0 = 0, "", "".join(d for d in digits if d)
+        while i < (l := len(r0)):
+            if int(r0[i]) in blanks:
+                r += r0[i] if i == l - 1 else dec_map[r0[i] + r0[i+1]]
+                i += 1
+            else:
+                r += dec_map[r0[i]] if r0[i] in dec_map else _h(r0[i], i, r)
+            i += 1
+        return r, len(r)
+    return _decode
+
+
+add("vic", vic_encode, vic_decode, r"vic(?:[-_]([\^*./a-zA-Z]+))?(?:[-_]([0-9]{2}))?(?:[-_]([0-9]+T?))?$",
+    printables_rate=1., penalty=.1)
+

{codext-1.16.1 → codext-1.16.3}/src/codext.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codext
-Version: 1.16.1
+Version: 1.16.3
 Summary: Native codecs extension
 Author-email: Alexandre D'Hondt <alexandre.dhondt@gmail.com>
 License:                     GNU GENERAL PUBLIC LICENSE
@@ -1034,12 +1034,14 @@ This category also contains `ascii85`, `adobe`, `[x]btoa`, `zeromq` with the `ba
 - [X] `barbie-N`: aka Barbie Typewriter (*N* belongs to [1, 4])
 - [X] `beaufort`: aka Beaufort Cipher (variant of Vigenere Cipher)
 - [X] `citrix`: aka Citrix CTX1 password encoding
+- [X] `phillips`: aka Phillips Cipher (polyalphabetic block cipher with 8 key squares)
 - [X] `polybius`: aka Polybius Square Cipher
 - [X] `railfence`: aka Rail Fence Cipher
 - [X] `rotN`: aka Caesar cipher (*N* belongs to [1,25])
 - [X] `scytaleN`: encrypts using the number of letters on the rod (*N* belongs to [1,[)
 - [X] `shiftN`: shift ordinals (*N* belongs to [1,255])
 - [X] `trithemius`: aka Trithemius Cipher (variant of Vigenere Cipher)
+- [X] `vic`: aka VIC Cipher
 - [X] `vigenere`: aka Vigenere Cipher
 - [X] `xorN`: XOR with a single byte (*N* belongs to [1,255])
 

{codext-1.16.1 → codext-1.16.3}/src/codext.egg-info/SOURCES.txt

@@ -85,11 +85,13 @@ src/codext/crypto/atbash.py
 src/codext/crypto/bacon.py
 src/codext/crypto/barbie.py
 src/codext/crypto/citrix.py
+src/codext/crypto/phillips.py
 src/codext/crypto/polybius.py
 src/codext/crypto/railfence.py
 src/codext/crypto/rot.py
 src/codext/crypto/scytale.py
 src/codext/crypto/shift.py
+src/codext/crypto/vic.py
 src/codext/crypto/vigenere.py
 src/codext/crypto/xor.py
 src/codext/hashing/__init__.py

{codext-1.16.1 → codext-1.16.3}/tests/test_base.py

@@ -172,7 +172,15 @@ class TestCodecsBase(TestCase):
         self.assertEqual(codecs.decode(B58, "base58-fl"), STR)
         self.assertEqual(codecs.encode(STR, "base58-short-url"), B58)
         self.assertEqual(codecs.encode(STR, "base58-url"), B58)
-    
+        # leading null bytes must be preserved as leading charset[0] ('1')
+        self.assertEqual(codecs.encode("\x00abc", "base58"), "1ZiCa")
+        self.assertEqual(codecs.encode("\x00", "base58"), "1")
+        self.assertEqual(codecs.encode("\x00\x00abc", "base58"), "11ZiCa")
+        self.assertEqual(codecs.decode("1ZiCa", "base58"), "\x00abc")
+        self.assertEqual(codecs.decode("11ZiCa", "base58"), "\x00\x00abc")
+        self.assertEqual(codecs.encode(b("\x00abc"), "base58"), b("1ZiCa"))
+        self.assertEqual(codecs.decode(b("1ZiCa"), "base58"), b("\x00abc"))
+
     def test_codec_base62(self):
         for b62, enc in zip(["CsoB4HQ5gmgMyCenF7E", "M2yLERaFqwqW8MoxPHO"], ["base62", "base62-inv"]):
             self.assertEqual(codecs.encode(STR, enc), b62)
@@ -211,6 +219,19 @@ class TestCodecsBase(TestCase):
         self.assertRaises(ValueError, codecs.decode, b(B100)[1:], "base100")
         self.assertIsNotNone(codecs.decode(b(B100) + b"\n", "base100", "ignore"))
     
+    def test_codec_base45(self):
+        # RFC 9285 test vectors
+        for s, b45 in [("AB", "BB8"), ("Hello!!", "%69 VD92EX0"), ("base-45", "UJCLQE7W581")]:
+            self.assertEqual(codecs.encode(s, "base45"), b45)
+            self.assertEqual(codecs.encode(b(s), "base45"), b(b45))
+            self.assertEqual(codecs.decode(b45, "base45"), s)
+            self.assertEqual(codecs.decode(b(b45), "base45"), b(s))
+        # a trailing non-ASCII byte must not be dropped (byte length, not str length, drives encoding)
+        self.assertEqual(codecs.encode(b"\xcf\xb1\x1b", "base45"), b"OBQR0")
+        self.assertEqual(codecs.decode(b"OBQR0", "base45"), b"\xcf\xb1\x1b")
+        for data in [b"\xff\xfe", b"hello", b"\x00", b"\x80\x81\x82\x83\x84"]:
+            self.assertEqual(codecs.decode(codecs.encode(data, "base45"), "base45"), data)
+
     def test_codec_base_generic(self):
         for n in range(2, 255):
             bn = "base{}_generic".format(n)

codext-1.16.1/src/codext/VERSION.txt

@@ -1 +0,0 @@
-1.16.1