FEAT: Modernize build system with pyproject.toml and custom build backend

.github/workflows/lint-check.yml

@@ -12,7 +12,6 @@ on:
  - '**.hpp'
  - '.github/workflows/lint-check.yml'
  - 'pyproject.toml'
- - '.flake8'
  - '.clang-format'
  push:
  branches:
@@ -39,7 +38,7 @@ jobs:
  - name: Install dependencies
  run: |
  python -m pip install --upgrade pip
- pip install black flake8 pylint autopep8
+ pip install black pylint autopep8
  if [ -f requirements.txt ]; then pip install -r requirements.txt; fi
 
  - name: Check Python formatting with Black
@@ -51,15 +50,6 @@ jobs:
  }
  echo "::endgroup::"
 
- - name: Lint with Flake8
- run: |
- echo "::group::Flake8 Linting"
- flake8 mssql_python/ tests/ --max-line-length=100 --extend-ignore=E203,W503,E501,E722,F401,F841,W293,W291,F541,F811,E402,E711,E712,E721,F821 --count --statistics || {
- echo "::warning::Flake8 found linting issues (informational only, not blocking)"
- }
- echo "::endgroup::"
- continue-on-error: true
-
  - name: Lint with Pylint
  run: |
  echo "::group::Pylint Analysis"
@@ -159,7 +149,7 @@ jobs:
  echo "❌ **Python Formatting (Black):** FAILED - Please run Black formatter" >> $GITHUB_STEP_SUMMARY
  fi
 
- echo "ℹ️ **Python Linting (Flake8, Pylint):** Informational only" >> $GITHUB_STEP_SUMMARY
+ echo "ℹ️ **Python Linting (Pylint):** Informational only" >> $GITHUB_STEP_SUMMARY
  echo "ℹ️ **C++ Linting (clang-format, cpplint):** Informational only" >> $GITHUB_STEP_SUMMARY
 
  echo "" >> $GITHUB_STEP_SUMMARY

.gitignore

@@ -63,3 +63,4 @@ build/
 
 # learning files
 learnings/
+.coverage

build_backend/__init__.py

@@ -0,0 +1,19 @@
+"""
+build_backend - Build system for mssql-python native extensions.
+
+This package provides:
+1. A CLI tool: `python -m build_backend`
+2. A PEP 517 build backend that auto-compiles ddbc_bindings
+
+Usage:
+ python -m build_backend # Compile ddbc_bindings only
+ python -m build_backend --arch arm64 # Specify architecture (Windows)
+ python -m build_backend --coverage # Enable coverage (Linux)
+ python -m build # Compile + create wheel (automatic)
+"""
+
+from .compiler import compile_ddbc
+from .platform_utils import get_platform_info
+
+__all__ = ["compile_ddbc", "get_platform_info"]
+__version__ = "1.3.0"

build_backend/__main__.py

@@ -0,0 +1,84 @@
+"""
+CLI entry point for build_backend.
+
+Usage:
+ python -m build_backend # Compile ddbc_bindings
+ python -m build_backend --arch arm64 # Specify architecture (Windows)
+ python -m build_backend --coverage # Enable coverage (Linux)
+ python -m build_backend --help # Show help
+"""
+
+import argparse
+import sys
+
+from . import __version__
+from .compiler import compile_ddbc
+from .platform_utils import get_platform_info
+
+
+def main() -> int:
+ """Main entry point for the CLI."""
+ parser = argparse.ArgumentParser(
+ prog="python -m build_backend",
+ description="Compile ddbc_bindings native extension for mssql-python",
+ formatter_class=argparse.RawDescriptionHelpFormatter,
+ epilog="""
+Examples:
+ python -m build_backend # Build for current platform
+ python -m build_backend --arch arm64 # Build for ARM64 (Windows)
+ python -m build_backend --coverage # Build with coverage (Linux)
+ python -m build_backend --quiet # Build without output
+ """,
+ )
+
+ parser.add_argument(
+ "--arch", "-a",
+ choices=["x64", "x86", "arm64", "x86_64", "aarch64", "universal2"],
+ help="Target architecture (Windows: x64, x86, arm64)",
+ )
+
+ parser.add_argument(
+ "--coverage", "-c",
+ action="store_true",
+ help="Enable coverage instrumentation (Linux only)",
+ )
+
+ parser.add_argument(
+ "--quiet", "-q",
+ action="store_true",
+ help="Suppress build output",
+ )
+
+ parser.add_argument(
+ "--version", "-V",
+ action="version",
+ version=f"%(prog)s {__version__}",
+ )
+
+ args = parser.parse_args()
+
+ # Show platform info
+ if not args.quiet:
+ arch, platform_tag = get_platform_info()
+ print(f"[build_backend] Platform: {sys.platform}")
+ print(f"[build_backend] Architecture: {arch}")
+ print(f"[build_backend] Platform tag: {platform_tag}")
+ print()
+
+ try:
+ compile_ddbc(
+ arch=args.arch,
+ coverage=args.coverage,
+ verbose=not args.quiet,
+ )
+ return 0
+ except FileNotFoundError as e:
+ print(f"Error: {e}", file=sys.stderr)
+ return 1
+ except RuntimeError as e:
+ print(f"Build failed: {e}", file=sys.stderr)
+ return 1
+
+
+if __name__ == "__main__":
+ sys.exit(main())

