Merge branch 'main' into core-header-refactor-2

Author: markshannon

Doc/library/pickletools.rst

@@ -19,7 +19,7 @@ ordinary users of the :mod:`pickle` module probably won't find the
 
 .. _pickletools-cli:
 
-Command line usage
+Command-line usage
 ------------------
 
 .. versionadded:: 3.2
@@ -48,7 +48,7 @@ For example, with a tuple ``(1, 2)`` pickled in file ``x.pickle``:
         9: .    STOP
     highest protocol among opcodes = 2
 
-Command line options
+Command-line options
 ^^^^^^^^^^^^^^^^^^^^
 
 .. program:: pickletools
@@ -72,12 +72,16 @@ Command line options
 
 .. option:: -p, --preamble=<preamble>
 
-   When more than one pickle file are specified, print given preamble
+   When more than one pickle file is specified, print given preamble
    before each disassembly.
 
+.. option:: pickle_file
 
+   A pickle file to read, or ``-`` to indicate reading from standard input.
 
-Programmatic Interface
+
+
+Programmatic interface
 ----------------------
 
 

Include/internal/pycore_pystate.h

@@ -52,36 +52,18 @@ extern const PyConfig* _PyInterpreterState_GetConfig(PyInterpreterState *interp)
 
 /* Check if the current thread is the main thread.
    Use _Py_IsMainInterpreter() to check if it's the main interpreter. */
-static inline int
-_Py_IsMainThread(void)
-{
-    unsigned long thread = PyThread_get_thread_ident();
-    return (thread == _PyRuntime.main_thread);
-}
-
+extern int _Py_IsMainThread(void);
 
-static inline PyInterpreterState *
-_PyInterpreterState_Main(void)
-{
-    return _PyRuntime.interpreters.main;
-}
+// Export for '_testinternalcapi' shared extension
+PyAPI_FUNC(PyInterpreterState*) _PyInterpreterState_Main(void);
 
 static inline int
 _Py_IsMainInterpreter(PyInterpreterState *interp)
 {
     return (interp == _PyInterpreterState_Main());
 }
 
-static inline int
-_Py_IsMainInterpreterFinalizing(PyInterpreterState *interp)
-{
-    /* bpo-39877: Access _PyRuntime directly rather than using
-       tstate->interp->runtime to support calls from Python daemon threads.
-       After Py_Finalize() has been called, tstate can be a dangling pointer:
-       point to PyThreadState freed memory. */
-    return (_PyRuntimeState_GetFinalizing(&_PyRuntime) != NULL &&
-            interp == &_PyRuntime._main_interpreter);
-}
+extern int _Py_IsMainInterpreterFinalizing(PyInterpreterState *interp);
 
 // Export for _interpreters module.
 PyAPI_FUNC(PyObject *) _PyInterpreterState_GetIDObject(PyInterpreterState *);
@@ -94,17 +76,7 @@ PyAPI_FUNC(void) _PyErr_SetInterpreterAlreadyRunning(void);
 
 extern int _PyThreadState_IsRunningMain(PyThreadState *);
 extern void _PyInterpreterState_ReinitRunningMain(PyThreadState *);
-
-
-static inline const PyConfig *
-_Py_GetMainConfig(void)
-{
-    PyInterpreterState *interp = _PyInterpreterState_Main();
-    if (interp == NULL) {
-        return NULL;
-    }
-    return _PyInterpreterState_GetConfig(interp);
-}
+extern const PyConfig* _Py_GetMainConfig(void);
 
 
 /* Only handle signals on the main thread of the main interpreter. */

Lib/hmac.py

@@ -65,6 +65,7 @@ def __init__(self, key, msg=None, digestmod=''):
 
     def _init_hmac(self, key, msg, digestmod):
         self._hmac = _hashopenssl.hmac_new(key, msg, digestmod=digestmod)
+        self._inner = self._outer = None  # because the slots are defined
         self.digest_size = self._hmac.digest_size
         self.block_size = self._hmac.block_size
 

Lib/pickletools.py

@@ -2845,7 +2845,7 @@ def __init__(self, value):
         description='disassemble one or more pickle files')
     parser.add_argument(
         'pickle_file',
-        nargs='*', help='the pickle file')
+        nargs='+', help='the pickle file')
     parser.add_argument(
         '-o', '--output',
         help='the file where the output should be written')
@@ -2863,26 +2863,23 @@ def __init__(self, value):
         help='if more than one pickle file is specified, print this before'
         ' each disassembly')
     args = parser.parse_args()
-    if not args.pickle_file:
-        parser.print_help()
+    annotate = 30 if args.annotate else 0
+    memo = {} if args.memo else None
+    if args.output is None:
+        output = sys.stdout
     else:
