Hot Take: Python 3.13’s JIT Compiler Makes PyPy Obsolete by Q3 2026

import time
import sys
import platform
import json
from typing import Callable, List, Dict, Any
import statistics

def benchmark_numeric_loop(iterations: int = 10_000_000) -> float:
    """Run a loop-heavy numeric workload, return execution time in ms."""
    start = time.perf_counter()
    total = 0
    for i in range(iterations):
        total += i * 2
        if i % 1000 == 0:
            total = total % 1_000_000  # Prevent overflow for large iterations
    end = time.perf_counter()
    return (end - start) * 1000  # Convert to milliseconds

def benchmark_json_serialize(iterations: int = 100_000) -> float:
    """Benchmark JSON serialization throughput, return ops per second."""
    test_data = {
        "id": 12345,
        "name": "test_payload",
        "values": list(range(100)),
        "metadata": {"created_at": "2024-10-01T12:00:00Z", "version": "1.0.0"}
    }
    start = time.perf_counter()
    for _ in range(iterations):
        try:
            json.dumps(test_data)
        except json.JSONEncodeError as e:
            print(f"JSON encode error: {e}", file=sys.stderr)
            return 0.0
    end = time.perf_counter()
    total_time = end - start
    return iterations / total_time if total_time > 0 else 0.0

def run_benchmark_suite(runs: int = 100) -> Dict[str, Any]:
    """Run full benchmark suite, return aggregated results."""
    results = {
        "numeric_loop_ms": [],
        "json_ops_per_sec": [],
        "runtime": platform.python_implementation(),
        "version": platform.python_version(),
        "jit_enabled": sys.flags.jit if hasattr(sys.flags, 'jit') else False
    }
    for run in range(runs):
        try:
            numeric_time = benchmark_numeric_loop()
            results["numeric_loop_ms"].append(numeric_time)
            json_throughput = benchmark_json_serialize()
            results["json_ops_per_sec"].append(json_throughput)
        except Exception as e:
            print(f"Run {run} failed: {e}", file=sys.stderr)
            continue
    # Aggregate results
    aggregated = {
        "runtime": results["runtime"],
        "version": results["version"],
        "jit_enabled": results["jit_enabled"],
        "numeric_loop_ms_avg": statistics.mean(results["numeric_loop_ms"]) if results["numeric_loop_ms"] else 0.0,
        "numeric_loop_ms_p99": statistics.quantiles(results["numeric_loop_ms"], n=100)[98] if len(results["numeric_loop_ms"]) >= 100 else 0.0,
        "json_ops_per_sec_avg": statistics.mean(results["json_ops_per_sec"]) if results["json_ops_per_sec"] else 0.0,
        "total_runs": len(results["numeric_loop_ms"])
    }
    return aggregated

if __name__ == "__main__":
    # Validate Python version for JIT support
    if sys.version_info < (3, 13):
        print(f"Warning: JIT only supported in Python 3.13+, running {platform.python_version()}", file=sys.stderr)
    # Run benchmark suite
    print(f"Running benchmarks on {platform.python_implementation()} {platform.python_version()}")
    print(f"JIT enabled: {sys.flags.jit if hasattr(sys.flags, 'jit') else 'N/A'}")
    results = run_benchmark_suite(runs=100)
    # Print results as JSON
    print(json.dumps(results, indent=2))

import sys
import os
import warnings
from typing import Optional, Dict, Any
import json

class JITConfigError(Exception):
    """Custom exception for JIT configuration errors."""
    pass

def check_jit_support() -> bool:
    """Check if current Python runtime supports JIT compilation."""
    if sys.version_info < (3, 13):
        raise JITConfigError(f"JIT requires Python 3.13+, found {sys.version_info.major}.{sys.version_info.minor}")
    if not hasattr(sys.flags, 'jit'):
        raise JITConfigError("JIT flag not found in sys.flags – possible custom CPython build")
    return True

def get_jit_config() -> Dict[str, Any]:
    """Retrieve current JIT configuration from environment and runtime flags."""
    config = {
        "jit_enabled": sys.flags.jit,
        "jit_threshold": os.environ.get("PYTHONJIT_THRESHOLD", "1000"),
        "jit_debug": os.environ.get("PYTHONJIT_DEBUG", "0"),
        "jit_log_path": os.environ.get("PYTHONJIT_LOG_PATH", ""),
        "runtime_version": sys.version,
        "implementation": sys.implementation.name
    }
    # Validate threshold is integer
    try:
        config["jit_threshold"] = int(config["jit_threshold"])
    except ValueError:
        warnings.warn(f"Invalid PYTHONJIT_THRESHOLD: {config['jit_threshold']}, defaulting to 1000")
        config["jit_threshold"] = 1000
    # Validate debug flag
    config["jit_debug"] = config["jit_debug"] in ("1", "true", "True")
    return config

def set_jit_env_config(threshold: Optional[int] = None, debug: Optional[bool] = None, log_path: Optional[str] = None) -> None:
    """Set JIT configuration via environment variables (requires restart to take effect)."""
    if threshold is not None:
        if not isinstance(threshold, int) or threshold < 1:
            raise JITConfigError(f"JIT threshold must be positive integer, got {threshold}")
        os.environ["PYTHONJIT_THRESHOLD"] = str(threshold)
    if debug is not None:
        os.environ["PYTHONJIT_DEBUG"] = "1" if debug else "0"
    if log_path is not None:
        if not isinstance(log_path, str) or not log_path.strip():
            raise JITConfigError(f"Invalid log path: {log_path}")
        os.environ["PYTHONJIT_LOG_PATH"] = log_path

