ensure backward compatibility

Author: picnixz

Lib/hashlib.py

@@ -141,18 +141,39 @@ def __get_openssl_constructor(name):
         return __get_builtin_constructor(name)
 
 
-def __py_new(name, data=b'', **kwargs):
+def __data_argument(funcname, data_sentinel, kwargs):
+    if '__data_sentinel' in kwargs:
+        raise TypeError("'__data_sentinel' is not a valid keyword argument")
+    if 'data' in kwargs and 'string' in kwargs:
+        raise TypeError("'data' and 'string' are mutually exclusive "
+                        "and support for 'string' keyword parameter "
+                        "is slated for removal in a future version.")
+    if data_sentinel is None:
+        if 'data' in kwargs:
+            # new(name, data=...)
+            return kwargs.pop('data')
+        elif 'string' in kwargs:
+            # new(name, string=...)
+            return kwargs.pop('string')
+        return b''
+    # new(name, data)
+    return data_sentinel
+
+
+def __py_new(name, __data_sentinel=None, **kwargs):
     """new(name, data=b'', **kwargs) - Return a new hashing object using the
     named algorithm; optionally initialized with data (which must be
     a bytes-like object).
     """
+    data = __data_argument('__py_new', __data_sentinel, kwargs)
     return __get_builtin_constructor(name)(data, **kwargs)
 
 
-def __hash_new(name, data=b'', **kwargs):
+def __hash_new(name, __data_sentinel=None, **kwargs):
     """new(name, data=b'') - Return a new hashing object using the named algorithm;
     optionally initialized with data (which must be a bytes-like object).
     """
+    data = __data_argument('__hash_new', __data_sentinel, kwargs)
     if name in __block_openssl_constructor:
         # Prefer our builtin blake2 implementation.
         return __get_builtin_constructor(name)(data, **kwargs)

Lib/test/test_hashlib.py

@@ -12,6 +12,7 @@
 import itertools
 import logging
 import os
+import re
 import sys
 import sysconfig
 import tempfile
@@ -140,11 +141,12 @@ def __init__(self, *args, **kwargs):
         # of hashlib.new given the algorithm name.
         for algorithm, constructors in self.constructors_to_test.items():
             constructors.add(getattr(hashlib, algorithm))
-            def _test_algorithm_via_hashlib_new(data=None, _alg=algorithm, **kwargs):
-                if data is None:
+            def c(_data=None, _alg=algorithm, **kwargs):
+                if _data is None:
                     return hashlib.new(_alg, **kwargs)
-                return hashlib.new(_alg, data, **kwargs)
-            constructors.add(_test_algorithm_via_hashlib_new)
+                return hashlib.new(_alg, _data, **kwargs)
+            c.__name__ = f'do_test_algorithm_via_hashlib_new_{algorithm}'
+            constructors.add(c)
 
         _hashlib = self._conditional_import_module('_hashlib')
         self._hashlib = _hashlib
@@ -251,8 +253,25 @@ def test_usedforsecurity_false(self):
 
     def test_clinic_signature(self):
         for constructor in self.hash_constructors:
-            with self.subTest(constructor):
+            with self.subTest(constructor.__name__):
                 constructor(data=b'')
+                constructor(string=b'')  # should be deprecated in the future
+
+    def test_clinic_signature_errors(self):
+        conflicting_call = re.escape(
+            "'data' and 'string' are mutually exclusive "
+            "and support for 'string' keyword parameter "
+            "is slated for removal in a future version."
+        )
+        duplicated_param = re.escape("given by name ('data') and position")
+        for constructor in self.hash_constructors:
+            with self.subTest(constructor.__name__):
+                with self.assertRaisesRegex(TypeError, conflicting_call):
+                    constructor(b'', string=b'')
+                with self.assertRaisesRegex(TypeError, conflicting_call):
+                    constructor(data=b'', string=b'')
+            with self.assertRaisesRegex(TypeError, duplicated_param):
+                constructor(b'', data=b'')
 
     def test_unknown_hash(self):
         self.assertRaises(ValueError, hashlib.new, 'spam spam spam spam spam')
@@ -723,7 +742,6 @@ def check_blake2(self, constructor, salt_size, person_size, key_size,
         self.assertRaises(ValueError, constructor, node_offset=-1)
         self.assertRaises(OverflowError, constructor, node_offset=max_offset+1)
 
-        self.assertRaises(TypeError, constructor, string=b'')
         self.assertRaises(TypeError, constructor, '')
 
         constructor(