pyswig-dev 0.2.0__py3-none-any.whl

pyswig_dev/__init__.py

@@ -0,0 +1,5 @@
+"""PySwig development tooling (environment setup, SWIG provisioning)."""
+
+from __future__ import annotations
+
+__version__ = "0.2.0"

pyswig_dev/cli.py

@@ -0,0 +1,31 @@
+"""Console entry point for pyswig-dev."""
+
+from __future__ import annotations
+
+import sys
+
+
+def main(argv: list[str] | None = None) -> int:
+    args = list(sys.argv[1:] if argv is None else argv)
+    if not args or args[0] in ("-h", "--help"):
+        print("usage: pyswig-dev <command> [options]")
+        print("commands: setup, test-all")
+        return 0 if args and args[0] in ("-h", "--help") else 1
+
+    command, rest = args[0], args[1:]
+    if command == "setup":
+        from pyswig_dev.setup_env import main as setup_main
+
+        return setup_main(rest)
+
+    if command == "test-all":
+        from pyswig_dev.test_all import main as test_main
+
+        return test_main(rest)
+
+    print(f"unknown command: {command}", file=sys.stderr)
+    return 2
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

pyswig_dev/config.py

@@ -0,0 +1,111 @@
+"""Load shared tool settings from the repository pyproject.toml."""
+
+from __future__ import annotations
+
+import sys
+from functools import lru_cache
+from pathlib import Path
+from typing import Any, cast
+
+
+@lru_cache(maxsize=1)
+def repo_root() -> Path:
+    """Return the PySwig git checkout root (directory with [tool.pyswig])."""
+    start = Path(__file__).resolve()
+    for candidate in (start, *start.parents):
+        pyproject = candidate / "pyproject.toml"
+        if not pyproject.is_file():
+            continue
+        data = _load_toml(pyproject)
+        if data.get("tool", {}).get("pyswig"):
+            return candidate
+    raise SystemExit("could not find repo root (pyproject.toml with [tool.pyswig])")
+
+
+ROOT = repo_root  # lazy alias for callers that expect ROOT as callable path source
+
+
+def pyproject_path() -> Path:
+    return repo_root() / "pyproject.toml"
+
+
+def _load_toml(path: Path) -> dict[str, Any]:
+    if sys.version_info >= (3, 11):
+        import tomllib
+
+        with path.open("rb") as handle:
+            return cast(dict[str, Any], tomllib.load(handle))
+    try:
+        import tomli
+    except ImportError as exc:
+        raise SystemExit(
+            "Reading pyproject.toml requires Python 3.11+ or the 'tomli' package."
+        ) from exc
+    with path.open("rb") as handle:
+        return cast(dict[str, Any], tomli.load(handle))
+
+
+def load_pyswig_tool_config() -> dict[str, Any]:
+    """Return the [tool.pyswig] table from pyproject.toml."""
+    data = _load_toml(pyproject_path())
+    return cast(dict[str, Any], data.get("tool", {}).get("pyswig", {}))
+
+
+def test_python_versions() -> list[str]:
+    """Python versions that must pass in CI and local test_all."""
+    values = load_pyswig_tool_config().get("test-python-versions", [])
+    if not values:
+        raise SystemExit("tool.pyswig.test-python-versions is empty in pyproject.toml")
+    return [str(item) for item in values]
+
+
+def coverage_python_version() -> str:
+    """Python version used for coverage measurement."""
+    value = load_pyswig_tool_config().get("coverage-python-version")
+    if not value:
+        raise SystemExit("tool.pyswig.coverage-python-version is missing in pyproject.toml")
+    return str(value)
+
+
+def default_dev_python_version() -> str:
+    """Default interpreter for the contributor .venv."""
+    value = load_pyswig_tool_config().get("default-dev-python-version")
+    if value:
+        return str(value)
+    return coverage_python_version()
+
+
+def integration_swig_versions() -> list[str]:
+    """Pinned SWIG versions exercised by simple wrapper integration tests."""
+    values = load_pyswig_tool_config().get("integration-swig-versions", [])
+    return [str(item) for item in values]
+
+
+def integration_python_versions() -> list[str]:
+    """Python versions exercised by simple wrapper integration tests."""
+    values = load_pyswig_tool_config().get("integration-python-versions", [])
+    return [str(item) for item in values]
+
+
+def integration_matrix_cells() -> list[tuple[str, str]]:
+    """All Python × SWIG combinations from pyproject.toml."""
+    return [
+        (python_version, swig_version)
+        for python_version in integration_python_versions()
+        for swig_version in integration_swig_versions()
+    ]
+
+
+def integration_swig_cache_dir() -> Path:
+    """Directory where integration tests cache downloaded or built SWIG binaries."""
+    value = load_pyswig_tool_config().get("integration-swig-cache-dir", ".cache/swig")
+    path = Path(str(value))
+    if path.is_absolute():
+        return path
+    return repo_root() / path
+
+
+def badge_filename(python_version: str) -> str:
+    """Return the public badge path for a Python version (e.g. public/python311-badge.svg)."""
+    compact = python_version.replace(".", "")
+    return f"public/python{compact}-badge.svg"

