Support any bytes-like object as ignorechars.

Author: serhiy-storchaka

Doc/library/base64.rst

@@ -85,9 +85,10 @@ POST request.
    A :exc:`binascii.Error` exception is raised
    if *s* is incorrectly padded.
 
-   If *ignorechars* is specified, it should be a byte string containing
-   characters to ignore from the input, and *validate* is ``True`` by default.
-   Otherwise *validate* is ``False`` by default.
+   If *ignorechars* is specified, it should be a :term:`bytes-like object`
+   containing characters to ignore from the input when *validate* is true.
+   The default value of *validate* is ``True`` if *ignorechars* is specified,
+   ``False`` otherwise.
 
    If *validate* is false, characters that are neither
    in the normal base-64 alphabet nor the alternative alphabet are

Doc/library/binascii.rst

@@ -54,9 +54,9 @@ The :mod:`binascii` module defines the following functions:
    Convert a block of base64 data back to binary and return the binary data. More
    than one line may be passed at a time.
 
-   If *ignorechars* is specified, it should be a byte string containing
-   characters to ignore from the input when *strict_mode* is true.
-   *strict_mode* is ``True`` by default, if *ignorechars* is specified,
+   If *ignorechars* is specified, it should be a :term:`bytes-like object`
+   containing characters to ignore from the input when *strict_mode* is true.
+   The default value of *strict_mode* is ``True`` if *ignorechars* is specified,
    ``False`` otherwise.
 
    If *strict_mode* is true, only valid base64 data will be converted. Invalid base64

Lib/test/test_base64.py

@@ -307,7 +307,11 @@ def test_b64decode_invalid_chars(self):
                  (b'@@', b'', b'@!'),
                  (b'!', b'', b'@!'),
                  (b"YWJj\n", b"abc", b'\n'),
-                 (b'YWJj\nYWI=', b'abcab', b'\n'))
+                 (b'YWJj\nYWI=', b'abcab', b'\n'),
+                 (b'YW\nJj', b'abc', b'\n'),
+                 (b'YW\nJj', b'abc', bytearray(b'\n')),
+                 (b'YW\nJj', b'abc', memoryview(b'\n')),
+        )
         funcs = (
             base64.b64decode,
             base64.standard_b64decode,
@@ -329,8 +333,6 @@ def test_b64decode_invalid_chars(self):
                     base64.b64decode(bstr, ignorechars=ignorechars),
                                  res)
 
-        with self.assertRaises(TypeError):
-            base64.b64decode(b'', ignorechars=bytearray())
         with self.assertRaises(TypeError):
             base64.b64decode(b'', ignorechars='')
         with self.assertRaises(TypeError):

Lib/test/test_binascii.py

@@ -199,10 +199,10 @@ def assertNonBase64Data(data, expected, ignorechars):
         assertNonBase64Data(b'abc=:', b'i\xb7', ignorechars=b':')
         assertNonBase64Data(b'ab==\n', b'i', ignorechars=b'\n')
         assertNonBase64Data(b'ab=:=', b'i', ignorechars=b':')
+        assertNonBase64Data(b'a\nb==', b'i', ignorechars=bytearray(b'\n'))
+        assertNonBase64Data(b'a\nb==', b'i', ignorechars=memoryview(b'\n'))
 
         data = self.type2test(b'a\nb==')
-        with self.assertRaises(TypeError):
-            binascii.a2b_base64(data, ignorechars=bytearray())
         with self.assertRaises(TypeError):
             binascii.a2b_base64(data, ignorechars='')
         with self.assertRaises(TypeError):

Modules/binascii.c

@@ -471,11 +471,10 @@ binascii_b2a_uu_impl(PyObject *module, Py_buffer *data, int backtick)
 
 
 static int
-ignorechar(unsigned char c, PyBytesObject *ignorechars)
+ignorechar(unsigned char c, Py_buffer *ignorechars)
 {
-    return (ignorechars != NULL &&
-            memchr(PyBytes_AS_STRING(ignorechars), c,
-                   PyBytes_GET_SIZE(ignorechars)));
+    return (ignorechars->buf != NULL &&
+            memchr(ignorechars->buf, c, ignorechars->len));
 }
 
 /*[clinic input]
@@ -488,7 +487,7 @@ binascii.a2b_base64
         When set to true, bytes that are not part of the base64 standard are
         not allowed.  The same applies to excess data after padding (= / ==).
         Set to True by default if ignorechars is specified, False otherwise.
-    ignorechars: PyBytesObject = NULL
+    ignorechars: Py_buffer(py_default="<unrepresentable>") = None
         A byte string containing characters to ignore from the input when
         strict_mode is true.
 
@@ -497,8 +496,8 @@ Decode a line of base64 data.
 
 static PyObject *
 binascii_a2b_base64_impl(PyObject *module, Py_buffer *data, int strict_mode,
-                         PyBytesObject *ignorechars)
-/*[clinic end generated code: output=b1868e0d886cd8cf input=e2d2e48c986e2afb]*/
+                         Py_buffer *ignorechars)
+/*[clinic end generated code: output=eab37aea4cfa6daa input=3be4937d72943835]*/
 {
     assert(data->len >= 0);
 
@@ -507,7 +506,7 @@ binascii_a2b_base64_impl(PyObject *module, Py_buffer *data, int strict_mode,
     binascii_state *state = NULL;
 
     if (strict_mode == -1) {
-        strict_mode = (ignorechars != NULL);
+        strict_mode = (ignorechars->buf != NULL);
     }
 
     /* Allocate the buffer */