Supress stdin to not leave things hanging

pablogsal · pablogsal · commit 1543ce5e30f4 · 2025-11-18T01:09:56.000Z
diff --git a/Lib/profiling/sampling/live_collector/collector.py b/Lib/profiling/sampling/live_collector/collector.py
@@ -3,6 +3,7 @@
 import collections
 import contextlib
 import curses
+from dataclasses import dataclass, field
 import os
 import site
 import sys
@@ -43,6 +44,29 @@
 from .widgets import HeaderWidget, TableWidget, FooterWidget, HelpWidget
 
 
+@dataclass
+class ThreadData:
+    """Encapsulates all profiling data for a single thread."""
+
+    thread_id: int
+
+    # Function call statistics: {location: {direct_calls: int, cumulative_calls: int}}
+    result: dict = field(default_factory=lambda: collections.defaultdict(
+        lambda: dict(direct_calls=0, cumulative_calls=0)
+    ))
+
+    # Thread status statistics
+    has_gil: int = 0
+    on_cpu: int = 0
+    gil_requested: int = 0
+    unknown: int = 0
+    total: int = 0  # Total status samples for this thread
+
+    # Sample counts
+    sample_count: int = 0
+    gc_frame_samples: int = 0
+
+
 class LiveStatsCollector(Collector):
     """Collector that displays live top-like statistics using ncurses."""
 