pyswig_dev/setup_env.py

@@ -0,0 +1,415 @@
+#!/usr/bin/env python3
+"""Bootstrap a cross-platform pyswig development environment using uv."""
+
+from __future__ import annotations
+
+import argparse
+import os
+import platform
+import shutil
+import subprocess
+import sys
+
+from pyswig_dev.config import default_dev_python_version, repo_root, test_python_versions
+from pyswig_dev.ssl_util import (
+    configure_ssl_environment,
+    configure_ssl_fallback_bundle,
+    ensure_python_ssl_packages,
+    log_ssl_configuration,
+    looks_like_tls_failure,
+)
+from pyswig_dev.uv_util import (
+    augment_path_for_uv,
+    describe_uv_command,
+    find_uv_command,
+    uv_install_hint,
+)
+
+REPO_ROOT = repo_root()
+
+UV_INSTALL_URL = "https://astral.sh/uv/install.sh"
+UV_INSTALL_PS1 = "https://astral.sh/uv/install.ps1"
+
+
+def log_ok(message: str) -> None:
+    print(f"[ok]    {message}")
+
+
+def log_skip(message: str) -> None:
+    print(f"[skip]  {message}")
+
+
+def log_install(message: str) -> None:
+    print(f"[install] {message}")
+
+
+def log_warn(message: str) -> None:
+    print(f"[warn]  {message}")
+
+
+def _base_env() -> dict[str, str]:
+    env = os.environ.copy()
+    configure_ssl_environment(env)
+    env.setdefault("UV_PROJECT_ENVIRONMENT", str(REPO_ROOT / ".venv"))
+    return env
+
+
+def run(
+    command: list[str],
+    *,
+    check: bool = True,
+    capture: bool = False,
+    env: dict[str, str] | None = None,
+) -> subprocess.CompletedProcess[str]:
+    display = " ".join(command)
+    print(f"+ {display}")
+    merged_env = _base_env()
+    if env:
+        merged_env.update(env)
+    return subprocess.run(
+        command,
+        cwd=REPO_ROOT,
+        check=check,
+        text=True,
+        capture_output=capture,
+        env=merged_env,
+    )
+
+
+def _install_uv_via_pip() -> None:
+    log_install("uv not found; installing with pip (--user)")
+    run(
+        [sys.executable, "-m", "pip", "install", "--user", "uv"],
+        check=False,
+    )
+    augment_path_for_uv()
+
+
+def _install_uv_via_official_installer() -> None:
+    system = platform.system()
+    log_install("uv still not found; running official Astral installer")
+    if system == "Windows":
+        run(
+            [
+                "powershell",
+                "-NoProfile",
+                "-ExecutionPolicy",
+                "Bypass",
+                "-Command",
+                f"irm {UV_INSTALL_PS1} | iex",
+            ],
+            check=False,
+        )
+    else:
+        run(["sh", "-c", f"curl -LsSf {UV_INSTALL_URL} | sh"], check=False)
+    augment_path_for_uv()
+
+
+def bootstrap_uv() -> list[str]:
+    """Install uv when missing; safe to call only after find_uv_command() returned None."""
+    _install_uv_via_pip()
+    found = find_uv_command()
+    if found:
+        return found
+
+    _install_uv_via_official_installer()
+    found = find_uv_command()
+    if found:
+        return found
+
+    raise SystemExit(uv_install_hint())
+
+
+def ensure_uv(*, allow_install: bool) -> list[str]:
+    """Locate uv, installing it when allowed and not already present."""
+    found = find_uv_command()
+    if found:
+        result = run([*found, "--version"], capture=True)
+        log_skip(f"uv already available at {describe_uv_command(found)} ({result.stdout.strip()})")
+        return found
+
+    log_install("uv not found on PATH or as python -m uv")
+    if not allow_install:
+        raise SystemExit(
+            f"{uv_install_hint()}\nRe-run without --skip-uv-install to install uv automatically."
+        )
+
+    command = bootstrap_uv()
+    result = run([*command, "--version"], capture=True)
+    log_ok(
+        f"uv installed and available at {describe_uv_command(command)} ({result.stdout.strip()})"
+    )
+    return command
+
+
+def python_is_available(uv: list[str], python_version: str) -> str | None:
+    result = subprocess.run(
+        [*uv, "python", "find", python_version],
+        cwd=REPO_ROOT,
+        text=True,
+        capture_output=True,
+        check=False,
+        env=_base_env(),
+    )
+    if result.returncode != 0:
+        return None
+    path = result.stdout.strip().splitlines()
+    return path[-1] if path else result.stdout.strip() or None
+
+
+def _log_install_failure(python_version: str, output: str, *, used_fallback: bool = False) -> None:
+    log_warn(f"Python {python_version} could not be installed; continuing setup")
+    if not output.strip():
+        return
+    for line in output.strip().splitlines()[-8:]:
+        log_warn(f"  {line}")
+    if looks_like_tls_failure(output):
+        if used_fallback:
+            log_warn(
+                "  TLS hint: retried with a merged Windows+certifi CA bundle and still failed. "
+                "Ask IT for a corporate CA PEM and set SSL_CERT_FILE before re-running."
+            )
+        else:
+            log_warn(
+                "  TLS hint: uv uses the OS trust store (UV_SYSTEM_CERTS). "
+                "A merged CA bundle retry will run automatically on certificate errors."
+            )
+
+
+def _install_python_with_uv(
+    uv: list[str], python_version: str
+) -> tuple[subprocess.CompletedProcess[str], bool]:
+    env = _base_env()
+    completed = subprocess.run(
+        [*uv, "python", "install", python_version],
+        cwd=REPO_ROOT,
+        text=True,
+        capture_output=True,
+        check=False,
+        env=env,
+    )
+    if completed.returncode == 0:
+        return completed, False
+
+    output = completed.stderr or completed.stdout
+    if not looks_like_tls_failure(output):
+        return completed, False
+
+    fallback_env = _base_env()
+    bundle = configure_ssl_fallback_bundle(fallback_env)
+    if bundle is None:
+        return completed, False
+
+    log_install(f"retrying Python {python_version} install with merged CA bundle ({bundle.name})")
+    log_ssl_configuration(fallback_env)
+    retried = subprocess.run(
+        [*uv, "python", "install", python_version],
+        cwd=REPO_ROOT,
+        text=True,
+        capture_output=True,
+        check=False,
+        env=fallback_env,
+    )
+    return retried, True
+
+
+def ensure_python(uv: list[str], python_version: str) -> str | None:
+    """Ensure a Python version is available; return path or None on install failure."""
+    found = python_is_available(uv, python_version)
+    if found:
+        log_skip(f"Python {python_version} already available ({found})")
+        return found
+
+    log_install(f"Python {python_version} not found; installing with uv")
+    completed, used_fallback = _install_python_with_uv(uv, python_version)
+    if completed.returncode != 0:
+        output = completed.stderr or completed.stdout
+        _log_install_failure(python_version, output, used_fallback=used_fallback)
+        return None
+
+    found = python_is_available(uv, python_version)
+    if not found:
+        _log_install_failure(python_version, "uv python install succeeded but python find failed")
+        return None
+
+    log_ok(f"Python {python_version} installed ({found})")
+    return found
+
+
+def ensure_project_venv(uv: list[str], python_version: str, *, recreate: bool) -> bool:
+    """Create .venv and install dev deps; return False when the dev Python is unavailable."""
+    if python_is_available(uv, python_version) is None:
+        log_warn(
+            f"skipping .venv setup because Python {python_version} is not available "
+            "(install failed or was skipped)"
+        )
+        return False
+
+    venv_dir = REPO_ROOT / ".venv"
+    if recreate and venv_dir.exists():
+        log_install(f"removing existing {venv_dir.name}")
+        shutil.rmtree(venv_dir)
+
+    if venv_dir.exists():
+        log_skip(f"virtual environment already exists at {venv_dir}")
+    else:
+        log_install(f"creating virtual environment at {venv_dir} (Python {python_version})")
+        completed = subprocess.run(
+            [*uv, "venv", str(venv_dir), "--python", python_version],
+            cwd=REPO_ROOT,
+            text=True,
+            capture_output=True,
+            check=False,
+            env=_base_env(),
+        )
+        if completed.returncode != 0:
+            _log_install_failure(python_version, completed.stderr or completed.stdout)
+            return False
+
+    log_install("installing editable packages (pyswig, pyswig-dev, contributor tools)")
+    completed = subprocess.run(
+        [
+            *uv,
+            "pip",
+            "install",
+            "-e",
+            "packages/pyswig[contributor]",
+            "-e",
+            "packages/pyswig-dev",
+        ],
+        cwd=REPO_ROOT,
+        text=True,
+        capture_output=True,
+        check=False,
+        env=_base_env(),
+    )
+    if completed.returncode != 0:
+        log_warn("editable dev install failed:")
+        for line in (completed.stderr or completed.stdout).strip().splitlines()[-8:]:
+            log_warn(f"  {line}")
+        return False
+
+    log_ok("editable install complete (pyswig + pyswig-dev)")
+    return True
+
+
+def ensure_pre_commit_hooks(*, skip: bool) -> bool:
+    """Install pre-commit and commit-msg (gitlint) hooks into .git/hooks."""
+    if skip:
+        log_skip("pre-commit hook install skipped")
+        return True
+
+    if sys.platform == "win32":
+        pre_commit = REPO_ROOT / ".venv" / "Scripts" / "pre-commit.exe"
+    else:
+        pre_commit = REPO_ROOT / ".venv" / "bin" / "pre-commit"
+
+    if not pre_commit.is_file():
+        log_warn("pre-commit not found in .venv; run setup without --skip-project-venv first")
+        return False
+
+    log_install("installing pre-commit hooks (pre-commit + commit-msg/gitlint)")
+    run([str(pre_commit), "install"])
+    run([str(pre_commit), "install", "--hook-type", "commit-msg"])
+    log_ok("pre-commit hooks installed")
+    return True
+
+
+def parse_args(argv: list[str] | None = None) -> argparse.Namespace:
+    parser = argparse.ArgumentParser(
+        description=__doc__,
+        epilog=(
+            "When uv is missing, this script tries to install it automatically "
+            "(pip --user, then the official Astral installer). "
+            "TLS trust is configured via UV_SYSTEM_CERTS and certifi."
+        ),
+    )
+    parser.add_argument(
+        "--skip-uv-install",
+        action="store_true",
+        help="Fail instead of installing uv when it is not already available",
+    )
+    parser.add_argument(
+        "--skip-project-venv",
+        action="store_true",
+        help="Only ensure test Python versions; do not create .venv",
+    )
+    parser.add_argument(
+        "--recreate-venv",
+        action="store_true",
+        help="Delete .venv before creating it again",
+    )
+    parser.add_argument(
+        "--skip-pre-commit",
+        action="store_true",
+        help="Do not install pre-commit and commit-msg hooks",
+    )
+    parser.add_argument(
+        "--python-version",
+        help="Override default dev venv Python version",
+    )
+    return parser.parse_args(argv)
+
+
+def main(argv: list[str] | None = None) -> int:
+    args = parse_args(argv)
+    versions = test_python_versions()
+    dev_version = args.python_version or default_dev_python_version()
+
+    print(f"==> pyswig dev setup ({platform.system().lower()})")
+    print(f"    test Python versions: {', '.join(versions)}")
+    print(f"    default dev venv: Python {dev_version}")
+
+    ensure_python_ssl_packages()
+    log_ssl_configuration(_base_env())
+
+    uv = ensure_uv(allow_install=not args.skip_uv_install)
+
+    missing_versions: list[str] = []
+    for version in versions:
+        if ensure_python(uv, version) is None:
+            missing_versions.append(version)
+
+    venv_ready = True
+    if not args.skip_project_venv:
+        if dev_version not in versions:
+            if ensure_python(uv, dev_version) is None and dev_version not in missing_versions:
+                missing_versions.append(dev_version)
+        venv_ready = ensure_project_venv(uv, dev_version, recreate=args.recreate_venv)
+
+    hooks_ready = True
+    if venv_ready and not args.skip_pre_commit:
+        hooks_ready = ensure_pre_commit_hooks(skip=False)
+    elif args.skip_pre_commit:
+        ensure_pre_commit_hooks(skip=True)
+
+    print("")
+    if missing_versions:
+        log_warn(f"Python version(s) not available: {', '.join(missing_versions)}")
+        log_warn(
+            "Remove them from pyproject.toml [tool.pyswig] test-python-versions if unsupported"
+        )
+    if not venv_ready and not args.skip_project_venv:
+        log_warn("default .venv was not created; fix the dev Python version or TLS settings above")
+    if not hooks_ready and not args.skip_pre_commit and venv_ready:
+        log_warn("pre-commit hooks were not installed")
+
+    if (
+        missing_versions
+        or (not venv_ready and not args.skip_project_venv)
+        or (not hooks_ready and not args.skip_pre_commit and venv_ready)
+    ):
+        print("")
+        log_warn("setup completed with warnings")
+        return 1
+
+    log_ok("development environment ready")
+    print("    run all version tests: pyswig-dev test-all")
+    print("    run default venv tests: .venv\\Scripts\\python -m pytest  (Windows)")
+    print("                            .venv/bin/python -m pytest       (Unix)")
+    print("    manual hook check:      .venv\\Scripts\\pre-commit run --all-files")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

