"""xtensor-python: Python bindings for the xtensor C++ multi-dimensional array library.

This package provides Python bindings and build utilities for xtensor-python,

a header-only C++ library that enables seamless interoperability between

NumPy arrays and xtensor expressions.

Key Features:

- Header-only C++ library for NumPy/xtensor interoperability

- Build helpers for creating C++ extensions

- CMake integration utilities

- Version management and dependency checking

Basic Usage:

>>> import xtensor_python

>>> print(xtensor_python.__version__)

>>> include_dirs = xtensor_python.get_include_dirs()

>>> extension = xtensor_python.create_extension('my_module', ['src/my_module.cpp'])

For CMake projects:

>>> import xtensor_python.cmake_helpers as cmake

>>> cmake.print_cmake_info()

>>> cmake.generate_cmake_config('/path/to/cmake/config')

"""

# Import version information first

try:

from ._version import (

__version__,

__version_info__,

version,

version_info,

get_version_info,

get_version_string,

VersionInfo,

)

except ImportError as e:

# Fallback if version module fails to import

__version__ = "unknown"

__version_info__ = None

version = __version__

version_info = __version_info__

def get_version_info():

raise ImportError(f"Version information unavailable: {e}")

def get_version_string():

return __version__

VersionInfo = None

# Import build helpers

try:

from .build_helpers import (

get_include_dirs,

get_compiler_flags,

get_numpy_flags,

get_link_flags,

get_define_macros,

create_extension,

BuildExtension,

get_build_requirements,

check_dependencies,

print_build_info,

)

except ImportError as e:

# Create stub functions if build helpers fail to import

def get_include_dirs():

raise ImportError(f"Build helpers unavailable: {e}")

def get_compiler_flags():

raise ImportError(f"Build helpers unavailable: {e}")

def get_numpy_flags():

raise ImportError(f"Build helpers unavailable: {e}")

def get_link_flags():

raise ImportError(f"Build helpers unavailable: {e}")

def get_define_macros():

raise ImportError(f"Build helpers unavailable: {e}")

def create_extension(*args, **kwargs):

raise ImportError(f"Build helpers unavailable: {e}")

BuildExtension = None

def get_build_requirements():

return ["numpy>=2.0", "pybind11>=2.6.1,<4"]

def check_dependencies():

return {"error": str(e)}

def print_build_info():

print(f"Build helpers unavailable: {e}")

# Import CMake helpers

try:

from .cmake_helpers import (

get_cmake_dir,

get_cmake_variables,

generate_cmake_config,

get_cmake_prefix_path,

get_cmake_find_commands,

print_cmake_info,

create_cmake_example,

)

except ImportError as e:

# Create stub functions if CMake helpers fail to import

def get_cmake_dir():

raise ImportError(f"CMake helpers unavailable: {e}")

def get_cmake_variables():

raise ImportError(f"CMake helpers unavailable: {e}")

def generate_cmake_config(*args, **kwargs):

raise ImportError(f"CMake helpers unavailable: {e}")

def get_cmake_prefix_path():

raise ImportError(f"CMake helpers unavailable: {e}")

def get_cmake_find_commands():

raise ImportError(f"CMake helpers unavailable: {e}")

def print_cmake_info():

print(f"CMake helpers unavailable: {e}")

def create_cmake_example(*args, **kwargs):

raise ImportError(f"CMake helpers unavailable: {e}")

# Package metadata

__author__ = "Wolf Vollprecht, Johan Mabille, Sylvain Corlay"

__email__ = "info@quantstack.net"

__license__ = "BSD-3-Clause"

__url__ = "https://github.com/xtensor-stack/xtensor-python"

__description__ = "Python bindings for the xtensor C++ multi-dimensional array library"

# Backward compatibility aliases for common functions

# These maintain compatibility with existing usage patterns

def get_include():

"""Get the main xtensor-python include directory.

Returns:

Path to the xtensor-python include directory

Note:

This is a backward compatibility alias. Use get_include_dirs() for

all required include directories.

"""

import os

from pathlib import Path

package_dir = Path(__file__).parent

return str(package_dir / "include")

def get_cmake_include_dir():

"""Get the CMake include directory.

Returns:

Path to the CMake configuration directory

Note:

This is a backward compatibility alias. Use get_cmake_dir() instead.

"""

return get_cmake_dir()

# Convenience functions for common operations

def setup_extension(name, sources, **kwargs):

"""Convenience function to create a fully configured extension.

This is a high-level wrapper around create_extension() that provides

sensible defaults for most use cases.

Args:

name: Extension module name

sources: List of source file paths

**kwargs: Additional arguments passed to create_extension()

Returns:

Configured Extension object

"""

return create_extension(name, sources, **kwargs)

def get_all_include_dirs():

"""Get all include directories needed for xtensor-python.

Returns:

List of all required include directory paths

Note:

This is an alias for get_include_dirs() for clarity.

"""

return get_include_dirs()

def print_info():

"""Print comprehensive information about xtensor-python installation.

This function prints version information, build configuration,

dependencies, and usage examples.

"""

print("xtensor-python Package Information")

print("=" * 50)

# Version information

print(f"Version: {__version__}")

if __version_info__:

print(f"Version info: {__version_info__}")

# Package information

print(f"Author: {__author__}")

print(f"License: {__license__}")

print(f"URL: {__url__}")

# Include directory

try:

include_dir = get_include()

print(f"Include directory: {include_dir}")

except Exception as e:

print(f"Include directory: Error - {e}")

print("\n" + "=" * 50)

# Build information

try:

print_build_info()

except Exception as e:

print(f"Build info error: {e}")

print("\n" + "=" * 50)

# CMake information

try:

print_cmake_info()

except Exception as e:

print(f"CMake info error: {e}")

def get_header_files():

"""Get list of all C++ header files included in the package.

Returns:

List of header file paths

"""

from pathlib import Path

package_dir = Path(__file__).parent

header_dir = package_dir / "include" / "xtensor-python"

if not header_dir.exists():

return []

return [str(f) for f in header_dir.glob("*.hpp")]

# Module-level convenience imports for common use cases

# This allows users to do: from xtensor_python import get_include_dirs

__all__ = [

# Version information

"__version__",

"__version_info__",

"version",

"version_info",

"get_version_info",

"get_version_string",

"VersionInfo",

# Build helpers

"get_include_dirs",

"get_compiler_flags",

"get_numpy_flags",

"get_link_flags",

"get_define_macros",

"create_extension",

"BuildExtension",

"get_build_requirements",

"check_dependencies",

"print_build_info",

# CMake helpers

"get_cmake_dir",

"get_cmake_variables",

"generate_cmake_config",

"get_cmake_prefix_path",

"get_cmake_find_commands",

"print_cmake_info",

"create_cmake_example",

# Backward compatibility

"get_include",

"get_cmake_include_dir",

# Convenience functions

"setup_extension",

"get_all_include_dirs",

"print_info",

"get_header_files",

# Package metadata

"__author__",

"__email__",

"__license__",

"__url__",

"__description__",

]

# Initialize package on import

def _initialize_package():

"""Initialize the package and perform any necessary setup."""

try:

# Verify that header files are present

header_files = get_header_files()

if not header_files:

import warnings

warnings.warn(

"No C++ header files found. The package may not be properly installed.",

UserWarning,

stacklevel=2

)

except Exception:

# Silently ignore initialization errors

pass

# Run initialization

_initialize_package()