diff --git a/CMakeLists.txt b/CMakeLists.txt new file mode 100644 index 0000000..7248a85 --- /dev/null +++ b/CMakeLists.txt @@ -0,0 +1,43 @@ +cmake_minimum_required(VERSION 3.20) + +project( + ${SKBUILD_PROJECT_NAME} + LANGUAGES C CXX + VERSION ${SKBUILD_PROJECT_VERSION}) + +find_package(Python COMPONENTS Interpreter Development.Module) + + +if(DEFINED ENV{AF_BUILD_LOCAL_LIBS}) + include(FetchContent) + + #set(NO_SONAME) + FetchContent_Declare( + arrayfire + GIT_REPOSITORY https://github.com/arrayfire/arrayfire.git + GIT_TAG v3.9 + ) + #TODO: change package name to match repository/project name? + #set(AF_INSTALL_CMAKE_DIR "${SKBUILD_PROJECT_NAME}") + + set(AF_INSTALL_BIN_DIR "arrayfire_wrapper/binaries") + set(AF_INSTALL_CMAKE_DIR "arrayfire_wrapper/binaries") + set(AF_INSTALL_DOC_DIR "arrayfire_wrapper/binaries") + set(AF_INSTALL_EXAMPLE_DIR "arrayfire_wrapper/binaries") + set(AF_INSTALL_INC_DIR "arrayfire_wrapper/binaries") + set(AF_INSTALL_LIB_DIR "arrayfire_wrapper/binaries") + set(FG_INSTALL_LIB_DIR "arrayfire_wrapper/binaries") + + FetchContent_MakeAvailable(arrayfire) +endif() + +# Testing artifacts +file(WRITE ${CMAKE_CURRENT_BINARY_DIR}/generated.txt "Testing") +install( + FILES ${CMAKE_CURRENT_BINARY_DIR}/generated.txt + DESTINATION arrayfire_wrapper + COMPONENT Generated) + +file(WRITE ${CMAKE_CURRENT_BINARY_DIR}/generated_ignored.txt "Testing") +install(FILES ${CMAKE_CURRENT_BINARY_DIR}/generated_ignored.txt + DESTINATION arrayfire_wrapper) diff --git a/LICENSE b/LICENSE index db032cc..1c216e1 100644 --- a/LICENSE +++ b/LICENSE @@ -1,6 +1,6 @@ BSD 3-Clause License -Copyright (c) 2023, Anton +Copyright (c) 2023, ArrayFire Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: diff --git a/README.md b/README.md index 8cdf198..300ce79 100644 --- a/README.md +++ b/README.md @@ -1,21 +1,77 @@ # arrayfire-binary-python-wrapper -Arrayfire python C library wrapper - -## Coverage - -- [x] Computer Vision -- [x] Events -- [x] Functions to Create and Modify Arrays -- [x] Functions to Work with Internal Array Layout -- [x] Image Processing - - [x] Features -- [x] Input and Output Functions -- [x] Interface Functions -- [x] Linear Algebra -- [x] Machine Learning -- [x] Mathematical Functions -- [x] Signal Processing -- [x] Statistics -- [x] Unified API Functions -- [x] Vector Algorithms +[ArrayFire](https://github.com/arrayfire/arrayfire) is a high performance library for parallel computing with an easy-to-use API. It enables users to write scientific computing code that is portable across CUDA, OpenCL and CPU devices. + +This project is meant to provide thin Python bindings for the ArrayFire C library. It also decouples releases of the main C/C++ library from the Python library by acting as a intermediate library and only wrapping the provided C calls. + +This allows the building of large binary wheels only when the underlying ArrayFire version is increased, and the fully-featured Python library can be developed atop independently. The package is not intended to be used directly and merely exposes the +C functionality required by downstream implementations. This package can exist in two forms, with a bundled binary distribution, or merely as a loader that will load the ArrayFire library from a system or user level install. + +# Installing + +The arrayfire-binary-python-wrapper can be installed from a variety of sources. [Pre-built wheels](https://repo.arrayfire.com/python/wheels/3.9.0/) are available for a number of systems and toolkits. These will include a binary distribution of the ArrayFire libraries. Installing from PyPI directly will only include a wrapper-only, source distribution that will not contain binaries. In this case, wrapper-only installations will require a separate installation of the ArrayFire C/C++ libraries. +You can get the ArrayFire C/C++ library from the following sources: + +- [Download and install binaries](https://arrayfire.com/download) +- [Build and install from source](https://github.com/arrayfire/arrayfire) + + +**Install the last stable version of python wrapper:** +``` +pip install arrayfire-binary-python-wrapper +``` + +**Install a pre-built wheel:** +``` +pip install arrayfire-binary-python-wrapper -f https://repo.arrayfire.com/python/wheels/3.9.0/ +``` + +# Building +The arrayfire-binary-python-wrapper can build wheels in packaged-binary or in system-wrapper modes. +[scikit-build-core](https://github.com/scikit-build/scikit-build-core) is used to provide the python build backend. +The minimal, wrapper-only mode that relies on a system install will be built by default though the regular python build process. For example: +``` +pipx run build --wheel +``` +Building a full pre-packaged local binary is an involved process that will require referencing the regular ArrayFire [build](https://github.com/arrayfire/arrayfire/wiki/Build-Instructions-for-Linux) [procedures](https://github.com/arrayfire/arrayfire/wiki/Build-Instructions-for-Windows). +Besides the regular ArrayFire CMake configuration, building the binaries is an opt-in process that is set by an environment variable `AF_BUILD_LOCAL_LIBS=1`. Once that environment variable is set, scikit-build-core will take care of cloning ArrayFire, building, and including the necessary binaries. + + +# Contributing + +The community of ArrayFire developers invites you to build with us if you are +interested and able to write top-performing tensor functions. Together we can +fulfill [The ArrayFire +Mission](https://github.com/arrayfire/arrayfire/wiki/The-ArrayFire-Mission-Statement) +for fast scientific computing for all. + +Contributions of any kind are welcome! Please refer to [the +wiki](https://github.com/arrayfire/arrayfire/wiki) and our [Code of +Conduct](33) to learn more about how you can get involved with the ArrayFire +Community through +[Sponsorship](https://github.com/arrayfire/arrayfire/wiki/Sponsorship), +[Developer +Commits](https://github.com/arrayfire/arrayfire/wiki/Contributing-Code-to-ArrayFire), +or [Governance](https://github.com/arrayfire/arrayfire/wiki/Governance). + +# Citations and Acknowledgements + +If you redistribute ArrayFire, please follow the terms established in [the +license](LICENSE). + +ArrayFire development is funded by AccelerEyes LLC and several third parties, +please see the list of [acknowledgements](ACKNOWLEDGEMENTS.md) for an +expression of our gratitude. + +# Support and Contact Info + +* [Slack Chat](https://join.slack.com/t/arrayfire-org/shared_invite/MjI4MjIzMDMzMTczLTE1MDI5ODg4NzYtN2QwNGE3ODA5OQ) +* [Google Groups](https://groups.google.com/forum/#!forum/arrayfire-users) +* ArrayFire Services: [Consulting](http://arrayfire.com/consulting) | [Support](http://arrayfire.com/download) | [Training](http://arrayfire.com/training) + +# Trademark Policy + +The literal mark "ArrayFire" and ArrayFire logos are trademarks of AccelerEyes +LLC (dba ArrayFire). If you wish to use either of these marks in your own +project, please consult [ArrayFire's Trademark +Policy](http://arrayfire.com/trademark-policy/) diff --git a/arrayfire_wrapper/__init__.py b/arrayfire_wrapper/__init__.py index 7521cc8..69f6a3c 100644 --- a/arrayfire_wrapper/__init__.py +++ b/arrayfire_wrapper/__init__.py @@ -17,8 +17,9 @@ "Backend", "BackendType", "get_backend", + "set_backend", ] -from ._backend import Backend, BackendType, get_backend +from ._backend import Backend, BackendType, get_backend, set_backend __all__ += [ "Dtype", diff --git a/arrayfire_wrapper/_backend.py b/arrayfire_wrapper/_backend.py index a47973e..88ebb94 100644 --- a/arrayfire_wrapper/_backend.py +++ b/arrayfire_wrapper/_backend.py @@ -5,12 +5,14 @@ import os import platform import sys +import sysconfig from dataclasses import dataclass from enum import Enum from pathlib import Path from typing import Iterator -from .defines import is_arch_x86 +from arrayfire_wrapper.defines import AFArray + from .version import ARRAYFIRE_VER_MAJOR VERBOSE_LOADS = os.environ.get("AF_VERBOSE_LOADS", "") == "1" @@ -36,6 +38,7 @@ class _BackendPathConfig: lib_prefix: str lib_postfix: str af_path: Path + af_is_user_path: bool cuda_found: bool def __iter__(self) -> Iterator: @@ -46,16 +49,20 @@ def _get_backend_path_config() -> _BackendPathConfig: platform_name = platform.system() cuda_found = False + # try to use user provided AF_PATH if explicitly set try: af_path = Path(os.environ["AF_PATH"]) + af_is_user_path = True except KeyError: af_path = None + af_is_user_path = False try: cuda_path = Path(os.environ["CUDA_PATH"]) except KeyError: cuda_path = None + # try to find default arrayfire installation paths if platform_name == _SupportedPlatforms.windows.value or _SupportedPlatforms.is_cygwin(platform_name): if platform_name == _SupportedPlatforms.windows.value: # HACK Supressing crashes caused by missing dlls @@ -64,29 +71,42 @@ def _get_backend_path_config() -> _BackendPathConfig: ctypes.windll.kernel32.SetErrorMode(0x0001 | 0x0002) # type: ignore[attr-defined] if not af_path: - af_path = _find_default_path(f"C:/Program Files/ArrayFire/v{ARRAYFIRE_VER_MAJOR}") + try: + af_path = _find_default_path(f"C:/Program Files/ArrayFire/v{ARRAYFIRE_VER_MAJOR}") + except ValueError: + af_path = None if cuda_path and (cuda_path / "bin").is_dir() and (cuda_path / "nvvm/bin").is_dir(): cuda_found = True - return _BackendPathConfig("", ".dll", af_path, cuda_found) + return _BackendPathConfig("", ".dll", af_path, af_is_user_path, cuda_found) if platform_name == _SupportedPlatforms.darwin.value: default_cuda_path = Path("/usr/local/cuda/") if not af_path: af_path = _find_default_path("/opt/arrayfire", "/usr/local") + try: + af_path = _find_default_path( + f"C:/Program Files/ArrayFire/v{ARRAYFIRE_VER_MAJOR}", + "C:/Program Files (x86)/ArrayFire/v{ARRAYFIRE_VER_MAJOR}", + ) + except ValueError: + af_path = None if not (cuda_path and default_cuda_path.exists()): cuda_found = (default_cuda_path / "lib").is_dir() and (default_cuda_path / "/nvvm/lib").is_dir() - return _BackendPathConfig("lib", f".{ARRAYFIRE_VER_MAJOR}.dylib", af_path, cuda_found) + return _BackendPathConfig("lib", f".{ARRAYFIRE_VER_MAJOR}.dylib", af_path, af_is_user_path, cuda_found) if platform_name == _SupportedPlatforms.linux.value: default_cuda_path = Path("/usr/local/cuda/") if not af_path: - af_path = _find_default_path(f"/opt/arrayfire-{ARRAYFIRE_VER_MAJOR}", "/opt/arrayfire/", "/usr/local/") + try: + af_path = _find_default_path(f"/opt/arrayfire-{ARRAYFIRE_VER_MAJOR}", "/opt/arrayfire/", "/usr/local/") + except ValueError: + af_path = None if not (cuda_path and default_cuda_path.exists()): if "64" in platform.architecture()[0]: # Check either is 64 bit arch is selected @@ -94,11 +114,46 @@ def _get_backend_path_config() -> _BackendPathConfig: else: cuda_found = (default_cuda_path / "lib").is_dir() and (default_cuda_path / "nvvm/lib").is_dir() - return _BackendPathConfig("lib", f".so.{ARRAYFIRE_VER_MAJOR}", af_path, cuda_found) + return _BackendPathConfig("lib", f".so.{ARRAYFIRE_VER_MAJOR}", af_path, af_is_user_path, cuda_found) raise OSError(f"{platform_name} is not supported.") +# finds paths to locally packaged arrayfire libraries if they exist in site +def _find_site_local_path() -> Path: + local_paths = ["."] + + # module search paths + af_module = __import__(__name__) + module_paths = af_module.__path__ if af_module.__path__ else [] + for path in module_paths: + local_paths.append(path) + + # site search path + purelib_path = sysconfig.get_path("purelib") + platlib_path = sysconfig.get_path("platlib") + local_paths.append(purelib_path) + local_paths.append(platlib_path) + + # sys search path + local_paths.extend(sys.path) + + module_name = af_module.__name__ + for path in local_paths: + lpath = Path(path) + if lpath.exists(): + p = lpath.glob(f"{module_name}/binaries/*") + files = [x.name for x in p if x.is_file()] + query_libnames = ["afcpu", "afoneapi", "afopencl", "afcuda", "af", "forge"] + found_lib_in_dir = any(q in f for q in query_libnames for f in files) + if found_lib_in_dir: + if VERBOSE_LOADS: + print(lpath) + print(lpath / module_name / "binaries") + return lpath / module_name / "binaries" + raise RuntimeError("No binaries detected in site path.") + + def _find_default_path(*args: str) -> Path: for path in args: default_path = Path(path) @@ -108,26 +163,46 @@ def _find_default_path(*args: str) -> Path: class BackendType(enum.Enum): # TODO change name - avoid using _backend_type - e.g. type - unified = 0 # NOTE It is set as Default value on Arrayfire backend - cpu = 1 cuda = 2 opencl = 4 oneapi = 8 + cpu = 1 + unified = 0 # NOTE It is set as Default value on Arrayfire backend def __iter__(self) -> Iterator: # NOTE cpu comes last because we want to keep this order priorty during backend initialization - return iter((self.unified, self.cuda, self.oneapi, self.opencl, self.cpu)) + return iter((self.cuda, self.opencl, self.oneapi, self.cpu, self.unified)) class Backend: _backend_type: BackendType - _clib: ctypes.CDLL + _clibs: dict[BackendType, ctypes.CDLL] def __init__(self) -> None: self._backend_path_config = _get_backend_path_config() - self._load_forge_lib() + self._backend_type = None + self._clibs = {} self._load_backend_libs() + self._load_forge_lib() + + def _change_backend(self, backend_type: BackendType) -> None: + # if unified is available, do dynamic module loading through libaf + if self._backend_type == BackendType.unified: + from arrayfire_wrapper.lib.unified_api_functions import set_backend as unified_set_backend + + try: + unified_set_backend(backend_type) + except RuntimeError as e: + print(f"Unable to change backend using unified loader: {str(e)}") + # if unified not available + else: + if backend_type in self._clibs: + self._backend_type = backend_type + else: + self._backend_path_config = _get_backend_path_config() + self._load_backend_libs(backend_type) + # self._load_forge_lib() # needed to reload? def _load_forge_lib(self) -> None: for lib_name in self._lib_names("forge", _LibPrefixes.forge): @@ -141,16 +216,17 @@ def _load_forge_lib(self) -> None: print(f"Unable to load {lib_name}") pass - def _load_backend_libs(self) -> None: - for backend_type in BackendType: + def _load_backend_libs(self, specific_backend: BackendType | None = None) -> None: + available_backends = [specific_backend] if specific_backend else list(BackendType) + for backend_type in available_backends: self._load_backend_lib(backend_type) - if hasattr(self, "_backend_type"): + if self._backend_type: if VERBOSE_LOADS: print(f"Setting {backend_type.name} as backend.") break - if not (hasattr(self, "_backend_type") and hasattr(self, "_clib")): + if not self._backend_type and not self._clibs: raise RuntimeError( "Could not load any ArrayFire libraries.\n" "Please look at https://github.com/arrayfire/arrayfire-python/wiki for more information." @@ -162,9 +238,11 @@ def _load_backend_lib(self, _backend_type: BackendType) -> None: for lib_name in self._lib_names(name, _LibPrefixes.arrayfire): try: + if VERBOSE_LOADS: + print(f"Attempting to load {lib_name}") ctypes.cdll.LoadLibrary(str(lib_name)) self._backend_type = _backend_type - self._clib = ctypes.CDLL(str(lib_name)) + self._clibs[_backend_type] = ctypes.CDLL(str(lib_name)) if _backend_type == BackendType.cuda: self._load_nvrtc_builtins_lib(lib_name.parent) @@ -191,22 +269,27 @@ def _lib_names(self, name: str, lib: _LibPrefixes, ver_major: str | None = None) post = self._backend_path_config.lib_postfix if ver_major is None else ver_major lib_name = self._backend_path_config.lib_prefix + lib.value + name + post - lib64_path = self._backend_path_config.af_path / "lib64" - search_path = lib64_path if lib64_path.is_dir() else self._backend_path_config.af_path / "lib" + lib_paths = [Path(lib_name)] - site_path = Path(sys.prefix) / "lib64" if not is_arch_x86() else Path(sys.prefix) / "lib" - - # prefer locally packaged arrayfire libraries if they exist - af_module = __import__(__name__) - local_path = Path(af_module.__path__[0]) if af_module.__path__ else Path("") - - lib_paths = [Path("", lib_name), site_path / lib_name, local_path / lib_name] + # use local or site packaged arrayfire libraries if they exist + try: + local_path = _find_site_local_path() + lib_paths.append(local_path / lib_name) + except RuntimeError as e: + if VERBOSE_LOADS: + print(f"Moving on to system libraries, site local load failed due to: {str(e)}") + pass if self._backend_path_config.af_path: # prefer specified AF_PATH if exists - return [search_path / lib_name] + lib_paths - else: - lib_paths.insert(2, Path(str(search_path), lib_name)) - return lib_paths + lib64_path = self._backend_path_config.af_path / "lib64" + search_path = lib64_path if lib64_path.is_dir() else self._backend_path_config.af_path / "lib" + # prefer path explicitly set by user through AF_PATH + if self._backend_path_config.af_is_user_path: + return [search_path / lib_name] + lib_paths + # otherwise, prefer to use site-packaged or local path + return lib_paths + [search_path / lib_name] + + return lib_paths def _find_nvrtc_builtins_lib_name(self, search_path: Path) -> str | None: for f in search_path.iterdir(): @@ -214,13 +297,51 @@ def _find_nvrtc_builtins_lib_name(self, search_path: Path) -> str | None: return f.name return None + # unified backend functions + def get_active_backend(self) -> str: + if self._backend_type == BackendType.unified: + from arrayfire_wrapper.lib.unified_api_functions import get_active_backend as unified_get_active_backend + + return unified_get_active_backend() + raise RuntimeError("Using unified function on non-unified backend") + + def get_available_backends(self) -> list[int]: + if self._backend_type == BackendType.unified: + from arrayfire_wrapper.lib.unified_api_functions import ( + get_available_backends as unified_get_available_backends, + ) + + return unified_get_available_backends() + raise RuntimeError("Using unified function on non-unified backend") + + def get_backend_count(self) -> int: + if self._backend_type == BackendType.unified: + from arrayfire_wrapper.lib.unified_api_functions import get_backend_count as unified_get_backend_count + + return unified_get_backend_count() + raise RuntimeError("Using unified function on non-unified backend") + + def get_backend_id(self, arr: AFArray, /) -> int: + if self._backend_type == BackendType.unified: + from arrayfire_wrapper.lib.unified_api_functions import get_backend_id as unified_get_backend_id + + return unified_get_backend_id(arr) + raise RuntimeError("Using unified function on non-unified backend") + + def get_device_id(self, arr: AFArray, /) -> int: + if self._backend_type == BackendType.unified: + from arrayfire_wrapper.lib.unified_api_functions import get_device_id as unified_get_device_id + + return unified_get_device_id(arr) + raise RuntimeError("Using unified function on non-unified backend") + @property def backend_type(self) -> BackendType: return self._backend_type @property def clib(self) -> ctypes.CDLL: - return self._clib + return self._clibs[self._backend_type] # Initialize the backend @@ -238,3 +359,11 @@ def get_backend() -> Backend: """ return __backend + + +def set_backend(backend_type: BackendType) -> None: + try: + backend = get_backend() + backend._change_backend(backend_type) + except RuntimeError: + print(f"Requested backend {backend_type.name} could not be found") diff --git a/arrayfire_wrapper/lib/__init__.py b/arrayfire_wrapper/lib/__init__.py index 5472443..7bb66d1 100644 --- a/arrayfire_wrapper/lib/__init__.py +++ b/arrayfire_wrapper/lib/__init__.py @@ -910,26 +910,6 @@ approx2_v2, ) -# Unified API functions - -__all__ += [ - "get_active_backend", - "get_available_backends", - "get_backend_count", - "get_backend_id", - "get_device_id", - "set_backend", -] - -from .unified_api_functions import ( - get_active_backend, - get_available_backends, - get_backend_count, - get_backend_id, - get_device_id, - set_backend, -) - # Events __all__ += ["AFEvent", "block_event", "create_event", "delete_event", "enqueue_wait_event", "mark_event"] diff --git a/arrayfire_wrapper/lib/unified_api_functions.py b/arrayfire_wrapper/lib/unified_api_functions.py deleted file mode 100644 index 9a87eed..0000000 --- a/arrayfire_wrapper/lib/unified_api_functions.py +++ /dev/null @@ -1,58 +0,0 @@ -import ctypes - -from arrayfire_wrapper._backend import BackendType -from arrayfire_wrapper.defines import AFArray -from arrayfire_wrapper.lib._utility import call_from_clib - - -def get_active_backend() -> str: - """ - source: https://arrayfire.org/docs/group__unified__func__getactivebackend.htm#gac6a8e976a151d007e0cf5cf4f11da2a9 - """ - out = ctypes.c_int(0) - call_from_clib(get_active_backend.__name__, ctypes.pointer(out)) - return BackendType(out.value).name - - -def get_available_backends() -> list[int]: - """ - source: https://arrayfire.org/docs/group__unified__func__getavailbackends.htm#ga92a9ce85385763bfa83911cda905afe8 - """ - out = ctypes.c_int(0) - call_from_clib(get_available_backends.__name__, ctypes.pointer(out)) - rv = out.value - return [bt.value & rv for bt in BackendType] - - -def get_backend_count() -> int: - """ - source: https://arrayfire.org/docs/group__unified__func__getbackendcount.htm#gad38c2dfedfdabfa264afa46d8664e9cd - """ - out = ctypes.c_uint(0) - call_from_clib(get_backend_count.__name__, ctypes.pointer(out)) - return out.value - - -def get_backend_id(arr: AFArray, /) -> int: - """ - source: https://arrayfire.org/docs/group__unified__func__getbackendid.htm#ga5fc39e209e1886cf250aec265c0d9079 - """ - out = ctypes.c_int(0) - call_from_clib(get_backend_id.__name__, ctypes.pointer(out), arr) - return out.value - - -def get_device_id(arr: AFArray, /) -> int: - """ - source: https://arrayfire.org/docs/group__unified__func__getdeviceid.htm#ga5d94b64dccd1c7cbc7a3a69fa64888c3 - """ - out = ctypes.c_int(0) - call_from_clib(get_device_id.__name__, ctypes.pointer(out), arr) - return out.value - - -def set_backend(backend: BackendType, /) -> None: - """ - source: https://arrayfire.org/docs/group__unified__func__setbackend.htm#ga6fde820e8802776b7fc823504b37f1b4 - """ - call_from_clib(set_backend.__name__, backend.value) diff --git a/dev-requirements.txt b/dev-requirements.txt index ce4a1f8..34e29b3 100644 --- a/dev-requirements.txt +++ b/dev-requirements.txt @@ -23,6 +23,8 @@ codecov>=2.1.12 # Package building build>=1.0.3 +scikit-build-core>=0.8.0 # Package publishing twine>=4.0.2 + diff --git a/pyproject.toml b/pyproject.toml index 1642d7b..76c3830 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -19,28 +19,26 @@ exclude = ''' ''' [build-system] -requires = [ - "setuptools >= 68.0", - "wheel >= 0.38.4", - "scikit-build >= 0.17.6", - "cmake >= 3.28.1", -] -build-backend = "setuptools.build_meta" +requires = ["scikit-build-core"] +build-backend = "scikit_build_core.build" -[tool.setuptools.dynamic] -version = { attr = "arrayfire_wrapper.VERSION" } +# TODO: re-enable if/when scikit-core can support +# [tool.setuptools.dynamic] +# version = { attr = "arrayfire_wrapper.__version__" } +# dynamic = ["version"] [project] name = "arrayfire-binary-python-wrapper" -dynamic = ["version"] +version = "0.6.0+AF3.9.0" requires-python = ">=3.10" authors = [ + { name = "ArrayFire", email = "technical@arrayfire.com"}, { name = "Anton Chernyatevich", email = "chernyatevich.a@gmail.com" }, ] maintainers = [{ name = "ArrayFire", email = "technical@arrayfire.com" }] description = "ArrayFire Python Wrapper" readme = "README.md" -license = { file = "LICENCE" } +license = { file = "LICENSE" } keywords = [ "arrayfire", "c", @@ -70,3 +68,38 @@ classifiers = [ [project.urls] Website = "http://arrayfire.com" "General Documentation" = "https://arrayfire.org/docs/index.htm" +#TODO: Documentation, Repository + +[tool.scikit-build] +# The build directory. Defaults to a temporary directory, but can be set. +build-dir = "build" + +[tool.scikit-build.wheel] +py-api = "py3" +packages = ["arrayfire_wrapper"] +expand-macos-universal-tags = true + +[tool.scikit-build.cmake] +build-type = "Release" # not working for whatever reason, duplicated below TODO: fix + +[tool.scikit-build.cmake.define] +# edit to enable/disable building of desired backends +AF_BUILD_CPU = "ON" +AF_BUILD_ONEAPI = "ON" +AF_BUILD_CUDA = "ON" +AF_BUILD_OPENCL = "ON" +AF_BUILD_UNIFIED = "ON" +AF_BUILD_DOCS = "OFF" + +CMAKE_BUILD_TYPE = "Release" +AF_BUILD_EXAMPLES = "OFF" +AF_WITH_IMAGEIO = "ON" +AF_WITH_LOGGING = "ON" +AF_WITH_FMT_HEADER_ONLY = "ON" +AF_WITH_SPDLOG_HEADER_ONLY = "ON" +AF_BUILD_FORGE = "ON" +AF_TEST_WITH_MTX_FILES = "OFF" +AF_INSTALL_STANDALONE = "ON" + +[tool.scikit-build.logging] +level = "INFO"