pyswig_dev/ssl_util.py

@@ -0,0 +1,122 @@
+"""Configure TLS trust for uv, pip, and other HTTPS clients used by setup scripts."""
+
+from __future__ import annotations
+
+import subprocess
+import sys
+import tempfile
+from pathlib import Path
+
+
+def ensure_python_ssl_packages() -> None:
+    """Install certifi and optional trust helpers for the bootstrap interpreter."""
+    packages = ["certifi"]
+    if sys.version_info >= (3, 10):
+        packages.append("truststore")
+    if sys.platform == "win32":
+        packages.append("pip-system-certs")
+
+    print("[install] ensuring Python SSL certificate packages (certifi, truststore)")
+    subprocess.run(
+        [sys.executable, "-m", "pip", "install", "--user", *packages],
+        check=False,
+        text=True,
+    )
+
+
+def _certifi_bundle_path() -> str | None:
+    try:
+        import certifi
+    except ImportError:
+        return None
+    return str(certifi.where())
+
+
+def configure_ssl_environment(env: dict[str, str]) -> dict[str, str]:
+    """Return env with TLS settings for uv (OS trust store) and pip (truststore)."""
+    # uv: trust the OS certificate store. Do not set SSL_CERT_FILE here — it overrides
+    # the default source entirely and can hide corporate roots that live in the OS store.
+    env.setdefault("UV_SYSTEM_CERTS", "true")
+
+    if sys.version_info >= (3, 10):
+        env.setdefault("PIP_USE_TRUSTSTORE", "true")
+
+    return env
+
+
+def configure_ssl_fallback_bundle(env: dict[str, str]) -> Path | None:
+    """Build a merged PEM bundle (certifi + Windows roots) for a retry after TLS failures."""
+    if sys.platform != "win32":
+        return None
+
+    certifi_path = _certifi_bundle_path()
+    windows_pem = _export_windows_root_certs_pem()
+    if certifi_path is None and windows_pem is None:
+        return None
+
+    merged = Path(tempfile.gettempdir()) / "pyswig-merged-ca-bundle.pem"
+    parts: list[str] = []
+    if certifi_path:
+        parts.append(Path(certifi_path).read_text(encoding="ascii"))
+    if windows_pem:
+        parts.append(windows_pem.read_text(encoding="ascii"))
+    merged.write_text("\n".join(parts), encoding="ascii")
+    env["SSL_CERT_FILE"] = str(merged)
+    env["REQUESTS_CA_BUNDLE"] = str(merged)
+    env["CURL_CA_BUNDLE"] = str(merged)
+    return merged
+
+
+def _export_windows_root_certs_pem() -> Path | None:
+    """Export LocalMachine and CurrentUser root CAs to a temporary PEM file."""
+    destination = Path(tempfile.gettempdir()) / "pyswig-windows-root-certs.pem"
+    ps_script = """
+$dest = $args[0]
+$lines = New-Object System.Collections.Generic.List[string]
+foreach ($storePath in @('Cert:\\LocalMachine\\Root', 'Cert:\\CurrentUser\\Root')) {
+    Get-ChildItem $storePath -ErrorAction SilentlyContinue | ForEach-Object {
+        $bytes = $_.Export([System.Security.Cryptography.X509Certificates.X509ContentType]::Cert)
+        $b64 = [Convert]::ToBase64String($bytes, [System.Base64FormattingOptions]::InsertLineBreaks)
+        $lines.Add('-----BEGIN CERTIFICATE-----')
+        $lines.Add($b64)
+        $lines.Add('-----END CERTIFICATE-----')
+    }
+}
+if ($lines.Count -eq 0) { exit 1 }
+Set-Content -Path $dest -Value ($lines -join [Environment]::NewLine) -Encoding ascii
+"""
+    completed = subprocess.run(
+        [
+            "powershell",
+            "-NoProfile",
+            "-ExecutionPolicy",
+            "Bypass",
+            "-Command",
+            ps_script,
+            str(destination),
+        ],
+        check=False,
+        text=True,
+        capture_output=True,
+    )
+    if completed.returncode != 0 or not destination.is_file():
+        return None
+    return destination
+
+
+def log_ssl_configuration(env: dict[str, str]) -> None:
+    """Print which TLS-related settings are active."""
+    parts = []
+    if env.get("UV_SYSTEM_CERTS") == "true":
+        parts.append("UV_SYSTEM_CERTS=true (uv uses OS trust store)")
+    if env.get("SSL_CERT_FILE"):
+        parts.append(f"SSL_CERT_FILE={env['SSL_CERT_FILE']} (fallback bundle)")
+    if parts:
+        print("[ok]    TLS configuration:")
+        for part in parts:
+            print(f"        {part}")
+
+
+def looks_like_tls_failure(output: str) -> bool:
+    lowered = output.lower()
+    return "unknownissuer" in lowered or "certificate" in lowered or "tls" in lowered

