Address review comments

Author: markshannon

Lib/test/test_compile.py

@@ -721,8 +721,7 @@ def check_limit(prefix, repeated, mode="single"):
             expect_ok = prefix + repeated * success_depth
             compile(expect_ok, '<test>', mode)
             broken = prefix + repeated * crash_depth
-            details = "Compiling ({!r} + {!r} * {})".format(
-                        prefix, repeated, crash_depth)
+            details = f"Compiling ({prefix!r} + {repeated!r} * {crash_depth})"
             with self.assertRaises(RecursionError, msg=details):
                 compile(broken, '<test>', mode)
 

Lib/test/test_dynamic.py

@@ -4,7 +4,7 @@
 import sys
 import unittest
 
-from test.support import swap_item, swap_attr, is_wasi, Py_DEBUG
+from test.support import swap_item, swap_attr, skip_wasi_stack_overflow, Py_DEBUG
 
 
 class RebindBuiltinsTests(unittest.TestCase):
@@ -134,7 +134,8 @@ def test_eval_gives_lambda_custom_globals(self):
 
         self.assertEqual(foo(), 7)
 
-    @unittest.skipIf(is_wasi, "requires too much stack")
+
+    @skip_wasi_stack_overflow()
     def test_load_global_specialization_failure_keeps_oparg(self):
         # https://github.com/python/cpython/issues/91625
         class MyGlobals(dict):

Lib/test/test_json/test_recursion.py

@@ -70,17 +70,18 @@ def default(self, o):
 
     @support.skip_emscripten_stack_overflow()
     def test_highly_nested_objects_decoding(self):
+        very_deep = 200000
         # test that loading highly-nested objects doesn't segfault when C
         # accelerations are used. See #12017
         with self.assertRaises(RecursionError):
             with support.infinite_recursion():
-                self.loads('{"a":' * 200000 + '1' + '}' * 200000)
+                self.loads('{"a":' * very_deep + '1' + '}' * very_deep)
         with self.assertRaises(RecursionError):
             with support.infinite_recursion():
-                self.loads('{"a":' * 200000 + '[1]' + '}' * 200000)
+                self.loads('{"a":' * very_deep + '[1]' + '}' * very_deep)
         with self.assertRaises(RecursionError):
             with support.infinite_recursion():
-                self.loads('[' * 200000 + '1' + ']' * 200000)
+                self.loads('[' * very_deep + '1' + ']' * very_deep)
 
     @support.skip_wasi_stack_overflow()
     @support.skip_emscripten_stack_overflow()

Misc/NEWS.d/next/Core_and_Builtins/2025-02-21-11-12-41.gh-issue-130396.SIenSP.rst

@@ -1,3 +1,3 @@
-Use actual stack limits (from pthread_getattr_np) for linux, and other
-systems with _GNU_SOURCE defined, when determining limits for C stack
+Use actual stack limits (from  :manpage:`pthread_getattr_np(3)`) for linux, and other
+systems with ``_GNU_SOURCE`` defined, when determining limits for C stack
 protection.

Python/ceval.c

@@ -364,9 +364,11 @@ _Py_InitializeRecursionLimits(PyThreadState *tstate)
     void *stack_addr;
     pthread_attr_t attr;
     int err = pthread_getattr_np(pthread_self(), &attr);
-    err |= pthread_attr_getguardsize(&attr, &guard_size);
-    err |= pthread_attr_getstack(&attr, &stack_addr, &stack_size);
-    err |= pthread_attr_destroy(&attr);
+    if (err == 0) {
+        err = pthread_attr_getguardsize(&attr, &guard_size);
+        err |= pthread_attr_getstack(&attr, &stack_addr, &stack_size);
+        err |= pthread_attr_destroy(&attr);
+    }
     if (err == 0) {
         uintptr_t base = ((uintptr_t)stack_addr) + guard_size;
         _tstate->c_stack_top = base + stack_size;