execution count more atomic

drorspei · drorspei · commit aaa5a4562899 · 2025-12-01T18:43:59.000+01:00
diff --git a/IPython/core/displayhook.py b/IPython/core/displayhook.py
@@ -63,7 +63,7 @@ def __init__(self, shell=None, cache_size=1000, **kwargs):
 
     @property
     def prompt_count(self):
-        return self.shell.execution_count
+        return self.shell.execution_count - 1
 
     #-------------------------------------------------------------------------
     # Methods used in __call__. Override these methods to modify the behavior
@@ -127,7 +127,7 @@ def write_output_prompt(self):
         """
         # Use write, not print which adds an extra space.
         sys.stdout.write(self.shell.separate_out)
-        outprompt = 'Out[{}]: '.format(self.shell.execution_count)
+        outprompt = 'Out[{}]: '.format(self.shell.execution_count - 1)
         if self.do_full_cache:
             sys.stdout.write(outprompt)
 
diff --git a/IPython/core/displaypub.py b/IPython/core/displaypub.py
@@ -149,7 +149,7 @@ def publish(
 
         outputs = self.shell.history_manager.outputs
 
-        target_execution_count = self.shell.execution_count
+        target_execution_count = self.shell.execution_count - 1
         if self._in_post_execute:
             # We're in post_execute, so this is likely a matplotlib flush
             # Use execution_count - 1 to associate with the cell that created the plot
diff --git a/IPython/core/interactiveshell.py b/IPython/core/interactiveshell.py
@@ -3046,6 +3046,7 @@ def _tee(self, channel: Literal["stdout", "stderr"]):
         """
         stream = getattr(sys, channel)
         original_write = stream.write
+        execution_count = self.execution_count
 
         def write(data, *args, **kwargs):
             """Write data to both the original destination and the capture dictionary."""
@@ -3060,7 +3061,6 @@ def write(data, *args, **kwargs):
                 return result
             if not data:
                 return result
-            execution_count = self.execution_count
             output_stream = None
             outputs_by_counter = self.history_manager.outputs
             output_type = "out_stream" if channel == "stdout" else "err_stream"
@@ -3293,17 +3293,18 @@ async def run_cell_async(
         if silent:
             store_history = False
 
+        execution_count = result.execution_count = self.execution_count
+
         if store_history:
-            result.execution_count = self.execution_count
+            self.execution_count += 1
 
         def error_before_exec(value):
             if store_history:
                 if self.history_manager:
                     # Store formatted traceback and error details
                     self.history_manager.exceptions[
-                        self.execution_count
+                        execution_count
                     ] = self._format_exception_for_storage(value)
-                self.execution_count += 1
             result.error_before_exec = value
             self.last_execution_succeeded = False
             self.last_execution_result = result
@@ -3348,15 +3349,13 @@ def error_before_exec(value):
         # Store raw and processed history
         if store_history:
             assert self.history_manager is not None
-            self.history_manager.store_inputs(self.execution_count, cell, raw_cell)
+            self.history_manager.store_inputs(execution_count, cell, raw_cell)
         if not silent:
             self.logger.log(cell, raw_cell)
 
         # Display the exception if input processing failed.
         if preprocessing_exc_tuple is not None:
             self.showtraceback(preprocessing_exc_tuple)
-            if store_history:
-                self.execution_count += 1
             return error_before_exec(preprocessing_exc_tuple[1])
 
         # Our own compiler remembers the __future__ environment. If we want to
@@ -3365,7 +3364,7 @@ def error_before_exec(value):
         compiler = self.compile if shell_futures else self.compiler_class()
 
         with self.builtin_trap:
-            cell_name = compiler.cache(cell, self.execution_count, raw_code=raw_cell)
+            cell_name = compiler.cache(cell, execution_count, raw_code=raw_cell)
 
             with self.display_trap:
                 # Compile to bytecode
@@ -3412,17 +3411,13 @@ def error_before_exec(value):
             assert self.history_manager is not None
             # Write output to the database. Does nothing unless
             # history output logging is enabled.
-            self.history_manager.store_output(self.execution_count)
-            exec_count = self.execution_count
+            self.history_manager.store_output(execution_count)
             if result.error_in_exec:
                 # Store formatted traceback and error details
                 self.history_manager.exceptions[
-                    exec_count
+                    execution_count
                 ] = self._format_exception_for_storage(result.error_in_exec)
 
-            # Each cell is a *single* input, regardless of how many lines it has
-            self.execution_count += 1
-
         return result
 
     def _format_exception_for_storage(
diff --git a/IPython/terminal/prompts.py b/IPython/terminal/prompts.py
@@ -87,7 +87,7 @@ def rewrite_prompt_tokens(self):
     def out_prompt_tokens(self):
         return [
             (Token.OutPrompt, 'Out['),
-            (Token.OutPromptNum, str(self.shell.execution_count)),
+            (Token.OutPromptNum, str(self.shell.execution_count - 1)),
             (Token.OutPrompt, ']: '),
         ]
 
diff --git a/tests/test_history.py b/tests/test_history.py
@@ -375,3 +375,29 @@ def test_get_tail_session_awareness(hmmax3):
                 hm2.db.close()
             if ha:
                 ha.db.close()
+
+
+def test_calling_run_cell(hmmax2):
+    ip = get_ipython()
+    with TemporaryDirectory() as tmpdir:
+        tmp_path = Path(tmpdir)
+        hist_manager_ori = ip.history_manager
+        hist_file = tmp_path / "history_test_history1.sqlite"
+        try:
+            ip.history_manager = HistoryManager(shell=ip, hist_file=hist_file)
+            import time
+    
+            session_number = ip.history_manager.session_number
+            ip.run_cell(raw_cell="get_ipython().run_cell(raw_cell='1', store_history=True)", store_history=True)
+            while ip.history_manager.db_input_cache:
+                time.sleep(0)
+            new_session_number = ip.history_manager.session_number
+        finally:
+            # Ensure saving thread is shut down before we try to clean up the files
+            ip.history_manager.end_session()
+            # Forcibly close database rather than relying on garbage collection
+            ip.history_manager.save_thread.stop()
+            ip.history_manager.db.close()
+
+            ip.history_manager = hist_manager_ori
+    assert session_number == new_session_number, ValueError(f"{session_number} != {new_session_number}")

Original file line number	Diff line number	Diff line change
`@@ -87,7 +87,7 @@ def rewrite_prompt_tokens(self):`
`87`	`87`	`def out_prompt_tokens(self):`
`88`	`88`	`return [`
`89`	`89`	`(Token.OutPrompt, 'Out['),`
`90`		`- (Token.OutPromptNum, str(self.shell.execution_count)),`
	`90`	`+ (Token.OutPromptNum, str(self.shell.execution_count - 1)),`
`91`	`91`	`(Token.OutPrompt, ']: '),`
`92`	`92`	`]`
`93`	`93`