pyswig_dev/swig_provision.py

@@ -0,0 +1,194 @@
+"""Download or build pinned SWIG versions for integration tests."""
+
+from __future__ import annotations
+
+import os
+import re
+import shutil
+import subprocess
+import sys
+import tarfile
+import urllib.error
+import urllib.request
+import zipfile
+from pathlib import Path
+
+_DOWNLOAD_BASE = "https://downloads.sourceforge.net/project/swig"
+_VERSION_LINE = re.compile(r"SWIG Version\s+(\S+)")
+
+
+class SwigProvisionError(RuntimeError):
+    """Raised when a requested SWIG version cannot be provisioned."""
+
+
+def _download(url: str, destination: Path) -> None:
+    destination.parent.mkdir(parents=True, exist_ok=True)
+    request = urllib.request.Request(url, headers={"User-Agent": "pyswig-integration-tests"})
+    try:
+        with urllib.request.urlopen(request, timeout=120) as response:
+            destination.write_bytes(response.read())
+    except urllib.error.URLError as exc:
+        raise SwigProvisionError(f"failed to download {url}: {exc}") from exc
+
+
+def read_swig_version(swig_exe: Path) -> str:
+    result = subprocess.run(
+        [str(swig_exe), "-version"],
+        capture_output=True,
+        text=True,
+        check=False,
+    )
+    if result.returncode != 0:
+        raise SwigProvisionError(f"{swig_exe} -version failed:\n{result.stderr}")
+    for line in result.stdout.splitlines():
+        match = _VERSION_LINE.search(line)
+        if match:
+            return match.group(1)
+    raise SwigProvisionError(f"could not parse SWIG version from:\n{result.stdout}")
+
+
+def find_swig_on_path(version: str) -> Path | None:
+    for directory in os_path_entries():
+        for name in ("swig.exe", "swig"):
+            candidate = directory / name
+            if not candidate.is_file():
+                continue
+            try:
+                if read_swig_version(candidate) == version:
+                    return candidate
+            except SwigProvisionError:
+                continue
+    return None
+
+
+def os_path_entries() -> list[Path]:
+    path_env = os.environ.get("PATH", "")
+    return [Path(entry) for entry in path_env.split(os.pathsep) if entry]
+
+
+def swig_install_root(swig_exe: Path) -> Path:
+    """Directory passed to the SWIG / ESYS_SWIG environment variables."""
+    return swig_exe.parent
+
+
+def swig_env(swig_exe: Path) -> dict[str, str]:
+    root = swig_install_root(swig_exe)
+    return {"SWIG": str(root), "ESYS_SWIG": str(root)}
+
+
+def ensure_swig(version: str, cache_dir: Path) -> Path:
+    """Return a SWIG executable for ``version``, downloading or building it if needed."""
+    cached = _cached_swig_exe(cache_dir, version)
+    if cached is not None:
+        return cached
+
+    on_path = find_swig_on_path(version)
+    if on_path is not None:
+        return on_path
+
+    cache_dir.mkdir(parents=True, exist_ok=True)
+    if sys.platform == "win32":
+        return _provision_swigwin(version, cache_dir)
+    return _provision_swig_unix(version, cache_dir)
+
+
+def _cached_swig_exe(cache_dir: Path, version: str) -> Path | None:
+    version_dir = cache_dir / version
+    if sys.platform == "win32":
+        candidates = sorted(version_dir.glob("swigwin-*/swig.exe"))
+    else:
+        candidates = [version_dir / "bin" / "swig"]
+    for candidate in candidates:
+        if not candidate.is_file():
+            continue
+        try:
+            if read_swig_version(candidate) == version:
+                return candidate
+        except SwigProvisionError:
+            continue
+    return None
+
+
+def _provision_swigwin(version: str, cache_dir: Path) -> Path:
+    version_dir = cache_dir / version
+    archive = version_dir / f"swigwin-{version}.zip"
+    url = f"{_DOWNLOAD_BASE}/swigwin/swigwin-{version}/swigwin-{version}.zip"
+    if not archive.is_file():
+        _download(url, archive)
+
+    extract_dir = version_dir / "extract"
+    if extract_dir.is_dir():
+        shutil.rmtree(extract_dir)
+    extract_dir.mkdir(parents=True, exist_ok=True)
+    with zipfile.ZipFile(archive) as zf:
+        zf.extractall(extract_dir)
+
+    matches = sorted(extract_dir.glob("swigwin-*/swig.exe"))
+    if not matches:
+        matches = sorted(extract_dir.rglob("swig.exe"))
+    if not matches:
+        raise SwigProvisionError(f"swig.exe not found after extracting {archive}")
+
+    swig_exe = matches[0]
+    if read_swig_version(swig_exe) != version:
+        raise SwigProvisionError(f"expected SWIG {version}, got {read_swig_version(swig_exe)}")
+    return swig_exe
+
+
+def _provision_swig_unix(version: str, cache_dir: Path) -> Path:
+    version_dir = cache_dir / version
+    install_prefix = version_dir
+    archive = version_dir / f"swig-{version}.tar.gz"
+    url = f"{_DOWNLOAD_BASE}/swig/swig-{version}/swig-{version}.tar.gz"
+    if not archive.is_file():
+        _download(url, archive)
+
+    source_root = version_dir / f"swig-{version}"
+    if not source_root.is_dir():
+        with tarfile.open(archive, "r:gz") as tar:
+            tar.extractall(version_dir)
+    if not source_root.is_dir():
+        raise SwigProvisionError(f"source tree not found in {archive}")
+
+    build_dir = version_dir / "build"
+    if build_dir.is_dir():
+        shutil.rmtree(build_dir)
+    build_dir.mkdir(parents=True, exist_ok=True)
+
+    configure = source_root / "configure"
+    if not configure.is_file():
+        raise SwigProvisionError(f"{configure} not found; cannot build SWIG {version}")
+
+    prefix_arg = str(install_prefix.resolve())
+    completed = subprocess.run(
+        [str(configure), f"--prefix={prefix_arg}"],
+        cwd=str(build_dir),
+        capture_output=True,
+        text=True,
+        check=False,
+    )
+    if completed.returncode != 0:
+        raise SwigProvisionError(
+            f"SWIG {version} configure failed:\n{completed.stdout}\n{completed.stderr}"
+        )
+
+    for args in (["make", "-j4"], ["make", "install"]):
+        completed = subprocess.run(
+            args,
+            cwd=str(build_dir),
+            capture_output=True,
+            text=True,
+            check=False,
+        )
+        if completed.returncode != 0:
+            label = " ".join(args)
+            raise SwigProvisionError(
+                f"SWIG {version} {label} failed:\n{completed.stdout}\n{completed.stderr}"
+            )
+
+    swig_exe = install_prefix / "bin" / "swig"
+    if not swig_exe.is_file():
+        raise SwigProvisionError(f"SWIG {version} install did not produce {swig_exe}")
+    if read_swig_version(swig_exe) != version:
+        raise SwigProvisionError(f"expected SWIG {version}, got {read_swig_version(swig_exe)}")
+    return swig_exe

