xtensor-python/src/xtensor_python/build_helpers.py at master · maxstidbits/xtensor-python

401 lines (325 loc) · 11.6 KB
"""Build helpers for xtensor-python.

This module provides utilities for building C++ extensions that use xtensor-python,
including functions to get include directories, compiler flags, and pre-configured
extension classes.
"""

import os
import platform
import sys
import warnings
from pathlib import Path
from typing import List, Dict, Optional, Union

try:
    import numpy as np
except ImportError:
    np = None

try:
    from pybind11 import get_cmake_dir as pybind11_get_cmake_dir
    from pybind11.setup_helpers import Pybind11Extension, build_ext
    from pybind11.setup_helpers import ParallelCompile
except ImportError:
    # Fallback for older pybind11 versions
    try:
        from setuptools import Extension as Pybind11Extension
        from setuptools.command.build_ext import build_ext
        ParallelCompile = None
        pybind11_get_cmake_dir = None
    except ImportError:
        Pybind11Extension = None
        build_ext = None
        ParallelCompile = None
        pybind11_get_cmake_dir = None


def get_include_dirs() -> List[str]:
    """Get all required include directories for xtensor-python.
    
    Returns:
        List of include directory paths
        
    Raises:
        ImportError: If required dependencies are not available
    """
    include_dirs = []
    
    # Add xtensor-python include directory
    package_dir = Path(__file__).parent
    xtensor_python_include = str(package_dir / "include")
    include_dirs.append(xtensor_python_include)
    
    # Add NumPy include directory
    if np is not None:
        numpy_include = np.get_include()
        include_dirs.append(numpy_include)
    else:
        raise ImportError(
            "NumPy is required for xtensor-python. "
            "Please install NumPy: pip install numpy"
        )
    
    # Add pybind11 include directory
    try:
        import pybind11
        pybind11_include = pybind11.get_include()
        include_dirs.append(pybind11_include)
    except ImportError:
        raise ImportError(
            "pybind11 is required for xtensor-python. "
            "Please install pybind11: pip install pybind11"
        )
    
    return include_dirs


def get_compiler_flags() -> List[str]:
    """Get platform-specific compiler flags for C++17 and xtensor-python.
    
    Returns:
        List of compiler flags
    """
    flags = []
    
    # C++17 standard
    if platform.system() == "Windows":
        # MSVC flags
        flags.extend(["/std:c++17", "/EHsc"])
        # Disable some MSVC warnings that are common with xtensor
        flags.extend([
            "/wd4244",  # conversion warnings
            "/wd4267",  # size_t conversion warnings
            "/wd4996",  # deprecated function warnings
        ])
    else:
        # GCC/Clang flags
        flags.extend(["-std=c++17"])
        
        # macOS specific flags
        if platform.system() == "Darwin":
            # Use libc++ on macOS
            flags.extend(["-stdlib=libc++"])
            
            # Handle macOS deployment target
            macos_target = os.environ.get("MACOSX_DEPLOYMENT_TARGET")
            if macos_target:
                flags.append(f"-mmacosx-version-min={macos_target}")
        
        # Optimization and warning flags
        flags.extend([
            "-O3",
            "-ffast-math",
            "-march=native",  # Optimize for current CPU
        ])
        
        # Disable some warnings that are common with xtensor
        flags.extend([
            "-Wno-unused-variable",
            "-Wno-unused-parameter",
        ])
    
    return flags


def get_numpy_flags() -> List[str]:
    """Get NumPy C API specific compiler flags.
    
    Returns:
        List of NumPy-specific compiler flags
    """
    flags = []
    
    # NumPy C API version
    flags.append("-DNPY_NO_DEPRECATED_API=NPY_1_7_API_VERSION")
    
    # Import array macro handling
    flags.append("-DFORCE_IMPORT_ARRAY")
    
    return flags


def get_link_flags() -> List[str]:
    """Get platform-specific linker flags.
    
    Returns:
        List of linker flags
    """
    flags = []
    
    if platform.system() == "Darwin":
        # macOS specific linker flags
        flags.extend(["-stdlib=libc++"])
    elif platform.system() == "Linux":
        # Linux specific flags if needed
        pass
    elif platform.system() == "Windows":
        # Windows specific flags if needed
        pass
    
    return flags


def get_define_macros() -> List[tuple]:
    """Get preprocessor macro definitions.
    
    Returns:
        List of (name, value) tuples for preprocessor macros
    """
    macros = []
    
    # Version information
    try:
        from ._version import get_version_info
        version_info = get_version_info()
        macros.extend([
            ("XTENSOR_PYTHON_VERSION_MAJOR", str(version_info.major)),
            ("XTENSOR_PYTHON_VERSION_MINOR", str(version_info.minor)),
            ("XTENSOR_PYTHON_VERSION_PATCH", str(version_info.patch)),
        ])
    except ImportError:
        # Fallback if version module is not available
        pass
    
    # Platform-specific macros
    if platform.system() == "Windows":
        macros.append(("WIN32_LEAN_AND_MEAN", None))
    
    return macros