build_backend/compiler.py

@@ -0,0 +1,135 @@
+"""Core compiler logic for ddbc_bindings.
+
+Locates and runs the platform-specific build script
+(``build.sh`` / ``build.bat``) in ``mssql_python/pybind/``.
+"""
+
+import sys
+import subprocess
+from pathlib import Path
+from typing import Optional
+
+from .platform_utils import get_platform_info
+
+
+def find_pybind_dir() -> Path:
+ """Find the pybind directory containing build scripts."""
+ # Try relative to this file first (for installed package)
+ possible_paths = [
+ Path(__file__).parent.parent / "mssql_python" / "pybind",
+ Path.cwd() / "mssql_python" / "pybind",
+ ]
+
+ # Check for platform-appropriate build script
+ build_script = "build.bat" if sys.platform.startswith("win") else "build.sh"
+
+ for path in possible_paths:
+ if path.exists() and (path / build_script).exists():
+ return path
+
+ raise FileNotFoundError(
+ f"Could not find mssql_python/pybind directory with {build_script}. "
+ "Make sure you're running from the project root."
+ )
+
+
+def compile_ddbc(
+ arch: Optional[str] = None,
+ coverage: bool = False,
+ verbose: bool = True,
+) -> bool:
+ """
+ Compile ddbc_bindings using the platform-specific build script.
+
+ Args:
+ arch: Target architecture (Windows only: x64, x86, arm64)
+ coverage: Enable coverage instrumentation (Linux/macOS only)
+ verbose: Print build output
+
+ Returns:
+ True if build succeeded, False otherwise
+
+ Raises:
+ FileNotFoundError: If build script is not found
+ RuntimeError: If build fails
+ """
+ pybind_dir = find_pybind_dir()
+
+ if arch is None:
+ arch, _ = get_platform_info()
+
+ if sys.platform.startswith("win"):
+ return _run_windows_build(pybind_dir, arch, verbose)
+ else:
+ return _run_unix_build(pybind_dir, coverage, verbose)
+
+
+def _run_windows_build(pybind_dir: Path, arch: str, verbose: bool) -> bool:
+ """Run build.bat on Windows."""
+ build_script = pybind_dir / "build.bat"
+ if not build_script.exists():
+ raise FileNotFoundError(f"Build script not found: {build_script}")
+
+ cmd = [str(build_script), arch]
+
+ if verbose:
+ print(f"[build_backend] Running: {' '.join(cmd)}")
+ print(f"[build_backend] Working directory: {pybind_dir}")
+
+ result = subprocess.run(
+ cmd,
+ cwd=pybind_dir,
+ check=False,
+ capture_output=not verbose,
+ )
+
+ if result.returncode != 0:
+ if not verbose:
+ if result.stdout:
+ print(result.stdout.decode(), file=sys.stderr)
+ if result.stderr:
+ print(result.stderr.decode(), file=sys.stderr)
+ raise RuntimeError(f"build.bat failed with exit code {result.returncode}")
+
+ if verbose:
+ print("[build_backend] Windows build completed successfully!")
+
+ return True
+
+
+def _run_unix_build(pybind_dir: Path, coverage: bool, verbose: bool) -> bool:
+ """Run build.sh on macOS/Linux."""
+ build_script = pybind_dir / "build.sh"
+ if not build_script.exists():
+ raise FileNotFoundError(f"Build script not found: {build_script}")
+
+ # Make sure the script is executable
+ build_script.chmod(0o755)
+
+ cmd = ["bash", str(build_script)]
+ if coverage:
+ cmd.append("--coverage")
+
+ if verbose:
+ print(f"[build_backend] Running: {' '.join(cmd)}")
+ print(f"[build_backend] Working directory: {pybind_dir}")
+
+ result = subprocess.run(
+ cmd,
+ cwd=pybind_dir,
+ check=False,
+ capture_output=not verbose,
+ )
+
+ if result.returncode != 0:
+ if not verbose:
+ if result.stdout:
+ print(result.stdout.decode(), file=sys.stderr)
+ if result.stderr:
+ print(result.stderr.decode(), file=sys.stderr)
+ raise RuntimeError(f"build.sh failed with exit code {result.returncode}")
+
+ if verbose:
+ print("[build_backend] Unix build completed successfully!")
+
+ return True