Update PR for #145981

- Use the new `alphabet` parameter in `binascii`
- Remove `binascii.a2b_base32hex()` and `binascii.b2a_base32hex()`
- Change value for `.. versionadded::` ReST directive in docs for
  new `binascii` functions to "next" instead of "3.15"

Author: kangtastic

Doc/library/binascii.rst

@@ -182,7 +182,7 @@ The :mod:`!binascii` module defines the following functions:
 
    .. versionadded:: 3.15
 
-.. function:: a2b_base32(string, /)
+.. function:: a2b_base32(string, /, *, alphabet=BASE32_ALPHABET)
 
    Convert base32 data back to binary and return the binary data.
 
@@ -193,38 +193,22 @@ The :mod:`!binascii` module defines the following functions:
    * Contains no excess data after padding (including excess padding, newlines, etc.).
    * Does not start with padding.
 
+   Optional *alphabet* must be a :class:`bytes` object of length 32 which
+   specifies an alternative alphabet.
+
    Invalid base32 data will raise :exc:`binascii.Error`.
 
-   .. versionadded:: 3.15
+   .. versionadded:: next
 
-.. function:: b2a_base32(data, /)
+.. function:: b2a_base32(data, /, *, alphabet=BASE32_ALPHABET)
 
    Convert binary data to a line(s) of ASCII characters in base32 coding,
    as specified in :rfc:`4648`. The return value is the converted line.
 
-   .. versionadded:: 3.15
-
-.. function:: a2b_base32hex(string, /)
-
-   Convert base32hex data back to binary and return the binary data.
-
-   Valid base32hex:
-
-   * Conforms to :rfc:`4648`.
-   * Contains only characters from the base32hex alphabet.
-   * Contains no excess data after padding (including excess padding, newlines, etc.).
-   * Does not start with padding.
-
-   Invalid base32hex data will raise :exc:`binascii.Error`.
-
-   .. versionadded:: 3.15
-
-.. function:: b2a_base32hex(data, /)
-
-   Convert binary data to a line(s) of ASCII characters in base32hex coding,
-   as specified in :rfc:`4648`. The return value is the converted line.
+   Optional *alphabet* must be a :term:`bytes-like object` of length 32 which
+   specifies an alternative alphabet.
 
-   .. versionadded:: 3.15
+   .. versionadded:: next
 
 .. function:: a2b_qp(data, header=False)
 
@@ -370,6 +354,18 @@ The :mod:`!binascii` module defines the following functions:
 
    .. versionadded:: next
 
+.. data:: BASE32_ALPHABET
+
+   The base32 alphabet according to :rfc:`4648`.
+
+   .. versionadded:: next
+
+.. data:: BASE32HEX_ALPHABET
+
+   The "Extended Hex" base32hex alphabet according to :rfc:`4648`.
+
+   .. versionadded:: next
+
 
 .. seealso::
 

Lib/base64.py

@@ -234,13 +234,13 @@ def b32decode(s, casefold=False, map01=None):
                                         extra_args=_B32_DECODE_MAP01_DOCSTRING)
 
 def b32hexencode(s):
-    return binascii.b2a_base32hex(s)
+    return binascii.b2a_base32(s, alphabet=binascii.BASE32HEX_ALPHABET)
 b32hexencode.__doc__ = _B32_ENCODE_DOCSTRING.format(encoding='base32hex')
 
 def b32hexdecode(s, casefold=False):
     # base32hex does not have the 01 mapping
     s = _b32decode_prepare(s, casefold)
-    return binascii.a2b_base32hex(s)
+    return binascii.a2b_base32(s, alphabet=binascii.BASE32HEX_ALPHABET)
 b32hexdecode.__doc__ = _B32_DECODE_DOCSTRING.format(encoding='base32hex',
                                                     extra_args='')
 

Lib/test/test_binascii.py

@@ -10,10 +10,10 @@
 
 
 # Note: "*_hex" functions are aliases for "(un)hexlify"