pyswig_dev/test_all.py

@@ -0,0 +1,123 @@
+#!/usr/bin/env python3
+"""Run the pyswig test suite on every configured Python version."""
+
+from __future__ import annotations
+
+import argparse
+import os
+import subprocess
+
+from pyswig_dev.config import coverage_python_version, repo_root, test_python_versions
+from pyswig_dev.ssl_util import configure_ssl_environment
+from pyswig_dev.uv_util import uv_command, uv_install_hint
+
+ROOT = repo_root()
+
+
+def _base_env() -> dict[str, str]:
+    return configure_ssl_environment(os.environ.copy())
+
+
+def python_is_available(uv: list[str], python_version: str) -> bool:
+    completed = subprocess.run(
+        [*uv, "python", "find", python_version],
+        cwd=ROOT,
+        capture_output=True,
+        text=True,
+        check=False,
+        env=_base_env(),
+    )
+    return completed.returncode == 0
+
+
+def run_pytest(
+    uv: list[str],
+    python_version: str,
+    *,
+    with_coverage: bool,
+    pytest_args: list[str],
+) -> int:
+    command = [*uv, "run", "--python", python_version, "--", "python", "-m", "pytest"]
+    if with_coverage:
+        command.extend(
+            [
+                "--cov=pyswig",
+                "--cov-report=term-missing",
+                "--cov-report=html:public/htmlcov",
+            ]
+        )
+    command.extend(pytest_args)
+    print(
+        f"\n==> pytest on Python {python_version}" + (" (with coverage)" if with_coverage else "")
+    )
+    completed = subprocess.run(command, cwd=ROOT, check=False, env=_base_env())
+    return completed.returncode
+
+
+def parse_args(argv: list[str] | None = None) -> argparse.Namespace:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument(
+        "--write-badges",
+        action="store_true",
+        help="Write public/pythonXYZ-badge.svg files for each tested version",
+    )
+    parser.add_argument(
+        "--pytest-args",
+        nargs=argparse.REMAINDER,
+        default=["-q"],
+        help="Extra arguments forwarded to pytest (default: -q)",
+    )
+    return parser.parse_args(argv)
+
+
+def main(argv: list[str] | None = None) -> int:
+    from scripts.write_version_badge import write_badge
+
+    args = parse_args(argv)
+    uv = uv_command(install_hint=uv_install_hint())
+    versions = test_python_versions()
+    coverage_version = coverage_python_version()
+    failures: list[str] = []
+    skipped: list[str] = []
+
+    if args.write_badges:
+        (ROOT / "public").mkdir(parents=True, exist_ok=True)
+
+    for version in versions:
+        if not python_is_available(uv, version):
+            print(f"[skip]  Python {version} not available to uv; skipping tests")
+            skipped.append(version)
+            continue
+
+        if args.write_badges:
+            write_badge(python_version=version, status="pending")
+
+        exit_code = run_pytest(
+            uv,
+            version,
+            with_coverage=(version == coverage_version),
+            pytest_args=args.pytest_args,
+        )
+
+        if args.write_badges:
+            write_badge(
+                python_version=version,
+                status="ok" if exit_code == 0 else "failed",
+            )
+
+        if exit_code != 0:
+            failures.append(version)
+
+    print("")
+    if skipped:
+        print(f"[skip]  unavailable Python version(s): {', '.join(skipped)}")
+    if failures:
+        print(f"[failed] Python version(s): {', '.join(failures)}")
+        return 1
+
+    print("[ok]    all configured Python versions passed")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