class BuildExtension(build_ext):
    """Enhanced build_ext class with xtensor-python optimizations.
    
    This class extends the standard build_ext to provide better defaults
    and optimizations for xtensor-python extensions.
    """
    
    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        
        # Enable parallel compilation if available
        if ParallelCompile is not None:
            ParallelCompile("NPY_NUM_BUILD_JOBS", needs_recompile=lambda: False).install()
    
    def build_extensions(self):
        """Build extensions with xtensor-python optimizations."""
        # Set compiler-specific options
        compiler_type = self.compiler.compiler_type
        
        if compiler_type == "msvc":
            # MSVC specific optimizations
            for ext in self.extensions:
                ext.extra_compile_args.extend([
                    "/O2",  # Optimize for speed
                    "/GL",  # Whole program optimization
                ])
                ext.extra_link_args.extend([
                    "/LTCG",  # Link-time code generation
                ])
        elif compiler_type in ("unix", "cygwin", "mingw32"):
            # GCC/Clang optimizations
            for ext in self.extensions:
                # Add optimization flags if not already present
                if "-O3" not in ext.extra_compile_args:
                    ext.extra_compile_args.append("-O3")
                
                # Enable link-time optimization
                if "-flto" not in ext.extra_compile_args:
                    ext.extra_compile_args.append("-flto")
                    ext.extra_link_args.append("-flto")
        
        super().build_extensions()


def create_extension(
    name: str,
    sources: List[str],
    include_dirs: Optional[List[str]] = None,
    extra_compile_args: Optional[List[str]] = None,
    extra_link_args: Optional[List[str]] = None,
    define_macros: Optional[List[tuple]] = None,
    language: str = "c++",
    **kwargs
) -> Union[Pybind11Extension, object]:
    """Create a pre-configured extension for xtensor-python.
    
    Args:
        name: Extension module name
        sources: List of source file paths
        include_dirs: Additional include directories
        extra_compile_args: Additional compiler flags
        extra_link_args: Additional linker flags
        define_macros: Additional preprocessor macros
        language: Programming language (default: 'c++')
        **kwargs: Additional arguments passed to Extension constructor
        
    Returns:
        Configured Extension object
        
    Raises:
        ImportError: If required dependencies are not available
    """
    if Pybind11Extension is None:
        raise ImportError(
            "Could not import extension class. "
            "Please install pybind11: pip install pybind11"
        )
    
    # Combine include directories
    all_include_dirs = get_include_dirs()
    if include_dirs:
        all_include_dirs.extend(include_dirs)
    
    # Combine compiler flags
    all_compile_args = get_compiler_flags()
    all_compile_args.extend(get_numpy_flags())
    if extra_compile_args:
        all_compile_args.extend(extra_compile_args)
    
    # Combine linker flags
    all_link_args = get_link_flags()
    if extra_link_args:
        all_link_args.extend(extra_link_args)
    
    # Combine preprocessor macros
    all_define_macros = get_define_macros()
    if define_macros:
        all_define_macros.extend(define_macros)
    
    # Create extension
    extension = Pybind11Extension(
        name=name,
        sources=sources,
        include_dirs=all_include_dirs,
        extra_compile_args=all_compile_args,
        extra_link_args=all_link_args,
        define_macros=all_define_macros,
        language=language,
        **kwargs
    )
    
    return extension


def get_build_requirements() -> List[str]:
    """Get the list of build requirements for xtensor-python.
    
    Returns:
        List of package requirements
    """
    requirements = [
        "numpy>=2.0",
        "pybind11>=2.6.1,<4",
    ]
    
    return requirements


def check_dependencies() -> Dict[str, bool]:
    """Check if all required dependencies are available.
    
    Returns:
        Dictionary mapping dependency names to availability status
    """
    dependencies = {}
    
    # Check NumPy
    try:
        import numpy
        dependencies["numpy"] = True
        dependencies["numpy_version"] = numpy.__version__
    except ImportError:
        dependencies["numpy"] = False
    
    # Check pybind11
    try:
        import pybind11
        dependencies["pybind11"] = True
        dependencies["pybind11_version"] = pybind11.__version__
    except ImportError:
        dependencies["pybind11"] = False
    
    # Check compiler
    try:
        from distutils import ccompiler
        compiler = ccompiler.new_compiler()
        dependencies["compiler"] = True
        dependencies["compiler_type"] = compiler.compiler_type
    except Exception:
        dependencies["compiler"] = False
    
    return dependencies


def print_build_info():
    """Print build environment information for debugging."""
    print("xtensor-python Build Information")
    print("=" * 40)
    
    # Version information
    try:
        from ._version import __version__, __version_info__
        print(f"xtensor-python version: {__version__}")
        print(f"Version info: {__version_info__}")
    except ImportError:
        print("xtensor-python version: Unknown")
    
    # Platform information
    print(f"Platform: {platform.system()} {platform.release()}")
    print(f"Architecture: {platform.machine()}")
    print(f"Python: {sys.version}")
    
    # Dependencies
    deps = check_dependencies()
    print("\nDependencies:")
    for name, available in deps.items():
        if name.endswith("_version") or name.endswith("_type"):
            continue
        status = "✓" if available else "✗"
        print(f"  {status} {name}")
        if available and f"{name}_version" in deps:
            print(f"    Version: {deps[f'{name}_version']}")
    
    # Include directories
    try:
        includes = get_include_dirs()
        print(f"\nInclude directories:")
        for inc in includes:
            print(f"  {inc}")
    except Exception as e:
        print(f"\nInclude directories: Error - {e}")
    
    # Compiler flags
    try:
        flags = get_compiler_flags()
        print(f"\nCompiler flags:")
        for flag in flags:
            print(f"  {flag}")
    except Exception as e:
        print(f"\nCompiler flags: Error - {e}")
Provide feedback

Saved searches

Use saved searches to filter your results more quickly

Expand file tree

Search code, repositories, users, issues, pull requests...

FilesExpand file tree

build_helpers.py

Latest commit

History

build_helpers.py

File metadata and controls

Expand file tree