-        annotate = 30 if args.annotate else 0
-        memo = {} if args.memo else None
-        if args.output is None:
-            output = sys.stdout
-        else:
-            output = open(args.output, 'w')
-        try:
-            for arg in args.pickle_file:
-                if len(args.pickle_file) > 1:
-                    name = '<stdin>' if arg == '-' else arg
-                    preamble = args.preamble.format(name=name)
-                    output.write(preamble + '\n')
-                if arg == '-':
-                    dis(sys.stdin.buffer, output, memo, args.indentlevel, annotate)
-                else:
-                    with open(arg, 'rb') as f:
-                        dis(f, output, memo, args.indentlevel, annotate)
-        finally:
-            if output is not sys.stdout:
-                output.close()
+        output = open(args.output, 'w')
+    try:
+        for arg in args.pickle_file:
+            if len(args.pickle_file) > 1:
+                name = '<stdin>' if arg == '-' else arg
+                preamble = args.preamble.format(name=name)
+                output.write(preamble + '\n')
+            if arg == '-':
+                dis(sys.stdin.buffer, output, memo, args.indentlevel, annotate)
+            else:
+                with open(arg, 'rb') as f:
+                    dis(f, output, memo, args.indentlevel, annotate)
+    finally:
+        if output is not sys.stdout:
+            output.close()

Lib/test/support/hashlib_helper.py

@@ -1,6 +1,7 @@
 import functools
 import hashlib
 import unittest
+from test.support.import_helper import import_module
 
 try:
     import _hashlib
@@ -12,44 +13,81 @@ def requires_hashlib():
     return unittest.skipIf(_hashlib is None, "requires _hashlib")
 
 
+def _decorate_func_or_class(func_or_class, decorator_func):
+    if not isinstance(func_or_class, type):
+        return decorator_func(func_or_class)
+
+    decorated_class = func_or_class
+    setUpClass = decorated_class.__dict__.get('setUpClass')
+    if setUpClass is None:
+        def setUpClass(cls):
+            super(decorated_class, cls).setUpClass()
+        setUpClass.__qualname__ = decorated_class.__qualname__ + '.setUpClass'
+        setUpClass.__module__ = decorated_class.__module__
+    else:
+        setUpClass = setUpClass.__func__
+    setUpClass = classmethod(decorator_func(setUpClass))
+    decorated_class.setUpClass = setUpClass
+    return decorated_class
+
+
 def requires_hashdigest(digestname, openssl=None, usedforsecurity=True):
-    """Decorator raising SkipTest if a hashing algorithm is not available
+    """Decorator raising SkipTest if a hashing algorithm is not available.
 
-    The hashing algorithm could be missing or blocked by a strict crypto
-    policy.
+    The hashing algorithm may be missing, blocked by a strict crypto policy,
+    or Python may be configured with `--with-builtin-hashlib-hashes=no`.
 
     If 'openssl' is True, then the decorator checks that OpenSSL provides
-    the algorithm. Otherwise the check falls back to built-in
-    implementations. The usedforsecurity flag is passed to the constructor.
+    the algorithm. Otherwise the check falls back to (optional) built-in
+    HACL* implementations.
+
+    The usedforsecurity flag is passed to the constructor but has no effect
+    on HACL* implementations.
 
+    Examples of exceptions being suppressed:
     ValueError: [digital envelope routines: EVP_DigestInit_ex] disabled for FIPS
     ValueError: unsupported hash type md4
     """
+    if openssl and _hashlib is not None:
+        def test_availability():
+            _hashlib.new(digestname, usedforsecurity=usedforsecurity)
+    else:
+        def test_availability():
+            hashlib.new(digestname, usedforsecurity=usedforsecurity)
+
+    def decorator_func(func):
+        @functools.wraps(func)
+        def wrapper(*args, **kwargs):
+            try:
+                test_availability()
+            except ValueError as exc:
+                msg = f"missing hash algorithm: {digestname!r}"
+                raise unittest.SkipTest(msg) from exc
+            return func(*args, **kwargs)
+        return wrapper
+
     def decorator(func_or_class):
-        if isinstance(func_or_class, type):
-            setUpClass = func_or_class.__dict__.get('setUpClass')
-            if setUpClass is None:
-                def setUpClass(cls):
-                    super(func_or_class, cls).setUpClass()
-                setUpClass.__qualname__ = func_or_class.__qualname__ + '.setUpClass'
-                setUpClass.__module__ = func_or_class.__module__
-            else:
-                setUpClass = setUpClass.__func__
-            setUpClass = classmethod(decorator(setUpClass))
-            func_or_class.setUpClass = setUpClass
-            return func_or_class
-
-        @functools.wraps(func_or_class)
+        return _decorate_func_or_class(func_or_class, decorator_func)
+    return decorator
+
+
+def requires_openssl_hashdigest(digestname, *, usedforsecurity=True):
+    """Decorator raising SkipTest if an OpenSSL hashing algorithm is missing.
+
+    The hashing algorithm may be missing or blocked by a strict crypto policy.
+    """
+    def decorator_func(func):
+        @requires_hashlib()
+        @functools.wraps(func)
         def wrapper(*args, **kwargs):
             try:
-                if openssl and _hashlib is not None:
-                    _hashlib.new(digestname, usedforsecurity=usedforsecurity)
-                else:
-                    hashlib.new(digestname, usedforsecurity=usedforsecurity)
+                _hashlib.new(digestname, usedforsecurity=usedforsecurity)
             except ValueError:
-                raise unittest.SkipTest(
-                    f"hash digest {digestname!r} is not available."
-                )
-            return func_or_class(*args, **kwargs)
+                msg = f"missing OpenSSL hash algorithm: {digestname!r}"
+                raise unittest.SkipTest(msg)
+            return func(*args, **kwargs)
         return wrapper
+
+    def decorator(func_or_class):
+        return _decorate_func_or_class(func_or_class, decorator_func)
     return decorator