Python 3.15 + (Faster startup with auto-lazy imports)

.github/workflows/lint-and-build.yml

@@ -47,18 +47,21 @@ jobs:
     env:
       # Prevent accidentally slower type-checking due to missing arm wheels.
       # Fail rather than accidentally compile C/binary extensions from sdist.
-      UV_NO_BUILD: true
+      UV_NO_BUILD: ${{ !(matrix.python-version == '3.15' && matrix.os == 'windows-latest') }} # winrt-Windows no wheels for 3.15 yet
       # Per-package no-binary overrides no-build, allowing
       # known pure-Python source-only dependencies to still build.
       # The Build job intentionally builds some binary packages from source.
-      UV_NO_BINARY_PACKAGE: keyboard pyinstaller PyAutoGUI beslogic-ruff-config
+      UV_NO_BINARY_PACKAGE: >-
+        keyboard PyAutoGUI beslogic-ruff-config
+        ${{ matrix.python-version == '3.15' && 'RapidFuzz Levenshtein numpy' || '' }}
+      # TODO: ^ Remove these exceptions once 3.15 wheels are released
     strategy:
       fail-fast: false
       # Pyright is version and platform sensible
       matrix:
         # windows arm runner slower as long as opencv doesn't provide windows arm64 wheels
         os: [windows-latest, ubuntu-24.04-arm]
-        python-version: ["3.14"]
+        python-version: ["3.14", "3.15"]
     steps:
       - uses: actions/checkout@v6
       - name: Set up uv for Python ${{ matrix.python-version }}
@@ -90,12 +93,15 @@ jobs:
       # Only the Python version we plan on shipping matters.
       matrix:
         os: [windows-latest, windows-11-arm, ubuntu-24.04, ubuntu-24.04-arm]
-        python-version: ["3.14"]
+        python-version: ["3.14", "3.15"]
         wine-compat: [""]
         include:
           - os: windows-latest
             python-version: "3.14"
             wine-compat: "-WineCompat"
+          - os: windows-latest
+            python-version: "3.15"
+            wine-compat: "-WineCompat"
     steps:
       - uses: actions/checkout@v6
         with:
@@ -119,6 +125,13 @@ jobs:
                 && format('{0}-{1}', matrix.python-version, endsWith(matrix.os, 'arm') && 'aarch64' || 'x86_64'))
               || null }}
       # endregion
+      # MinGW (cc) fails SIZEOF_PY_INTPTR_T detection on ARM64; force MSVC for numpy sdist
+      # TODO: Remove this action once we use numpy 3.15 wheels
+      - name: Set up MSVC ARM64 environment
+        if: ${{ matrix.os == 'windows-11-arm' && matrix.python-version == '3.15' }}
+        uses: ilammy/msvc-dev-cmd@v1
+        with:
+          arch: arm64
       - run: scripts/install.ps1 ${{ matrix.wine-compat }}
       - run: "scripts/build.ps1 ${{ matrix.wine-compat }}"
       - name: Run test suite

pyproject.toml