pyswig_dev/uv_util.py

@@ -0,0 +1,77 @@
+"""Resolve how to invoke uv on the current machine."""
+
+from __future__ import annotations
+
+import os
+import shutil
+import subprocess
+import sys
+from pathlib import Path
+
+
+def find_uv_command() -> list[str] | None:
+    """Return argv prefix to run uv when it is already available."""
+    binary = shutil.which("uv")
+    if binary:
+        return [binary]
+
+    module_check = subprocess.run(
+        [sys.executable, "-m", "uv", "--version"],
+        text=True,
+        capture_output=True,
+        check=False,
+    )
+    if module_check.returncode == 0:
+        return [sys.executable, "-m", "uv"]
+
+    return None
+
+
+def describe_uv_command(command: list[str]) -> str:
+    """Human-readable location for log messages."""
+    if len(command) == 1:
+        return command[0]
+    return f"{command[0]} -m uv"
+
+
+def uv_install_hint() -> str:
+    return (
+        "uv is required but was not found after automatic installation attempts.\n"
+        "Install manually, then re-run: pyswig-dev setup\n"
+        "  - pip (user): python -m pip install --user uv\n"
+        "  - Official installer: https://docs.astral.sh/uv/getting-started/installation/"
+    )
+
+
+def uv_command(*, install_hint: str) -> list[str]:
+    """Return argv prefix to run uv, or exit with install_hint."""
+    found = find_uv_command()
+    if found:
+        return found
+    raise SystemExit(install_hint)
+
+
+def augment_path_for_uv() -> None:
+    """Add common uv install locations to PATH for the current process."""
+    candidates: list[Path] = [
+        Path.home() / ".local" / "bin",
+        Path.home() / ".cargo" / "bin",
+    ]
+    if sys.platform == "win32":
+        roaming = os.environ.get("APPDATA")
+        if roaming:
+            scripts = (
+                Path(roaming)
+                / "Python"
+                / f"Python{sys.version_info.major}{sys.version_info.minor}"
+                / "Scripts"
+            )
+            candidates.append(scripts)
+        local_app = os.environ.get("LOCALAPPDATA")
+        if local_app:
+            candidates.append(Path(local_app) / "uv")
+
+    existing = os.environ.get("PATH", "")
+    additions = [str(path) for path in candidates if path.is_dir()]
+    if additions:
+        os.environ["PATH"] = os.pathsep.join(additions + [existing])

