pydblclick 0.2.0__tar.gz

pydblclick-0.2.0/LICENSE.md

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 TsKyrk
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

pydblclick-0.2.0/PKG-INFO

@@ -0,0 +1,200 @@
+Metadata-Version: 2.4
+Name: pydblclick
+Version: 0.2.0
+Summary: Enhances the user experience of Python scripts run via double-click on Windows
+Author: TsKyrk
+License-Expression: MIT
+Project-URL: Repository, https://github.com/TsKyrk/pydblclick
+Keywords: windows,launcher,wrapper,double-click,console
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Programming Language :: Python :: 3
+Classifier: Environment :: Console
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE.md
+Provides-Extra: dev
+Requires-Dist: pytest; extra == "dev"
+Dynamic: license-file
+
+# What is pydblclick ?
+
+*(formerly known as **pyexewrap** — renamed before the first PyPI release, since the old
+name referenced the deprecated `py.exe` launcher and suggested exe-building tools)*
+
+pydblclick makes Python scripts pleasant to run **by double-click** on Windows — for you,
+your colleagues, or anyone you share a one-file script with:
+
+- The console window **never flashes away**: a pause prompt appears at the end of the
+  script, *including* when an exception occurs (even a syntax error), so the traceback
+  is always readable.
+- Scripts that declare their dependencies inline ([PEP 723](https://peps.python.org/pep-0723/))
+  are executed through [uv](https://docs.astral.sh/uv/): **dependencies are resolved
+  automatically** in an ephemeral environment — the recipient never manages venvs or
+  `pip install`.
+- An interactive menu at the pause prompt: `<i>` opens a Python console **with the
+  script's real variables** (post-mortem debugging), `<c>` opens a cmd console,
+  `<r>` restarts the script.
+- `.pyw` (windowed) scripts run with **no console at all** (they are registered with
+  `pythonw.exe`) — but if they crash, a console is created on the spot showing the
+  script's output and the traceback, instead of dying silently.
+- When a script is run from a console, called by another script or a batch file,
+  pydblclick stays out of the way: no pause, exit codes and arguments faithfully
+  propagated.
+
+## Python's native problems for Windows users
+
+- A double-clicked `.py` file pops a console that flashes away, unless the last line is
+  a blocking `input()` — and even then, any exception (a syntax error, a missing module)
+  skips that line and the window vanishes before the traceback can be read.
+- That blocking `input()` becomes undesirable when the same script is run from a console
+  or called by another script.
+- A `.pyw` script that crashes dies silently: there is no console to show the traceback.
+- Sharing a script that needs `requests` or `pandas` means asking the recipient to
+  understand pip, venvs, and PATH — or it just crashes with `ModuleNotFoundError`.
+
+# Installation
+
+```commandline
+pip install <path-to-this-repo>       (PyPI package coming soon)
+pydblclick register
+```
+
+`pydblclick register` sets pydblclick as the default handler for `.py`/`.pyw` double-clicks
+using the standard Windows mechanism (ProgID + UserChoice). This works on **all** Python
+installations — classic installer *and* MSIX Python Manager (see
+[MSIX_COMPATIBILITY.md](MSIX_COMPATIBILITY.md)). A backup of the previous file
+associations is saved automatically before any change.
+
+To undo everything:
+
+```commandline
+pydblclick unregister
+```
+
+To inspect the Windows file association chain (and detect MSIX interference):
+
+```commandline
+pydblclick diagnose
+```
+
+For automatic dependency resolution (PEP 723 scripts), also install
+[uv](https://docs.astral.sh/uv/getting-started/installation/). Without uv, PEP 723
+scripts still run with plain Python, and a message explains what to install.
+
+# Usage
+
+## Double-click (the main purpose)
+
+Once registered, **every** `.py`/`.pyw` file you double-click runs enhanced. Nothing to
+add to the scripts themselves. Try the scripts in the [examples](examples/) folder.
+
+## Sharing dependency-aware one-file scripts (PEP 723 + uv)
+
+Declare dependencies at the top of the script, in standard PEP 723 format:
+
+```python
+# /// script
+# requires-python = ">=3.11"
+# dependencies = ["requests", "rich"]
+# ///
+import requests
+...
+```
+
+On a machine with pydblclick + uv, double-clicking this file "just works": uv resolves
+the dependencies in an ephemeral environment, and pydblclick keeps the window open with
+its usual menu. This is a standard format — the same file also runs with `uv run` alone
+on any platform. Use `uv add --script myscript.py requests` to maintain the block.
+
+## Opting a script out
+
+Add this comment anywhere in a script to make pydblclick step aside (plain Python
+behavior, no pause):
+
+```python
+# pydblclick: off
+```
+
+## Pause only on error
+
+To make an individual script skip the final pause *unless an exception occurred*:
+
+```python
+pydblclick_customizations['must_pause_in_console'] = False
+```
+
+## Command line
+
+`pydblclick <script.py> [args...]` (or `python -m pydblclick <script.py> [args...]`) wraps
+a script explicitly. In a console there is no pause; set the
+`pydblclick_simulate_doubleclick` env var to force double-click behavior (useful in
+batch files and tests).
+
+## Custom icons
+
+Scripts launched via pydblclick show the registered Python icon. For a custom icon,
+create a shortcut to the script (ALT+drag & drop) and set the icon in its properties.
+
+# How it works
+
+Two processes (see [CLAUDE.md](CLAUDE.md) architecture notes and [ROADMAP.md](ROADMAP.md)):
+
+- a thin **parent supervisor** (`python -m pydblclick`) which guarantees the window
+  survives anything — even `os._exit()`, a native crash, or a script that closes stdin;
+- a **child engine** (`python -m pydblclick._child`) which runs your script with exact
+  plain-Python semantics (`runpy`), shows clean tracebacks (no wrapper frames), and
+  owns the pause menu. For PEP 723 scripts the child runs inside the uv-provisioned
+  environment.
+
+No monkey-patching, no code injection: `__name__`, `__file__`, `sys.argv`, exit codes
+and `exit()`/`quit()` behave exactly as with plain Python.
+
+# Legacy: the shebang method (deprecated)
+
+Before the 2026 pivot (under the project's former name *pyexewrap*), scripts were enhanced
+individually with a shebang line (`#!/usr/bin/env python -m pydblclick`) read by the classic
+`py.exe` launcher, and installation went through a system-wide PYTHONPATH (the helper scripts
+have since been removed). This mechanism **still works on classic-installer systems**
+provided pydblclick is importable by the system Python (`pip install` does that), but it is
+a dead end:
+
+- the classic `py.exe` launcher is deprecated since Python 3.14 and will not be produced
+  for Python 3.16+;
+- the MSIX Python Manager (Microsoft Store / "Python Install Manager" on python.org)
+  never reads shebangs on double-click, and its shebang support
+  [does not allow arguments](https://docs.python.org/3/using/windows.html) such as
+  `-m pydblclick`.
+
+Use `pydblclick register` instead; per-script granularity is provided by the
+`# pydblclick: off` directive. See [MSIX_COMPATIBILITY.md](MSIX_COMPATIBILITY.md) for the
+full compatibility matrix and history.
+
+# Compatibility with the MSIX Python Manager (python/pymanager)
+
+The `PythonSoftwareFoundation.PythonManager` MSIX package intercepts `.py`/`.pyw`
+double-clicks through Windows App Model activation, bypassing shebangs and registry
+ftype settings. **`pydblclick register` works with it**: the MSIX launcher honors
+UserChoice pointing to the `pydblclick.PyFile` ProgID (confirmed by testing).
+
+If double-clicks don't reach pydblclick, run `pydblclick diagnose` — it detects MSIX
+interference and tells you what to fix. Details in
+[MSIX_COMPATIBILITY.md](MSIX_COMPATIBILITY.md).
+
+# Note about py.exe
+
+`py.exe` was the Windows wrapper for multiple Python interpreters, making pydblclick a
+wrapper of a wrapper. Its pymanager successor confirms that launcher-level wrapping is
+not extensible — which is why pydblclick now registers itself as the file handler, the
+one mechanism every launcher must respect.
+
+# Todos
+
+- Publish to PyPI (`pip install pydblclick`)
+- Standalone `pydblclick.exe` handler (no Python required to bootstrap; uv can even
+  provision Python itself)
+- Offer to install uv when a PEP 723 script is double-clicked and uv is missing
+- Context menu items "Run with pydblclick" / "Bypass pydblclick"
+
+# Contributions
+
+Your contributions would be greatly appreciated. Feel free to copy the project.

pydblclick-0.2.0/README.md

@@ -0,0 +1,182 @@
+# What is pydblclick ?
+
+*(formerly known as **pyexewrap** — renamed before the first PyPI release, since the old
+name referenced the deprecated `py.exe` launcher and suggested exe-building tools)*
+
+pydblclick makes Python scripts pleasant to run **by double-click** on Windows — for you,
+your colleagues, or anyone you share a one-file script with:
+
+- The console window **never flashes away**: a pause prompt appears at the end of the
+  script, *including* when an exception occurs (even a syntax error), so the traceback
+  is always readable.
+- Scripts that declare their dependencies inline ([PEP 723](https://peps.python.org/pep-0723/))
+  are executed through [uv](https://docs.astral.sh/uv/): **dependencies are resolved
+  automatically** in an ephemeral environment — the recipient never manages venvs or
+  `pip install`.
+- An interactive menu at the pause prompt: `<i>` opens a Python console **with the
+  script's real variables** (post-mortem debugging), `<c>` opens a cmd console,
+  `<r>` restarts the script.
+- `.pyw` (windowed) scripts run with **no console at all** (they are registered with
+  `pythonw.exe`) — but if they crash, a console is created on the spot showing the
+  script's output and the traceback, instead of dying silently.
+- When a script is run from a console, called by another script or a batch file,
+  pydblclick stays out of the way: no pause, exit codes and arguments faithfully
+  propagated.
+
+## Python's native problems for Windows users
+
+- A double-clicked `.py` file pops a console that flashes away, unless the last line is
+  a blocking `input()` — and even then, any exception (a syntax error, a missing module)
+  skips that line and the window vanishes before the traceback can be read.
+- That blocking `input()` becomes undesirable when the same script is run from a console
+  or called by another script.
+- A `.pyw` script that crashes dies silently: there is no console to show the traceback.
+- Sharing a script that needs `requests` or `pandas` means asking the recipient to
+  understand pip, venvs, and PATH — or it just crashes with `ModuleNotFoundError`.
+
+# Installation
+
+```commandline
+pip install <path-to-this-repo>       (PyPI package coming soon)
+pydblclick register
+```
+
+`pydblclick register` sets pydblclick as the default handler for `.py`/`.pyw` double-clicks
+using the standard Windows mechanism (ProgID + UserChoice). This works on **all** Python
+installations — classic installer *and* MSIX Python Manager (see
+[MSIX_COMPATIBILITY.md](MSIX_COMPATIBILITY.md)). A backup of the previous file
+associations is saved automatically before any change.
+
+To undo everything:
+
+```commandline
+pydblclick unregister
+```
+
+To inspect the Windows file association chain (and detect MSIX interference):
+
+```commandline
+pydblclick diagnose
+```
+
+For automatic dependency resolution (PEP 723 scripts), also install
+[uv](https://docs.astral.sh/uv/getting-started/installation/). Without uv, PEP 723
+scripts still run with plain Python, and a message explains what to install.
+
+# Usage
+
+## Double-click (the main purpose)
+
+Once registered, **every** `.py`/`.pyw` file you double-click runs enhanced. Nothing to
+add to the scripts themselves. Try the scripts in the [examples](examples/) folder.
+
+## Sharing dependency-aware one-file scripts (PEP 723 + uv)
+
+Declare dependencies at the top of the script, in standard PEP 723 format:
+
+```python
+# /// script
+# requires-python = ">=3.11"
+# dependencies = ["requests", "rich"]
+# ///
+import requests
+...
+```
+
+On a machine with pydblclick + uv, double-clicking this file "just works": uv resolves
+the dependencies in an ephemeral environment, and pydblclick keeps the window open with
+its usual menu. This is a standard format — the same file also runs with `uv run` alone
+on any platform. Use `uv add --script myscript.py requests` to maintain the block.
+
+## Opting a script out
+
+Add this comment anywhere in a script to make pydblclick step aside (plain Python
+behavior, no pause):
+
+```python
+# pydblclick: off
+```
+
+## Pause only on error
+
+To make an individual script skip the final pause *unless an exception occurred*:
+
+```python
+pydblclick_customizations['must_pause_in_console'] = False
+```
+
+## Command line
+
+`pydblclick <script.py> [args...]` (or `python -m pydblclick <script.py> [args...]`) wraps
+a script explicitly. In a console there is no pause; set the
+`pydblclick_simulate_doubleclick` env var to force double-click behavior (useful in
+batch files and tests).
+
+## Custom icons
+
+Scripts launched via pydblclick show the registered Python icon. For a custom icon,
+create a shortcut to the script (ALT+drag & drop) and set the icon in its properties.
+
+# How it works
+
+Two processes (see [CLAUDE.md](CLAUDE.md) architecture notes and [ROADMAP.md](ROADMAP.md)):
+
+- a thin **parent supervisor** (`python -m pydblclick`) which guarantees the window
+  survives anything — even `os._exit()`, a native crash, or a script that closes stdin;
+- a **child engine** (`python -m pydblclick._child`) which runs your script with exact
+  plain-Python semantics (`runpy`), shows clean tracebacks (no wrapper frames), and
+  owns the pause menu. For PEP 723 scripts the child runs inside the uv-provisioned
+  environment.
+
+No monkey-patching, no code injection: `__name__`, `__file__`, `sys.argv`, exit codes
+and `exit()`/`quit()` behave exactly as with plain Python.
+
+# Legacy: the shebang method (deprecated)
+
+Before the 2026 pivot (under the project's former name *pyexewrap*), scripts were enhanced
+individually with a shebang line (`#!/usr/bin/env python -m pydblclick`) read by the classic
+`py.exe` launcher, and installation went through a system-wide PYTHONPATH (the helper scripts
+have since been removed). This mechanism **still works on classic-installer systems**
+provided pydblclick is importable by the system Python (`pip install` does that), but it is
+a dead end:
+
+- the classic `py.exe` launcher is deprecated since Python 3.14 and will not be produced
+  for Python 3.16+;
+- the MSIX Python Manager (Microsoft Store / "Python Install Manager" on python.org)
+  never reads shebangs on double-click, and its shebang support
+  [does not allow arguments](https://docs.python.org/3/using/windows.html) such as
+  `-m pydblclick`.
+
+Use `pydblclick register` instead; per-script granularity is provided by the
+`# pydblclick: off` directive. See [MSIX_COMPATIBILITY.md](MSIX_COMPATIBILITY.md) for the
+full compatibility matrix and history.
+
+# Compatibility with the MSIX Python Manager (python/pymanager)
+
+The `PythonSoftwareFoundation.PythonManager` MSIX package intercepts `.py`/`.pyw`
+double-clicks through Windows App Model activation, bypassing shebangs and registry
+ftype settings. **`pydblclick register` works with it**: the MSIX launcher honors
+UserChoice pointing to the `pydblclick.PyFile` ProgID (confirmed by testing).
+
+If double-clicks don't reach pydblclick, run `pydblclick diagnose` — it detects MSIX
+interference and tells you what to fix. Details in
+[MSIX_COMPATIBILITY.md](MSIX_COMPATIBILITY.md).
+
+# Note about py.exe
+
+`py.exe` was the Windows wrapper for multiple Python interpreters, making pydblclick a
+wrapper of a wrapper. Its pymanager successor confirms that launcher-level wrapping is
+not extensible — which is why pydblclick now registers itself as the file handler, the
+one mechanism every launcher must respect.
+
+# Todos
+
+- Publish to PyPI (`pip install pydblclick`)
+- Standalone `pydblclick.exe` handler (no Python required to bootstrap; uv can even
+  provision Python itself)
+- Offer to install uv when a PEP 723 script is double-clicked and uv is missing
+- Context menu items "Run with pydblclick" / "Bypass pydblclick"
+
+# Contributions
+
+Your contributions would be greatly appreciated. Feel free to copy the project.

pydblclick-0.2.0/pydblclick/__main__.py

@@ -0,0 +1,208 @@
+"""pydblclick — parent supervisor process.
+
+Entry point: python -m pydblclick <script.py> [args...]
+
+The actual script execution happens in a child process (pydblclick/_child.py)
+launched with the same interpreter. The child runs the script with plain-Python
+semantics, shows tracebacks and displays the pause prompt/menu itself.
+
+The parent's only job is to guarantee that the console window never flashes
+away, even when the child cannot pause by itself:
+- the script closed stdin with exit()/quit() (input() becomes impossible),
+- the interpreter died hard (os._exit, native crash, MemoryError...),
+- the script was Ctrl+C'd to death.
+
+Child -> parent protocol: the child writes "handled" to the file pointed to
+by the PYDBLCLICK_STATUS_FILE env var once it has fulfilled its pause-or-no-pause
+duty. If the marker is missing after the child exits, the parent pauses.
+
+Before launching, the parent inspects the script's source (pydblclick/_script_meta.py):
+- `# pydblclick: off` -> run with plain Python, no wrapping at all;
+- PEP 723 `# /// script` block -> run the child through `uv run` so the
+  declared dependencies are resolved in an ephemeral environment.
+"""
+import os
+import shutil
+import signal
+import subprocess
+import sys
+import tempfile
+
+from pydblclick import _script_meta
+from pydblclick._child import STATUS_HANDLED, User32, ensure_console, have_console, signed32
+
+UV_INSTALL_URL = "https://docs.astral.sh/uv/getting-started/installation/"
+
+# Exit code of a process killed because its console window was closed (or by a
+# hard Ctrl+C/Ctrl+Break). Closing the window is a deliberate user action:
+# the fallback pause must not fire for it.
+STATUS_CONTROL_C_EXIT = 0xC000013A  # 3221225786
+
+
+def _console_python():
+    """The console interpreter (python.exe) even when running under pythonw.exe.
+
+    The parent of a windowless .pyw launch is pythonw.exe, but the child engine
+    needs a standard interpreter with working standard streams.
+    """
+    exe = sys.executable
+    if os.path.basename(exe).lower() == "pythonw.exe":
+        candidate = os.path.join(os.path.dirname(exe), "python.exe")
+        if os.path.exists(candidate):
+            return candidate
+    return exe
+
+
+def _script_is_doubleclicked():
+    return (('PROMPT' not in os.environ)
+            or ('pydblclick_simulate_doubleclick' in os.environ)
+            or ('pyexewrap_simulate_doubleclick' in os.environ))  # legacy name
+
+
+def _read_status(status_file):
+    try:
+        with open(status_file, encoding="UTF-8") as f:
+            return f.read().strip()
+    except OSError:
+        return ""
+
+
+def _fallback_pause(returncode):
+    """Last-resort pause when the child could not display its own prompt."""
+    if sys.stdout is None or sys.stdin is None:
+        # Windowless parent (pythonw.exe): no usable stdio at all -- create a
+        # console on the spot so the failure is visible.
+        if not ensure_console(title="pydblclick"):
+            return
+    elif have_console():
+        # The console may still be hidden if a .pyw script crashed hard
+        User32.show_window(User32.Const.SW_SHOWDEFAULT)
+    if returncode != 0:
+        print("\nThe script ended (exit code " + str(returncode) + ") without pydblclick being able to pause.")
+    try:
+        input("Press <Enter> to Quit.\n")
+    except (EOFError, ValueError, KeyboardInterrupt):
+        pass  # stdin unusable in the parent too: nothing more we can do
+
+
+def _plain_python_for(script):
+    """The interpreter for unwrapped execution (pythonw for .pyw when available)."""
+    if os.path.splitext(script)[1].lower() == ".pyw":
+        pythonw = os.path.join(os.path.dirname(sys.executable), "pythonw.exe")
+        if os.path.exists(pythonw):
+            return pythonw
+    return sys.executable
+
+
+def _find_uv():
+    """Locate the uv executable (PYDBLCLICK_UV overrides PATH, for tests)."""
+    return os.environ.get("PYDBLCLICK_UV") or shutil.which("uv")
+
+
+def _build_child_command(script, script_args, env):
+    """Build the child command line, delegating to `uv run` for PEP 723 scripts."""
+    default_cmd = [_console_python(), "-m", "pydblclick._child", script] + script_args
+
+    meta = _script_meta.parse_pep723(_script_meta.read_script_text(script))
+    if meta is None:
+        return default_cmd
+
+    uv = _find_uv()
+    if not uv:
+        print("[pydblclick] This script declares PEP 723 dependencies, but 'uv' was not found on PATH.")
+        print("            Install uv to run it with its dependencies resolved automatically:")
+        print("            " + UV_INSTALL_URL)
+        print("            Running with plain Python instead...\n")
+        return default_cmd
+
+    cmd = [uv, "run", "--no-project"]
+    if meta["requires-python"]:
+        cmd += ["--python", meta["requires-python"]]
+    for dep in meta["dependencies"]:
+        cmd += ["--with", dep]
+    cmd += ["python", "-m", "pydblclick._child", script] + script_args
+
+    # pydblclick itself must be importable inside uv's ephemeral environment
+    package_parent = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+    existing = env.get("PYTHONPATH")
+    env["PYTHONPATH"] = package_parent + (os.pathsep + existing if existing else "")
+    return cmd
+
+
+def main():
+    if len(sys.argv) < 2:
+        print("Usage: pydblclick <script.py> [args...]")
+        print("       pydblclick register    (set pydblclick as the .py/.pyw double-click handler)")
+        print("       pydblclick unregister  (restore plain Python on double-click)")
+        print("       pydblclick diagnose    (inspect the Windows file association chain)")
+        return 2
+
+    # Management subcommands (a real script file named e.g. 'register' still wins)
+    from pydblclick._cli import COMMANDS
+    if sys.argv[1] in COMMANDS and not os.path.exists(sys.argv[1]):
+        from pydblclick import _cli
+        return _cli.main(sys.argv[1:])
+
+    script, script_args = sys.argv[1], sys.argv[2:]
+
+    # Per-script opt-out: run with plain Python, no wrapping, no pause
+    if _script_meta.has_opt_out(_script_meta.read_script_text(script)):
+        result = subprocess.run([_plain_python_for(script), script] + script_args)
+        return signed32(result.returncode)
+
+    # The status file is how the child tells us "I already paused (or decided
+    # a pause was not needed)". It survives any way the child may die.
+    fd, status_file = tempfile.mkstemp(prefix="pydblclick_status_")
+    os.close(fd)
+    env = dict(os.environ)
+    env["PYDBLCLICK_STATUS_FILE"] = status_file
+
+    cmd = _build_child_command(script, script_args, env)
+
+    # Windowless mode: a double-clicked .pyw arrives here through pythonw.exe,
+    # so this parent has no console. The child runs fully detached (no console
+    # either), its output captured in a log file. Only if an exception occurs
+    # does the child create a console (AllocConsole) and replay the log there.
+    windowless = os.path.splitext(script)[1].lower() == ".pyw" and not have_console()
+    run_kwargs = {}
+    log_file = None
+    log_handle = None
+    if windowless:
+        fd, log_file = tempfile.mkstemp(prefix="pydblclick_pyw_", suffix=".log")
+        log_handle = os.fdopen(fd, "w", encoding="utf-8", errors="replace")
+        env["PYDBLCLICK_PYW_LOG"] = log_file
+        run_kwargs = {
+            "stdin": subprocess.DEVNULL,
+            "stdout": log_handle,
+            "stderr": subprocess.STDOUT,
+            "creationflags": subprocess.DETACHED_PROCESS,
+        }
+
+    # Ctrl+C is sent to every process attached to the console. The child is
+    # the one that must handle it (KeyboardInterrupt in the script, then its
+    # pause menu); the parent must survive to display the fallback pause.
+    previous_handler = signal.signal(signal.SIGINT, signal.SIG_IGN)
+    try:
+        result = subprocess.run(cmd, env=env, **run_kwargs)
+    finally:
+        signal.signal(signal.SIGINT, previous_handler)
+        if log_handle:
+            log_handle.close()
+
+    child_handled = _read_status(status_file) == STATUS_HANDLED
+    for temp_file in (status_file, log_file):
+        if temp_file:
+            try:
+                os.remove(temp_file)
+            except OSError:
+                pass
+
+    user_closed_console = result.returncode == STATUS_CONTROL_C_EXIT
+    if not child_handled and not user_closed_console and _script_is_doubleclicked():
+        _fallback_pause(result.returncode)
+
+    return signed32(result.returncode)
+
+
+if __name__ == "__main__":
+    sys.exit(signed32(main()))