@@ -17,7 +17,7 @@ dependencies = [
 
   #
   # Build and compile resources
-  "pyinstaller >=6.15.0", # Python 3.14 support
+  "pyinstaller >=6.21.0", # Python 3.15 support
 
   #
   # https://packaging.python.org/en/latest/specifications/dependency-specifiers/#environment-markers
@@ -49,7 +49,7 @@ dev = [
   #
   # Linters & Formatters
   "dprint-py >=0.50.0.0",
-  "mypy >=2.1", # TODO: Bump when 3.15 wheels
+  "mypy >=2.1; python_version < '3.15'", # TODO: Bump when 3.15 wheels
   "pyright[nodejs] >=1.1.400", # reportPrivateImportUsage behaviour change
   { include-group = "ruff" },
   #
@@ -84,16 +84,19 @@ find-links = ["./scripts"] # Discover local wheels
 exclude-newer = "1 week"
 [tool.uv.exclude-newer-package]
 typed-D3DShot = false # I own it
+# pyinstaller-hooks-contrib = false # pyinstaller develop build
+pyinstaller = "2 days" # TODO: REMOVE BEFORE MERGING
+pyinstaller-hooks-contrib = "6 days" # TODO: REMOVE BEFORE MERGING
 
 ###
 # Development channels
 ###
 [tool.uv.sources]
 beslogic-ruff-config = { git = "https://github.com/Beslogic/Beslogic-Ruff-Config", rev = "312cfab8a1e2653639a2ef665e99eac6c7412ba7" }
 # pywin32 = { git = "https://github.com/mhammond/pywin32.git", marker = "python_version >= '3.15'" }
+# pyinstaller = { git = "https://github.com/pyinstaller/pyinstaller.git", marker = "python_version >= '3.15'" }
 # numpy = { index = "scientific-python-nightly-wheels", marker = "python_version >= '3.15'" }
-# pillow = { index = "scientific-python-nightly-wheels", marker = "python_version >= '3.15'" }
-# pyinstaller = { url = "https://github.com/pyinstaller/pyinstaller/archive/develop.zip", marker = "python_version >= '3.15'" }
+pillow = { index = "scientific-python-nightly-wheels", marker = "python_version >= '3.15'" }
 
 [[tool.uv.index]]
 exclude-newer = false # Anaconda index doesn't have upload dates

scripts/build.ps1

@@ -10,9 +10,11 @@ Push-Location "$PSScriptRoot/.." # Avoid issues with space in path
 try {
   & 'scripts/compile_resources.ps1'
 
+  # TODO: Remove UV_PYTHON check once tcl/tk is fixed on Python 3.15
   # CI not allowed to skip splash screen, it MUST build (will fail when calling PyInstaller)
-  $SupportsSplashScreen = $Env:GITHUB_JOB -or [System.Convert]::ToBoolean(
-    $(uv run --active scripts/check_splash_support.py))
+  $SupportsSplashScreen = ($Env:UV_PYTHON -notlike '3.15*') -and (
+    $Env:GITHUB_JOB -or [System.Convert]::ToBoolean(
+      $(uv run --active scripts/check_splash_support.py)))
 
   $arguments = @(
     'src/AutoSplit.py',

scripts/check_splash_support.py

@@ -12,7 +12,14 @@
 from PyInstaller.building.splash import Splash
 
 try:
-    Splash._check_tcl_tk_compatibility()  # noqa: SLF001
+    from PyInstaller.utils.hooks.tcl_tk import tcltk_info
+
+    if not tcltk_info.available:
+        raise SystemExit(  # noqa: TRY301 # Copies source
+            "ERROR: Your platform does not support the splash screen feature, "
+            + "since tkinter is not installed. Please install tkinter and try again."
+        )
+    Splash._check_tcl_tk_compatibility(tcltk_info)  # noqa: SLF001
     print(True)
 except SystemExit as e:
     print(e, file=sys.stderr)

scripts/compile_resources.ps1

@@ -42,9 +42,21 @@ if (-not $GITHUB_REPOSITORY) {
   $GITHUB_REPOSITORY = 'Toufool/AutoSplit'
 }
 
+# Our own top-level modules and packages, used by AutoSplit.py's lazy imports
+# filter (Python 3.15+). Generated because PyInstaller-frozen builds can't
+# discover pure modules on disk: they live inside the PYZ archive.
+$SRC_ROOT_MODULES = (
+  @('"__main__"') + (
+    Get-ChildItem ./src |
+      Where-Object { ($_.Extension -eq '.py' -or $_.PSIsContainer) -and $_.Name -notlike '__*' } |
+      ForEach-Object { "`"$($_.BaseName)`"" }
+  )
+) -join ', '
+
 New-Item $build_vars_path -ItemType File -Force | Out-Null
 Add-Content $build_vars_path "AUTOSPLIT_BUILD_NUMBER = `"$BUILD_NUMBER`""
 Add-Content $build_vars_path "AUTOSPLIT_GITHUB_REPOSITORY = `"$GITHUB_REPOSITORY`""
+Add-Content $build_vars_path "SRC_ROOT_MODULES = frozenset(($SRC_ROOT_MODULES))"
 Write-Host "Generated build number: `"$BUILD_NUMBER`""
 Write-Host "Set repository to `"$GITHUB_REPOSITORY`""
 

src/AutoSplit.py

@@ -2,6 +2,54 @@
 import os
 import sys
 
+if sys.version_info >= (3, 15):
+    # Packages whose *internal* imports must stay eager
+    # (importing them from elsewhere is still lazy):
+    # - stdlib: gains nothing (loads at startup anyway),
+    #   and its lazy proxies fail to reify under shiboken6's patched __import__
+    #   (e.g. typing.Union: "'lazy_import' object is not subscriptable").
+    # - shiboken6/shibokensupport: patch __import__ (feature_import) and exec
+    #   embedded modules behind aliased spec names
+    #   (PySide6.support.signature.* vs shibokensupport.*).
+    # - numpy: its self-check raises a bogus version conflict when imported
+    #   through shiboken6's patched __import__.
+    _EAGER_INTERNALS = (
+        frozenset({
+            "PySide6",
+            "shiboken6",
+            "shibokensupport",
+            "numpy",
+        })
+        | sys.stdlib_module_names
+    )
+
+    def _lazy_imports_filter(
+        importing: str | None,
+        imported: str,
+        fromlist: tuple[str, ...] | None = None,  # noqa: ARG001
+        /,
+    ) -> bool:
+        # No importer means exec'd/embedded code (e.g. shiboken6's signature
+        # bootstrap), which can't be trusted to resolve lazy proxies.
+        if not importing:
+            return False
+        # Imports within the same top-level package must stay eager:
+        # - A package importing its own submodule rebinds the submodule name on
+        #   the parent package, clobbering any same-named lazy proxy in the
+        #   package's namespace
+        #   (e.g. "from capture_method.ScrotCaptureMethod import ScrotCaptureMethod").
+        #   https://github.com/python/cpython/issues/151208
+        # - A relative "from . import x" binds a lazy proxy that fails to reify
+        #   on attribute access (e.g. PIL/__init__.py's
+        #   "__version__ = _version.__version__" sees the raw proxy).
+        #   TODO: Report upstream, possibly same root cause as the issue above.
+        if importing.partition(".")[0] == imported.partition(".")[0]:
+            return False
+        return importing.partition(".")[0] not in _EAGER_INTERNALS
+
+    sys.set_lazy_imports_filter(_lazy_imports_filter)
+    sys.set_lazy_imports("all")
+
 # Prevent PyAutoGUI and pywinctl from setting Process DPI Awareness,
 # which Qt tries to do then throws warnings about it.
 # The unittest workaround significantly increases

src/capture_method/BitBltCaptureMethod.py

@@ -77,10 +77,7 @@ def get_frame(self) -> MatLike | None:
             # Invalid handle or the window was closed while it was being manipulated
             return None
 
-        if is_blank(image):
-            image = None
-        else:
-            image.shape = (height, width, BGRA_CHANNEL_COUNT)
+        image = None if is_blank(image) else image.reshape((height, width, BGRA_CHANNEL_COUNT))
 
         # Cleanup DC and handle
         try_delete_dc(dc_object)

src/capture_method/WindowsGraphicsCaptureMethod.py

@@ -156,7 +156,7 @@ def get_frame(self) -> MatLike | None:
             raise ValueError("Unable to obtain the BitmapBuffer from SoftwareBitmap.")
         reference = bitmap_buffer.create_reference()
         image = np.frombuffer(cast("bytes", reference), dtype=np.uint8)
-        image.shape = (self.size.height, self.size.width, BGRA_CHANNEL_COUNT)
+        image = image.reshape((self.size.height, self.size.width, BGRA_CHANNEL_COUNT))
         image = image[
             selection["y"] : selection["y"] + selection["height"],
             selection["x"] : selection["x"] + selection["width"],

tests/test_import_all_modules.py

@@ -1,14 +1,16 @@
 """
 Smoke test: import every one of our own modules, including submodules.
 
-Catches import-time errors early: syntax errors, missing dependencies
-and broken platform guards in module-level code.
+Catches import-time errors early: syntax errors, missing dependencies,
+broken platform guards and lazy import issues in module-level code.
 """
 
 import importlib
 import operator
 import pkgutil
+import subprocess  # noqa: S404
 import sys
+import textwrap
 import unittest
 from pathlib import Path
 
@@ -55,8 +57,44 @@ def test_import_all_modules(self):
                 if module_name in EXPECTED_OS_ERRORS:
                     with self.assertRaises(OSError):
                         importlib.import_module(module_name)
-                else:
-                    importlib.import_module(module_name)
+                    continue
+                module = importlib.import_module(module_name)
+                # Force every lazy import proxy to resolve. eval's LOAD_NAME
+                # on the module's namespace triggers reification
+                # (plain getattr does not).
+                for attr_name in [
+                    k for k, v in vars(module).items() if type(v).__name__ == "lazy_import"
+                ]:
+                    eval(attr_name, vars(module))  # noqa: S307
+
+    def test_app_entrypoint_in_fresh_interpreter(self):
+        """
+        The test runner itself has already imported most of the stdlib, which
+        masks lazy import issues that only occur with a clean sys.modules
+        (e.g. shiboken6's bootstrap importing stdlib modules through lazy
+        proxies). Mimic a real app launch instead.
+
+        Also probes shiboken6's signature support: its bootstrap swallows
+        errors and only logs them, and it isn't otherwise guaranteed to be
+        exercised by mere imports.
+        """
+        code = textwrap.dedent("""
+            import AutoSplit
+            import inspect
+            from PySide6 import QtCore
+            signature = inspect.signature(QtCore.QObject.objectName)
+            assert isinstance(signature, inspect.Signature), signature
+        """)
+        # Trusted, hardcoded code string ran with our own interpreter
+        result = subprocess.run(  # noqa: S603
+            [sys.executable, "-c", code],
+            capture_output=True,
+            text=True,
+            check=False,
+            cwd=SRC_DIR,
+            timeout=120,
+        )
+        self.assertEqual(result.returncode, 0, msg=result.stderr)
 
 
 if __name__ == "__main__":