@@ -118,10 +142,7 @@ def __init__(
         self.current_thread_index = (
             0  # Index into thread_ids when in PER_THREAD mode
         )
-        self.per_thread_result = {}  # {thread_id: {func: {direct_calls, cumulative_calls}}}
-        self.per_thread_status = {}  # {thread_id: {has_gil: count, on_cpu: count, ...}}
-        self.per_thread_samples = {}  # {thread_id: sample_count}
-        self.per_thread_gc_samples = {}  # {thread_id: gc_frame_sample_count}
+        self.per_thread_data = {}  # {thread_id: ThreadData}
 
         # Calculate common path prefixes to strip
         self._path_prefixes = self._get_common_path_prefixes()
@@ -201,15 +222,9 @@ def _process_frames(self, frames, thread_id=None):
 
             # Also track per-thread if thread_id is provided
             if thread_id is not None:
-                if thread_id not in self.per_thread_result:
-                    self.per_thread_result[thread_id] = (
-                        collections.defaultdict(
-                            lambda: dict(direct_calls=0, cumulative_calls=0)
-                        )
-                    )
-                self.per_thread_result[thread_id][location][
-                    "cumulative_calls"
-                ] += 1
+                if thread_id not in self.per_thread_data:
+                    self.per_thread_data[thread_id] = ThreadData(thread_id=thread_id)
+                self.per_thread_data[thread_id].result[location]["cumulative_calls"] += 1
 
         # The top frame gets counted as an inline call (directly executing)
         top_location = (
@@ -221,13 +236,9 @@ def _process_frames(self, frames, thread_id=None):
 
         # Also track per-thread
         if thread_id is not None:
-            if thread_id not in self.per_thread_result:
-                self.per_thread_result[thread_id] = collections.defaultdict(
-                    lambda: dict(direct_calls=0, cumulative_calls=0)
-                )
-            self.per_thread_result[thread_id][top_location][
-                "direct_calls"
-            ] += 1
+            if thread_id not in self.per_thread_data:
+                self.per_thread_data[thread_id] = ThreadData(thread_id=thread_id)
+            self.per_thread_data[thread_id].result[top_location]["direct_calls"] += 1
 
     def collect_failed_sample(self):
         self._failed_samples += 1
@@ -260,47 +271,31 @@ def collect(self, stack_frames):
                 status_flags = getattr(thread_info, "status", 0)
                 thread_id = getattr(thread_info, "thread_id", None)
 
-                # Initialize per-thread status tracking
-                if (
-                    thread_id is not None
-                    and thread_id not in self.per_thread_status
-                ):
-                    self.per_thread_status[thread_id] = {
-                        "has_gil": 0,
-                        "on_cpu": 0,
-                        "gil_requested": 0,
-                        "unknown": 0,
-                        "total": 0,
-                    }
+                # Initialize per-thread data if needed
+                if thread_id is not None and thread_id not in self.per_thread_data:
+                    self.per_thread_data[thread_id] = ThreadData(thread_id=thread_id)
 
                 # Update aggregated counts
                 if status_flags & THREAD_STATUS_HAS_GIL:
                     temp_status_counts["has_gil"] += 1
                     if thread_id is not None:
-                        self.per_thread_status[thread_id]["has_gil"] += 1
+                        self.per_thread_data[thread_id].has_gil += 1
                 if status_flags & THREAD_STATUS_ON_CPU:
                     temp_status_counts["on_cpu"] += 1
                     if thread_id is not None:
-                        self.per_thread_status[thread_id]["on_cpu"] += 1
+                        self.per_thread_data[thread_id].on_cpu += 1
                 if status_flags & THREAD_STATUS_GIL_REQUESTED:
                     temp_status_counts["gil_requested"] += 1
                     if thread_id is not None:
-                        self.per_thread_status[thread_id]["gil_requested"] += 1
+                        self.per_thread_data[thread_id].gil_requested += 1
                 if status_flags & THREAD_STATUS_UNKNOWN:
                     temp_status_counts["unknown"] += 1
                     if thread_id is not None:
-                        self.per_thread_status[thread_id]["unknown"] += 1
+                        self.per_thread_data[thread_id].unknown += 1
 
                 # Update per-thread total count
                 if thread_id is not None:
-                    self.per_thread_status[thread_id]["total"] += 1
-
-                # Initialize per-thread sample tracking
-                if thread_id is not None:
-                    if thread_id not in self.per_thread_samples:
-                        self.per_thread_samples[thread_id] = 0
-                    if thread_id not in self.per_thread_gc_samples:
-                        self.per_thread_gc_samples[thread_id] = 0
+                    self.per_thread_data[thread_id].total += 1
 
                 # Process frames (respecting skip_idle)
                 if self.skip_idle:
@@ -322,7 +317,7 @@ def collect(self, stack_frames):
 
                     # Increment per-thread sample count
                     if thread_id is not None:
-                        self.per_thread_samples[thread_id] += 1
+                        self.per_thread_data[thread_id].sample_count += 1
 
                     # Check if any frame is in GC
                     thread_has_gc_frame = False
@@ -335,7 +330,7 @@ def collect(self, stack_frames):
 
                     # Track per-thread GC samples
                     if thread_has_gc_frame and thread_id is not None:
-                        self.per_thread_gc_samples[thread_id] += 1
+                        self.per_thread_data[thread_id].gc_frame_samples += 1
 
         # Update cumulative thread status counts
         for key, count in temp_status_counts.items():
@@ -582,7 +577,10 @@ def _build_stats_list(self):
             # PER_THREAD mode - use specific thread result
             if self.current_thread_index < len(self.thread_ids):
                 thread_id = self.thread_ids[self.current_thread_index]
-                result_source = self.per_thread_result.get(thread_id, {})
+                if thread_id in self.per_thread_data:
+                    result_source = self.per_thread_data[thread_id].result
+                else:
+                    result_source = {}
             else:
                 result_source = self.result
 
@@ -648,10 +646,7 @@ def _build_stats_list(self):
     def reset_stats(self):
         """Reset all collected statistics."""
         self.result.clear()
-        self.per_thread_result.clear()
-        self.per_thread_status.clear()
-        self.per_thread_samples.clear()
-        self.per_thread_gc_samples.clear()
+        self.per_thread_data.clear()
         self.thread_ids.clear()
         self.view_mode = "ALL"
         self.current_thread_index = 0
diff --git a/Lib/profiling/sampling/live_collector/widgets.py b/Lib/profiling/sampling/live_collector/widgets.py
@@ -391,8 +391,15 @@ def draw_thread_status(self, line, width):
                 thread_id = self.collector.thread_ids[
                     self.collector.current_thread_index
                 ]
-                if thread_id in self.collector.per_thread_status:
-                    status_counts = self.collector.per_thread_status[thread_id]
+                if thread_id in self.collector.per_thread_data:
+                    thread_data = self.collector.per_thread_data[thread_id]
+                    status_counts = {
+                        "has_gil": thread_data.has_gil,
+                        "on_cpu": thread_data.on_cpu,
+                        "gil_requested": thread_data.gil_requested,
+                        "unknown": thread_data.unknown,
+                        "total": thread_data.total,
+                    }
                 else:
                     status_counts = self.collector._thread_status_counts
             else:
@@ -420,12 +427,13 @@ def draw_thread_status(self, line, width):
                 thread_id = self.collector.thread_ids[
                     self.collector.current_thread_index
                 ]
-                thread_samples = self.collector.per_thread_samples.get(
-                    thread_id, 1
-                )
-                thread_gc_samples = self.collector.per_thread_gc_samples.get(
-                    thread_id, 0
-                )
+                if thread_id in self.collector.per_thread_data:
+                    thread_data = self.collector.per_thread_data[thread_id]
+                    thread_samples = thread_data.sample_count
+                    thread_gc_samples = thread_data.gc_frame_samples
+                else:
+                    thread_samples = 1
+                    thread_gc_samples = 0
                 total_samples = max(1, thread_samples)
                 pct_gc = (thread_gc_samples / total_samples) * 100
             else:
@@ -485,7 +493,10 @@ def draw_function_stats(self, line, width, stats_list):
         if self.collector.view_mode == "PER_THREAD" and len(self.collector.thread_ids) > 0:
             if self.collector.current_thread_index < len(self.collector.thread_ids):
                 thread_id = self.collector.thread_ids[self.collector.current_thread_index]
-                result_set = self.collector.per_thread_result.get(thread_id, {})
+                if thread_id in self.collector.per_thread_data:
+                    result_set = self.collector.per_thread_data[thread_id].result
+                else:
+                    result_set = {}
             else:
                 result_set = self.collector.result
         else:
diff --git a/Lib/profiling/sampling/sample.py b/Lib/profiling/sampling/sample.py
@@ -127,6 +127,7 @@ def _run_with_sync(original_cmd, suppress_output=False):
         # Suppress stdout/stderr if requested (for live mode)
         popen_kwargs = {}
         if suppress_output:
+            popen_kwargs['stdin'] = subprocess.DEVNULL
             popen_kwargs['stdout'] = subprocess.DEVNULL
             popen_kwargs['stderr'] = subprocess.DEVNULL
 
diff --git a/Lib/test/test_profiling/test_live_collector_core.py b/Lib/test/test_profiling/test_live_collector_core.py
@@ -120,12 +120,12 @@ def test_process_frames_with_thread_id(self):
         self.assertEqual(collector.result[location]["cumulative_calls"], 1)
 
         # Check per-thread result
-        self.assertIn(123, collector.per_thread_result)
+        self.assertIn(123, collector.per_thread_data)
         self.assertEqual(
-            collector.per_thread_result[123][location]["direct_calls"], 1
+            collector.per_thread_data[123].result[location]["direct_calls"], 1
         )
         self.assertEqual(
-            collector.per_thread_result[123][location]["cumulative_calls"], 1
+            collector.per_thread_data[123].result[location]["cumulative_calls"], 1
         )
 
     def test_process_frames_multiple_threads(self):
@@ -139,23 +139,23 @@ def test_process_frames_multiple_threads(self):
         collector._process_frames(frames2, thread_id=456)
 
         # Check that both threads have their own data
-        self.assertIn(123, collector.per_thread_result)
-        self.assertIn(456, collector.per_thread_result)
+        self.assertIn(123, collector.per_thread_data)
+        self.assertIn(456, collector.per_thread_data)
 
         loc1 = ("test.py", 10, "test_func")
         loc2 = ("test.py", 20, "other_func")
 
         # Thread 123 should only have func1
         self.assertEqual(
-            collector.per_thread_result[123][loc1]["direct_calls"], 1
+            collector.per_thread_data[123].result[loc1]["direct_calls"], 1
         )
-        self.assertNotIn(loc2, collector.per_thread_result[123])
+        self.assertNotIn(loc2, collector.per_thread_data[123].result)
 
         # Thread 456 should only have func2
         self.assertEqual(
-            collector.per_thread_result[456][loc2]["direct_calls"], 1
+            collector.per_thread_data[456].result[loc2]["direct_calls"], 1
         )
-        self.assertNotIn(loc1, collector.per_thread_result[456])
+        self.assertNotIn(loc1, collector.per_thread_data[456].result)
 
 
 class TestLiveStatsCollectorCollect(unittest.TestCase):
diff --git a/Lib/test/test_profiling/test_live_collector_interaction.py b/Lib/test/test_profiling/test_live_collector_interaction.py