pyswig_dev-0.2.0.dist-info/METADATA

@@ -0,0 +1,43 @@
+Metadata-Version: 2.4
+Name: pyswig-dev
+Version: 0.2.0
+Summary: Development tooling for PySwig wrapper authors
+Author-email: Michel Gillet <michel.gillet@libesys.org>
+License-Expression: MIT
+Project-URL: Homepage, https://pyswig.org
+Project-URL: Repository, https://gitlab.com/libesys/tools/pyswig.git
+Keywords: swig,development,tooling
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Software Development :: Build Tools
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE.txt
+Requires-Dist: pyswig==0.2.0
+Requires-Dist: tomli>=2.0; python_version < "3.11"
+Dynamic: license-file
+
+# pyswig-dev
+
+Development tooling for [PySwig](https://pyswig.org) wrapper authors:
+
+- `pyswig-dev setup` — bootstrap uv, Python versions, `.venv`, pre-commit hooks
+- `pyswig-dev test-all` — run pytest on every configured Python version
+
+Install from PyPI (pulls **pyswig** automatically):
+
+```bash
+pip install pyswig-dev
+```
+
+From a git clone (editable, for PySwig contributors):
+
+```bash
+pip install -e packages/pyswig[contributor] -e packages/pyswig-dev
+pyswig-dev setup
+```
+
+Release versions are lockstep with **pyswig** (same tag, e.g. `0.1.4`).

pyswig_dev-0.2.0.dist-info/RECORD

@@ -0,0 +1,14 @@
+pyswig_dev/__init__.py,sha256=oy2BLOPxyVMChKTlmdJd16ArMh8MK47d8bE6njuPiFw,132
+pyswig_dev/cli.py,sha256=mzc3ru577QzDnd-u8PTzlbt8Pn8qIGK78mpzJLJnZdY,816
+pyswig_dev/config.py,sha256=j0SeiS6j9S8xGWcRL-AgZOfGQAp69luTuN6A_Jf2LyQ,3811
+pyswig_dev/setup_env.py,sha256=VSgprziFpO0tuiuBA1M4qj84YFA49CE7axmtvNTcKRw,13164
+pyswig_dev/ssl_util.py,sha256=R6o3y-8woQSEn8UeC-6BsOs7SoLrQruhdzs0P56umAY,4209
+pyswig_dev/swig_provision.py,sha256=teK0yse5CSy9hdUbYq50oWp669A_S4RagVlhIHA7w8s,6483
+pyswig_dev/test_all.py,sha256=TctvwOkhxJ1Uw_QNz0Cc-sHtuo3B9FEbhMXCI3gU0s4,3490
+pyswig_dev/uv_util.py,sha256=0O70jdo4rmzo2EAEQQ5ChXWMfj9Wyem2kBSa_FnIGNE,2259
+pyswig_dev-0.2.0.dist-info/licenses/LICENSE.txt,sha256=7HC5WkxCB_q7rDY3pCKS9FBnyIrhuPCb9SNWTm1bjgw,1069
+pyswig_dev-0.2.0.dist-info/METADATA,sha256=F3pKrDjK9XCepMt8UybmTdgnBfL3VG6duzsrLaTbQ4c,1391
+pyswig_dev-0.2.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+pyswig_dev-0.2.0.dist-info/entry_points.txt,sha256=4OxDafhwtYqQH7j2Y_y3bssEeSVDNjoYaVXHuvhInpw,51
+pyswig_dev-0.2.0.dist-info/top_level.txt,sha256=YPpoCGOJ2sZ2qYVjiYhDH42KP5vcy4RAfg0St726AkM,11
+pyswig_dev-0.2.0.dist-info/RECORD,,

pyswig_dev-0.2.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

pyswig_dev-0.2.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+pyswig-dev = pyswig_dev.cli:main

pyswig_dev-0.2.0.dist-info/licenses/LICENSE.txt

@@ -0,0 +1,20 @@
+MIT License
+
+Copyright (c) 2020 Michel Gillet
+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.

pyswig_dev-0.2.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+pyswig_dev