def print_jit_status() -> None:
    """Print human-readable JIT status to stdout."""
    try:
        check_jit_support()
        config = get_jit_config()
        print("=== Python 3.13 JIT Status ===")
        print(f"Runtime: {config['implementation']} {config['runtime_version']}")
        print(f"JIT Enabled (runtime flag): {config['jit_enabled']}")
        print(f"JIT Threshold (env PYTHONJIT_THRESHOLD): {config['jit_threshold']}")
        print(f"JIT Debug (env PYTHONJIT_DEBUG): {config['jit_debug']}")
        print(f"JIT Log Path (env PYTHONJIT_LOG_PATH): {config['jit_log_path'] or 'Not set'}")
        # Check if JIT is actually active (experimental API)
        if hasattr(sys, '_jit_active'):
            print(f"JIT Active (runtime): {sys._jit_active}")
        else:
            print("JIT Active status: Unknown (experimental API not available)")
    except JITConfigError as e:
        print(f"JIT Configuration Error: {e}", file=sys.stderr)
        sys.exit(1)

if __name__ == "__main__":
    # Example: Configure JIT for production workload
    try:
        # Set threshold to 500 (compile functions after 500 calls)
        set_jit_env_config(threshold=500, debug=False, log_path="/var/log/python-jit.log")
        print_jit_status()
        # Example: Run a sample workload to trigger JIT compilation
        print("\nRunning sample workload to trigger JIT...")
        total = 0
        for i in range(10_000):
            total += i * 2
        print(f"Sample workload result: {total}")
    except Exception as e:
        print(f"Unexpected error: {e}", file=sys.stderr)
        sys.exit(1)

import sys
import importlib
import pkg_resources
import json
from typing import List, Dict, Tuple
import subprocess
import warnings

class MigrationCheckError(Exception):
    """Exception raised for migration compatibility issues."""
    pass

def check_python_version() -> Tuple[bool, str]:
    """Verify running on CPython 3.13+."""
    impl = sys.implementation.name
    major, minor = sys.version_info.major, sys.version_info.minor
    if impl != "cpython":
        return False, f"Expected CPython, found {impl}"
    if major != 3 or minor < 13:
        return False, f"Expected Python 3.13+, found {major}.{minor}"
    return True, "CPython 3.13+ detected"

def check_pypy_specific_imports() -> List[str]:
    """Check for PyPy-specific imports that won't work on CPython."""
    pypy_specific_modules = [
        "pypy", "pypyjit", "pypycore", "_pypy_wait", "pypy.magic"
    ]
    found = []
    for mod in pypy_specific_modules:
        try:
            importlib.import_module(mod)
            found.append(mod)
        except ImportError:
            continue
    return found

def check_c_extensions(compatibility_map: Dict[str, str]) -> List[Dict[str, str]]:
    """Check if installed C extensions are compatible with CPython 3.13."""
    incompatible = []
    for dist in pkg_resources.working_set:
        # Check if extension has PyPy-specific build
        if "pypy" in dist.project_name.lower():
            incompatible.append({
                "package": dist.project_name,
                "version": dist.version,
                "issue": "PyPy-specific package, not required for CPython"
            })
            continue
        # Check against compatibility map
        if dist.project_name in compatibility_map:
            required_version = compatibility_map[dist.project_name]
            if dist.version != required_version:
                incompatible.append({
                    "package": dist.project_name,
                    "installed_version": dist.version,
                    "required_version": required_version,
                    "issue": "Version mismatch for CPython 3.13 compatibility"
                })
    return incompatible

def run_migration_check() -> Dict[str, Any]:
    """Run full migration compatibility check."""
    results = {
        "python_check": {},
        "pypy_imports": [],
        "incompatible_extensions": [],
        "recommendations": []
    }
    # Check Python version
    py_ok, py_msg = check_python_version()
    results["python_check"] = {"passed": py_ok, "message": py_msg}
    # Check PyPy imports
    results["pypy_imports"] = check_pypy_specific_imports()
    # Check C extensions (example compatibility map)
    compat_map = {
        "numpy": "2.1.0",
        "pandas": "2.2.3",
        "fastapi": "0.112.0",
        "sqlalchemy": "2.0.35"
    }
    results["incompatible_extensions"] = check_c_extensions(compat_map)
    # Generate recommendations
    if not py_ok:
        results["recommendations"].append(f"Upgrade to CPython 3.13: {py_msg}")
    if results["pypy_imports"]:
        results["recommendations"].append(f"Remove PyPy-specific imports: {', '.join(results['pypy_imports'])}")
    if results["incompatible_extensions"]:
        results["recommendations"].append("Update incompatible packages to CPython 3.13 compatible versions")
    if not results["recommendations"]:
        results["recommendations"].append("No migration issues detected – safe to switch to CPython 3.13 JIT")
    return results

if __name__ == "__main__":
    print("=== PyPy to CPython 3.13 JIT Migration Check ===")
    try:
        results = run_migration_check()
        print(json.dumps(results, indent=2))
        # Exit with error if critical issues found
        if not results["python_check"]["passed"] or results["incompatible_extensions"]:
            sys.exit(1)
    except Exception as e:
        print(f"Migration check failed: {e}", file=sys.stderr)
        sys.exit(1)

import cProfile
import pstats
from your_app import run_data_pipeline

profiler = cProfile.Profile()
profiler.enable()
run_data_pipeline()  # Your CPU-bound workload
profiler.disable()
stats = pstats.Stats(profiler)
stats.sort_stats("cumtime").print_stats(20)  # Print top 20 time-consuming functions

# Dockerfile for CPython 3.13 JIT tuned for web API
FROM python:3.13-slim
ENV PYTHONJIT_THRESHOLD=2000
ENV PYTHONJIT_DEBUG=0
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt
COPY . .
CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0"]

# Check if numpy has CPython 3.13 support
pip install numpy==2.1.0 --dry-run
# If no errors, package is compatible