Change function signatures and reflow docstrings in base64.py

Improve consistency in parameter names and formatting.

Author: kangtastic

Lib/base64.py

@@ -293,61 +293,61 @@ def b16decode(s, casefold=False):
 #
 # Ascii85 encoding/decoding
 #
-def a85encode(b, *, foldspaces=False, wrapcol=0, pad=False, adobe=False):
-    """Encode bytes-like object b using Ascii85 and return a bytes object.
+def a85encode(s, *, foldspaces=False, wrapcol=0, pad=False, adobe=False):
+    """Encode the bytes-like object s using Ascii85 and return a bytes object.
 
     foldspaces is an optional flag that uses the special short sequence 'y'
     instead of 4 consecutive spaces (ASCII 0x20) as supported by 'btoa'. This
     feature is not supported by the "standard" Adobe encoding.
 
-    wrapcol controls whether the output should have newline (b'\\n') characters
-    added to it. If this is non-zero, each output line will be at most this
-    many characters long.
+    wrapcol controls whether the output should have newline (b'\\n')
+    characters added to it. If this is non-zero, each output line will be at
+    most this many characters long.
 
     pad controls whether the input is padded to a multiple of 4 before
     encoding. Note that the btoa implementation always pads.
 
     adobe controls whether the encoded byte sequence is framed with <~ and ~>,
     which is used by the Adobe implementation.
     """
-    return binascii.b2a_ascii85(b, fold_spaces=foldspaces,
+    return binascii.b2a_ascii85(s, fold_spaces=foldspaces,
                                 wrap=adobe, width=wrapcol, pad=pad)
 
-def a85decode(b, *, foldspaces=False, adobe=False, ignorechars=b' \t\n\r\v'):
-    """Decode the Ascii85 encoded bytes-like object or ASCII string b.
+def a85decode(s, *, foldspaces=False, adobe=False, ignorechars=b' \t\n\r\v'):
+    """Decode the Ascii85 encoded bytes-like object or ASCII string s.
 
-    foldspaces is a flag that specifies whether the 'y' short sequence should be
-    accepted as shorthand for 4 consecutive spaces (ASCII 0x20). This feature is
-    not supported by the "standard" Adobe encoding.
+    foldspaces is a flag that specifies whether the 'y' short sequence
+    should be accepted as shorthand for 4 consecutive spaces (ASCII 0x20).
+    This feature is not supported by the "standard" Adobe encoding.
 
-    adobe controls whether the input sequence is in Adobe Ascii85 format (i.e.
-    is framed with <~ and ~>).
+    adobe controls whether the input sequence is in Adobe Ascii85 format
+    (i.e. is framed with <~ and ~>).
 
-    ignorechars should be a byte string containing characters to ignore from the
-    input. This should only contain whitespace characters, and by default
+    ignorechars should be a byte string containing characters to ignore from
+    the input. This should only contain whitespace characters, and by default
     contains all whitespace characters in ASCII.
 
     The result is returned as a bytes object.
     """
-    b = _bytes_from_decode_data(b)
-    return binascii.a2b_ascii85(b, fold_spaces=foldspaces,
+    s = _bytes_from_decode_data(s)
+    return binascii.a2b_ascii85(s, fold_spaces=foldspaces,
                                 wrap=adobe, ignore=ignorechars)
 
-def b85encode(b, pad=False):
-    """Encode bytes-like object b in base85 format and return a bytes object.
+def b85encode(s, pad=False):
+    """Encode the bytes-like object s using base85 and return a bytes object.
 
-    If pad is true, the input is padded with b'\\0' so its length is a multiple of
-    4 bytes before encoding.
+    If pad is True, the input is padded with b'\\0' so its length is a
+    multiple of 4 bytes before encoding.
     """
-    return binascii.b2a_base85(b, pad=pad, newline=False)
+    return binascii.b2a_base85(s, pad=pad, newline=False)
 
-def b85decode(b):
-    """Decode the base85-encoded bytes-like object or ASCII string b
+def b85decode(s):
+    """Decode the base85-encoded bytes-like object or ASCII string s.
 
     The result is returned as a bytes object.
     """
-    b = _bytes_from_decode_data(b)
-    return binascii.a2b_base85(b, strict_mode=True)
+    s = _bytes_from_decode_data(s)
+    return binascii.a2b_base85(s, strict_mode=True)
 
 _b85alphabet = (b"0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
                 b"abcdefghijklmnopqrstuvwxyz!#$%&()*+-;<=>?@^_`{|}~")
@@ -363,11 +363,11 @@ def b85decode(b):
 _z85_encode_translation = bytes.maketrans(_b85alphabet, _z85alphabet)
 
 def z85encode(s):
-    """Encode bytes-like object b in z85 format and return a bytes object."""
+    """Encode the bytes-like object s using z85 and return a bytes object."""
     return b85encode(s).translate(_z85_encode_translation)
 
 def z85decode(s):
-    """Decode the z85-encoded bytes-like object or ASCII string b
+    """Decode the z85-encoded bytes-like object or ASCII string s.
 
     The result is returned as a bytes object.
     """