-b2a_functions = ['b2a_ascii85', 'b2a_base32', 'b2a_base32hex', 'b2a_base64', 'b2a_base85',
+b2a_functions = ['b2a_ascii85', 'b2a_base32', 'b2a_base64', 'b2a_base85',
                  'b2a_hex', 'b2a_qp', 'b2a_uu',
                  'hexlify']
-a2b_functions = ['a2b_ascii85', 'a2b_base32', 'a2b_base32hex', 'a2b_base64', 'a2b_base85',
+a2b_functions = ['a2b_ascii85', 'a2b_base32', 'a2b_base64', 'a2b_base85',
                  'a2b_hex', 'a2b_qp', 'a2b_uu',
                  'unhexlify']
 all_functions = a2b_functions + b2a_functions + ['crc32', 'crc_hqx']
@@ -820,155 +820,31 @@ def assertInvalidLength(*args):
         assertInvalidLength(b"BEEFCA=K", b"\t\x08Q\x01")
         assertInvalidLength(b"BEEFCA=====K", b"\t\x08Q\x01")
 
-    def test_base32hex_valid(self):
-        # Test base32hex with valid data
-        lines = []
-        step = 0
-        i = 0
-        while i < len(self.rawdata):
-            b = self.type2test(self.rawdata[i:i + step])
-            a = binascii.b2a_base32hex(b)
-            lines.append(a)
-            i += step
-            step += 1
-        res = bytes()
-        for line in lines:
-            a = self.type2test(line)
-            b = binascii.a2b_base32hex(a)
-            res += b
-        self.assertEqual(res, self.rawdata)
-
-    def test_base32hex_errors(self):
-        def _fixPadding(data):
-            fixed = data.replace(b"=", b"")
-            len_8 = len(fixed) % 8
-            p = 8 - len_8 if len_8 else 0
-            return fixed + b"=" * p
-
-        def _assertRegexTemplate(assert_regex, data, good_padding_result=None):
-            with self.assertRaisesRegex(binascii.Error, assert_regex):
-                binascii.a2b_base32hex(self.type2test(data))
-            if good_padding_result:
-                fixed = self.type2test(_fixPadding(data))
-                self.assertEqual(binascii.a2b_base32hex(fixed), good_padding_result)
-
-        def assertNonBase32HexData(*args):
-            _assertRegexTemplate(r"(?i)Only base32hex data", *args)
-
-        def assertExcessData(*args):
-            _assertRegexTemplate(r"(?i)Excess data", *args)
-
-        def assertExcessPadding(*args):
-            _assertRegexTemplate(r"(?i)Excess padding", *args)
-
-        def assertLeadingPadding(*args):
-            _assertRegexTemplate(r"(?i)Leading padding", *args)
-
-        def assertIncorrectPadding(*args):
-            _assertRegexTemplate(r"(?i)Incorrect padding", *args)
-
-        def assertDiscontinuousPadding(*args):
-            _assertRegexTemplate(r"(?i)Discontinuous padding", *args)
-
-        def assertInvalidLength(*args):
-            _assertRegexTemplate(r"(?i)Invalid.+number of data characters", *args)
-
-        assertNonBase32HexData(b"a")
-        assertNonBase32HexData(b"AA-")
-        assertNonBase32HexData(b"ABCDE==!")
-        assertNonBase32HexData(b"ab:(){:|:&};:==")
-
-        assertExcessData(b"AB======C")
-        assertExcessData(b"AB======CD")
-        assertExcessData(b"ABCD====E")
-        assertExcessData(b"ABCDE===FGH")
-        assertExcessData(b"ABCDEFG=H")
-        assertExcessData(b"4321====55555555")
-
-        assertExcessData(b"BE======EF", b"[\x9c")
-        assertExcessData(b"BEEF====C", b"[\x9c\xf6")
-        assertExcessData(b"BEEFC===AK", b"[\x9c\xf6*")
-        assertExcessData(b"BEEFCAK=E", b"[\x9c\xf6*\x8e")
-
-        assertExcessPadding(b"BE=======", b"[")
-        assertExcessPadding(b"BE========", b"[")
-        assertExcessPadding(b"BEEF=====", b"[\x9c")
-        assertExcessPadding(b"BEEF======", b"[\x9c")
-        assertExcessPadding(b"BEEFC====", b"[\x9c\xf6")
-        assertExcessPadding(b"BEEFC=====", b"[\x9c\xf6")
-        assertExcessPadding(b"BEEFCAK==", b"[\x9c\xf6*")
-        assertExcessPadding(b"BEEFCAK===", b"[\x9c\xf6*")
-        assertExcessPadding(b"BEEFCAKE=", b"[\x9c\xf6*\x8e")
-        assertExcessPadding(b"BEEFCAKE==", b"[\x9c\xf6*\x8e")
-        assertExcessPadding(b"BEEFCAKE===", b"[\x9c\xf6*\x8e")
-        assertExcessPadding(b"BEEFCAKE====", b"[\x9c\xf6*\x8e")
-        assertExcessPadding(b"BEEFCAKE=====", b"[\x9c\xf6*\x8e")
-        assertExcessPadding(b"BEEFCAKE======", b"[\x9c\xf6*\x8e")
-        assertExcessPadding(b"BEEFCAKE=======", b"[\x9c\xf6*\x8e")
-        assertExcessPadding(b"BEEFCAKE========", b"[\x9c\xf6*\x8e")
-        assertExcessPadding(b"BEEFCAKE=========", b"[\x9c\xf6*\x8e")
-
-        assertLeadingPadding(b"=", b"")
-        assertLeadingPadding(b"==", b"")
-        assertLeadingPadding(b"===", b"")
-        assertLeadingPadding(b"====", b"")
-        assertLeadingPadding(b"=====", b"")
-        assertLeadingPadding(b"======", b"")
-        assertLeadingPadding(b"=======", b"")
-        assertLeadingPadding(b"========", b"")
-        assertLeadingPadding(b"=========", b"")
-        assertLeadingPadding(b"=BEEFCAKE", b"[\x9c\xf6*\x8e")
-        assertLeadingPadding(b"==BEEFCAKE", b"[\x9c\xf6*\x8e")
-        assertLeadingPadding(b"===BEEFCAKE", b"[\x9c\xf6*\x8e")
-        assertLeadingPadding(b"====BEEFCAKE", b"[\x9c\xf6*\x8e")
-        assertLeadingPadding(b"=====BEEFCAKE", b"[\x9c\xf6*\x8e")
-        assertLeadingPadding(b"======BEEFCAKE", b"[\x9c\xf6*\x8e")
-        assertLeadingPadding(b"=======BEEFCAKE", b"[\x9c\xf6*\x8e")
-        assertLeadingPadding(b"========BEEFCAKE", b"[\x9c\xf6*\x8e")
-        assertLeadingPadding(b"=========BEEFCAKE", b"[\x9c\xf6*\x8e")
-
-        assertIncorrectPadding(b"A")
-        assertIncorrectPadding(b"AB")
-        assertIncorrectPadding(b"ABC")
-        assertIncorrectPadding(b"ABCD")
-        assertIncorrectPadding(b"ABCDE")
-        assertIncorrectPadding(b"ABCDEF")
-        assertIncorrectPadding(b"ABCDEFG")
-
-        assertIncorrectPadding(b"BE=", b"[")
-        assertIncorrectPadding(b"BE==", b"[")
-        assertIncorrectPadding(b"BE===", b"[")
-        assertIncorrectPadding(b"BE====", b"[")
-        assertIncorrectPadding(b"BE=====", b"[")
-        assertIncorrectPadding(b"BEEF=", b"[\x9c")
-        assertIncorrectPadding(b"BEEF==", b"[\x9c")
-        assertIncorrectPadding(b"BEEF===", b"[\x9c")
-        assertIncorrectPadding(b"BEEFC=", b"[\x9c\xf6")
-        assertIncorrectPadding(b"BEEFC==", b"[\x9c\xf6")
-
-        assertDiscontinuousPadding(b"BE=EF===", b"[\x9c")
-        assertDiscontinuousPadding(b"BE==EF==", b"[\x9c")
-        assertDiscontinuousPadding(b"BEEF=C==", b"[\x9c\xf6")
-        assertDiscontinuousPadding(b"BEEFC=AK", b"[\x9c\xf6*")
+    def test_base32_alphabet(self):
+        alphabet = b'0Aa1Bb2Cc3Dd4Ee5Ff6Gg7Hh8Ii9JjKk'
+        data = self.type2test(self.rawdata)
+        encoded = binascii.b2a_base32(data, alphabet=alphabet)
+        trans = bytes.maketrans(binascii.BASE32_ALPHABET, alphabet)
+        expected = binascii.b2a_base32(data).translate(trans)
+        self.assertEqual(encoded, expected)
+        self.assertEqual(binascii.a2b_base32(encoded, alphabet=alphabet), self.rawdata)
+        self.assertEqual(binascii.b2a_base32(data, alphabet=self.type2test(alphabet)), expected)
 
-        assertInvalidLength(b"A=")
-        assertInvalidLength(b"A==")
-        assertInvalidLength(b"A===")
-        assertInvalidLength(b"A====")
-        assertInvalidLength(b"A=====")
-        assertInvalidLength(b"A======")
-        assertInvalidLength(b"ABC=")
-        assertInvalidLength(b"ABC==")
-        assertInvalidLength(b"ABC===")
-        assertInvalidLength(b"ABC====")
-        assertInvalidLength(b"ABCDEF=")
+        data = self.type2test(b'')
+        self.assertEqual(binascii.b2a_base32(data, alphabet=alphabet), b'')
+        self.assertEqual(binascii.a2b_base32(data, alphabet=alphabet), b'')
 
-        assertInvalidLength(b"B=E=====", b"[")
-        assertInvalidLength(b"B==E====", b"[")
-        assertInvalidLength(b"BEE=F===", b"[\x9c")
-        assertInvalidLength(b"BEE==F==", b"[\x9c")
-        assertInvalidLength(b"BEEFCA=K", b"[\x9c\xf6*")
-        assertInvalidLength(b"BEEFCA=====K", b"[\x9c\xf6*")
+        for func in binascii.b2a_base32, binascii.a2b_base32:
+            with self.assertRaises(TypeError):
+                func(data, alphabet=None)
+            with self.assertRaises(TypeError):
+                func(data, alphabet=alphabet.decode())
+            with self.assertRaises(ValueError):
+                func(data, alphabet=alphabet[:-1])
+            with self.assertRaises(ValueError):
+                func(data, alphabet=alphabet+b'?')
+        with self.assertRaises(TypeError):
+            binascii.a2b_base32(data, alphabet=bytearray(alphabet))
 
     def test_uu(self):
         MAX_UU = 45