def build_extension(self, ext): extdir = os.path.abspath( os.path.dirname(self.get_ext_fullpath(ext.name))) if not os.path.exists(self.build_temp): os.makedirs(self.build_temp) subprocess.check_call( [ "cmake", "-DPYBIND11_PYTHON_VERSION={}.{}.{}".format( sys.version_info.major, sys.version_info.minor, sys.version_info.micro), "-Dpybind11_DIR={}".format(pybind11.get_cmake_dir()), "-DONNX_INCLUDE={}".format( os.path.dirname(os.path.dirname(onnx.__file__))), "-DONNXRUNTIME_EXTERNAL_INCLUDE={}".format( os.path.join( os.path.join(os.path.dirname(onnxruntime.__file__), "external"), "include")), "-DCMAKE_LIBRARY_OUTPUT_DIRECTORY={}".format(extdir), ext.sourcedir, ], cwd=self.build_temp, ) subprocess.check_call(["cmake", "--build", "."], cwd=self.build_temp)
def build_extension(self, ext): extdir = os.path.abspath( os.path.dirname(self.get_ext_fullpath(ext.name))) cmake_args = [ '-DCMAKE_LIBRARY_OUTPUT_DIRECTORY=' + extdir, '-DPYTHON_EXECUTABLE=' + sys.executable ] cfg = 'Debug' if self.debug else 'Release' build_args = ['--config', cfg] cmake_args += ['-DCMAKE_BUILD_TYPE=' + cfg] build_args += ['--', '-j3'] env = os.environ.copy() import pybind11 env['pybind11_DIR'] = pybind11.get_cmake_dir() env['CXXFLAGS'] = '{} -DVERSION_INFO=\\"{}\\"'.format( env.get('CXXFLAGS', ''), self.distribution.get_version()) if not os.path.exists(self.build_temp): os.makedirs(self.build_temp) subprocess.check_call(['cmake', ext.sourcedir] + cmake_args, cwd=self.build_temp, env=env) subprocess.check_call(['cmake', '--build', '.'] + build_args, cwd=self.build_temp, env=env)
def build_extensions(self): # First: configure CMake build import platform import sys import distutils.sysconfig import pybind11 # Work out the relevant Python paths to pass to CMake, adapted from the # PyTorch build system if platform.system() == "Windows": cmake_python_library = "{}/libs/python{}.lib".format( distutils.sysconfig.get_config_var("prefix"), distutils.sysconfig.get_config_var("VERSION"), ) if not os.path.exists(cmake_python_library): cmake_python_library = "{}/libs/python{}.lib".format( sys.base_prefix, distutils.sysconfig.get_config_var("VERSION"), ) else: cmake_python_library = "{}/{}".format( distutils.sysconfig.get_config_var("LIBDIR"), distutils.sysconfig.get_config_var("INSTSONAME"), ) cmake_python_include_dir = distutils.sysconfig.get_python_inc() install_dir = os.path.abspath( os.path.dirname(self.get_ext_fullpath("dummy")) ) os.makedirs(install_dir, exist_ok=True) cmake_args = [ "-DCMAKE_INSTALL_PREFIX={}".format(install_dir), "-DPython_EXECUTABLE={}".format(sys.executable), "-DPython_LIBRARIES={}".format(cmake_python_library), "-DPython_INCLUDE_DIRS={}".format(cmake_python_include_dir), "-DCMAKE_BUILD_TYPE={}".format( "Debug" if self.debug else "Release" ), "-DCMAKE_PREFIX_PATH={}".format(pybind11.get_cmake_dir()), ] if os.environ.get("KEPLER_JAX_CUDA", "no").lower() == "yes": cmake_args.append("-DKEPLER_JAX_CUDA=yes") os.makedirs(self.build_temp, exist_ok=True) subprocess.check_call( ["cmake", HERE] + cmake_args, cwd=self.build_temp ) # Build all the extensions super().build_extensions() # Finally run install subprocess.check_call( ["cmake", "--build", ".", "--target", "install"], cwd=self.build_temp, )
def run_cmake(build_temp, install_dir, debug=False): import distutils.sysconfig from distutils import log # From PyTorch if platform.system() == "Windows": cmake_python_library = "{}/libs/python{}.lib".format( distutils.sysconfig.get_config_var("prefix"), distutils.sysconfig.get_config_var("VERSION"), ) # Fix virtualenv builds if not os.path.exists(cmake_python_library): cmake_python_library = "{}/libs/python{}.lib".format( sys.base_prefix, distutils.sysconfig.get_config_var("VERSION"), ) else: cmake_python_library = "{}/{}".format( distutils.sysconfig.get_config_var("LIBDIR"), distutils.sysconfig.get_config_var("INSTSONAME"), ) cmake_python_include_dir = distutils.sysconfig.get_python_inc() cmake_args = [ "-DCMAKE_INSTALL_PREFIX={}".format(os.path.dirname(install_dir)), "-DCMAKE_LIBRARY_OUTPUT_DIRECTORY={}".format(install_dir), "-DPython_EXECUTABLE={}".format(sys.executable), "-DPython_LIBRARIES={}".format(cmake_python_library), "-DPython_INCLUDE_DIRS={}".format(cmake_python_include_dir), "-DCMAKE_BUILD_TYPE={}".format("Debug" if debug else "Release"), "-DCMAKE_PREFIX_PATH={}".format(pybind11.get_cmake_dir()), ] build_args = [] if not os.path.exists(build_temp): os.makedirs(build_temp) log.info("cmake " + HERE + " " + " ".join(cmake_args)) subprocess.check_call(["cmake", HERE] + cmake_args, cwd=build_temp) log.info("cmake --build . --target install " + " ".join(build_args)) subprocess.check_call( ["cmake", "--build", ".", "--target", "install"] + build_args, cwd=build_temp, )
def build_extension(self, ext): from pybind11 import get_cmake_dir extdir = os.path.abspath( os.path.dirname(self.get_ext_fullpath(ext.name))) cmake_args = [ '-DCMAKE_LIBRARY_OUTPUT_DIRECTORY=' + extdir, '-DPYTHON_EXECUTABLE=' + sys.executable, '-Denable_smpi=OFF', '-Denable_java=OFF', '-Denable_python=ON', '-Dminimal-bindings=ON', '-Dpybind11_DIR=' + get_cmake_dir() ] cfg = 'Debug' if self.debug else 'Release' build_args = ['--config', cfg] if platform.system() == "Windows": cmake_args += [ '-DCMAKE_LIBRARY_OUTPUT_DIRECTORY_{}={}'.format( cfg.upper(), extdir) ] if sys.maxsize > 2**32: cmake_args += ['-A', 'x64'] build_args += ['--', '/m'] else: cmake_args += ['-DCMAKE_BUILD_TYPE=' + cfg] build_args += ['--', '-j4'] env = os.environ.copy() env['CXXFLAGS'] = '{} -DVERSION_INFO=\\"{}\\"'.format( env.get('CXXFLAGS', ''), self.distribution.get_version()) if not os.path.exists(self.build_temp): os.makedirs(self.build_temp) subprocess.check_call(['cmake', ext.sourcedir] + cmake_args, cwd=self.build_temp, env=env) subprocess.check_call(['cmake', '--build', '.'] + build_args, cwd=self.build_temp)
def build_extension(self, ext): build_temp = Path(self.build_temp).resolve() build_temp.mkdir(parents=True, exist_ok=True) extdir = Path(self.get_ext_fullpath(ext.name)).resolve().parent extdir.mkdir(parents=True, exist_ok=True) config = 'Debug' if self.debug else 'Release' cmake_args = [ '-DCMAKE_LIBRARY_OUTPUT_DIRECTORY=' + str(extdir.resolve()), '-DCMAKE_BUILD_TYPE=' + config, '-Dpybind11_DIR=' + pybind11.get_cmake_dir(), ] build_args = [] if sys.platform.startswith("darwin"): # Cross-compile support for macOS - respect ARCHFLAGS if set archs = re.findall(r"-arch (\S+)", os.environ.get("ARCHFLAGS", "")) if archs: cmake_args += [ "-DCMAKE_OSX_ARCHITECTURES={}".format(";".join(archs)) ] # Set CMAKE_BUILD_PARALLEL_LEVEL to control the parallel build level # across all generators. if "CMAKE_BUILD_PARALLEL_LEVEL" not in os.environ: # self.parallel is a Python 3 only way to set parallel jobs by hand # using -j in the build_ext call, not supported by pip or PyPA-build. if hasattr(self, "parallel") and self.parallel: # CMake 3.12+ only. build_args += [f"-j{self.parallel}"] subprocess.check_call(["cmake", ext.sourcedir] + cmake_args, cwd=self.build_temp) subprocess.check_call(["cmake", "--build", "."] + build_args, cwd=self.build_temp)
def build_extension(self, ext): # The pybind11 package is only needed for `build_ext`, and may not be installed # in the caller's environment. By the time this function is called, though, # build dependencies will have been checked. import pybind11 extdir = os.path.abspath(os.path.dirname(self.get_ext_fullpath(ext.name))) # required for auto-detection & inclusion of auxiliary "native" libs if not extdir.endswith(os.path.sep): extdir += os.path.sep debug = int(os.environ.get("DEBUG", 0)) if self.debug is None else self.debug cfg = "Debug" if debug else "Release" # CMake lets you override the generator - we need to check this. # Can be set with Conda-Build, for example. cmake_generator = os.environ.get("CMAKE_GENERATOR", "") cmake_args = [ "-DCMAKE_LIBRARY_OUTPUT_DIRECTORY={}".format(extdir), "-DCMAKE_BUILD_TYPE={}".format(cfg), # not used on MSVC, but no harm ] build_args = [] # Adding CMake arguments set as environment variable # (needed e.g. to build for ARM OSx on conda-forge) if "CMAKE_ARGS" in os.environ: cmake_args += [item for item in os.environ["CMAKE_ARGS"].split(" ") if item] if self.compiler.compiler_type != "msvc": # Using Ninja-build since it a) is available as a wheel and b) # multithreads automatically. MSVC would require all variables be # exported for Ninja to pick it up, which is a little tricky to do. # Users can override the generator with CMAKE_GENERATOR in CMake # 3.15+. if not cmake_generator: try: import ninja # noqa: F401 cmake_args += ["-GNinja"] except ImportError: pass else: # Single config generators are handled "normally" single_config = any(x in cmake_generator for x in {"NMake", "Ninja"}) # CMake allows an arch-in-generator style for backward compatibility contains_arch = any(x in cmake_generator for x in {"ARM", "Win64"}) # Specify the arch if using MSVC generator, but only if it doesn't # contain a backward-compatibility arch spec already in the # generator name. if not single_config and not contains_arch: cmake_args += ["-A", PLAT_TO_CMAKE[self.plat_name]] # Multi-config generators have a different way to specify configs if not single_config: cmake_args += [ "-DCMAKE_LIBRARY_OUTPUT_DIRECTORY_{}={}".format(cfg.upper(), extdir) ] build_args += ["--config", cfg] if sys.platform.startswith("darwin"): # Cross-compile support for macOS - respect ARCHFLAGS if set archs = re.findall(r"-arch (\S+)", os.environ.get("ARCHFLAGS", "")) if archs: cmake_args += ["-DCMAKE_OSX_ARCHITECTURES={}".format(";".join(archs))] # Set CMAKE_BUILD_PARALLEL_LEVEL to control the parallel build level # across all generators. if "CMAKE_BUILD_PARALLEL_LEVEL" not in os.environ: # self.parallel is a Python 3 only way to set parallel jobs by hand # using -j in the build_ext call, not supported by pip or PyPA-build. if hasattr(self, "parallel") and self.parallel: # CMake 3.12+ only. build_args += ["-j{}".format(self.parallel)] if not os.path.exists(self.build_temp): os.makedirs(self.build_temp) cmake_args = update_gromacs_client_cmake_args(cmake_args) has_pybind = False for arg in cmake_args: if arg.upper().startswith('-DPYBIND11_ROOT'): has_pybind = True if not has_pybind: pybind_root = pybind11.get_cmake_dir() if pybind_root: cmake_args.append(f'-Dpybind11_ROOT={pybind_root}') subprocess.check_call( ["cmake", ext.sourcedir] + cmake_args, cwd=self.build_temp ) subprocess.check_call( ["cmake", "--build", "."] + build_args, cwd=self.build_temp )
def run(self): nddshome = get_nddshome() arch = get_arch() lib_dir = os.path.join(get_script_dir(), 'platform', arch) # CMake will find same Python major version as the one used for setup major_version = sys.version_info.major cfg = 'Debug' if (self.debug or get_debug()) else 'Release' cmake_args = [ '-DBUILD_SHARED_LIBS=ON', '-DCONNEXTDDS_DIR=' + nddshome, '-DCONNEXTDDS_ARCH=' + arch, '-DCMAKE_BUILD_TYPE=' + cfg, '-Dpybind11_DIR=' + pybind11.get_cmake_dir(), '-DRTI_PYTHON_MAJOR_VERSION=' + str(major_version), '-DRTI_PLATFORM_DIR=' + lib_dir ] cmake_toolchain = get_cmake_toolchain() python_root = get_python_root() if cmake_toolchain: cmake_args += ['-DCMAKE_TOOLCHAIN_FILE=' + cmake_toolchain] else: cmake_args += ['-DCMAKE_PREFIX_PATH=' + lib_dir] if python_root: cmake_args += ['-DPython_ROOT_DIR=' + python_root] for ext in self.extensions: extdir = os.path.abspath( os.path.dirname(self.get_ext_fullpath(ext.name))) cmake_args += [ '-D' + ext.name.replace('.', '_').upper() + '_LIBRARY_OUTPUT_DIRECTORY=' + extdir ] self.copy_extension_libs(ext, extdir, arch) build_args = ['--config', cfg] if 'Win' in arch: cmake_args += ['-A', get_cpu(arch)] build_args += ['--', '/p:CL_MPcount={}'.format(get_job_count())] else: cmake_args += ['-DRTI_LINK_OPTIMIZATIONS_ON=1'] build_args += ['--parallel', str(get_job_count())] # handle possible ABI issues when targeting gcc 4.x platforms if 'Linux' in arch and 'gcc4' in arch: abi_flag = '-D_GLIBCXX_USE_CXX11_ABI=0' else: abi_flag = '' env = os.environ.copy() env['CXXFLAGS'] = '{} {} -DVERSION_INFO=\\"{}\\"'.format( env.get('CXXFLAGS', ''), abi_flag, self.distribution.get_version()) module_build_dir = os.path.join(self.build_temp, 'connext-py') if not os.path.exists(module_build_dir): os.makedirs(module_build_dir) cmake_cmd = os.path.join(cmake.CMAKE_BIN_DIR, 'cmake') subprocess.check_call([ cmake_cmd, os.path.abspath(os.path.join(get_script_dir(), 'modules')) ] + cmake_args, cwd=module_build_dir, env=env) subprocess.check_call([cmake_cmd, '--build', '.'] + build_args, cwd=module_build_dir, env=env) # attempt to create interface files for type hinting; failure is not a fatal error python_cmd = sys.executable stubgen = os.path.join(get_script_dir(), 'resources', 'scripts', 'stubgen.py') stubgen_args = [ '--split-overload-docs', '--no-setup-py', '--root-module-suffix', '' ] extdirs = set() for ext in self.extensions: extdir = os.path.abspath( os.path.dirname(self.get_ext_fullpath(ext.name))) extdirs.add(extdir) pkg_components = ext.name.split('.')[:-1] builddir = os.path.abspath( os.path.join(extdir, os.sep.join(['..'] * len(pkg_components)))) stubs_env = os.environ.copy() stubs_env['PYTHONPATH'] = builddir try: with open(os.devnull, 'w') as devnull: subprocess.check_call([python_cmd, stubgen] + stubgen_args + ['-o', extdir, ext.name], env=stubs_env, stderr=devnull) except Exception: print('Could not generate stub file for {}'.format(ext.name)) for extdir in extdirs: if os.path.isdir(os.path.join(extdir, '__pycache__')): shutil.rmtree(os.path.join(extdir, '__pycache__'))
'-DUSE_QT:BOOL=FALSE', '-DUSE_MMTF:BOOL=FALSE', '-DUSE_PYTHON:BOOL=TRUE', '-DUSE_MOLEQUEUE:BOOL=FALSE', '-DUSE_HDF5:BOOL=FALSE', '-DUSE_LIBARCHIVE:BOOL=FALSE', '-DUSE_LIBMSYM:BOOL=FALSE', ] + extra_cmake_args() + wheel_args() # Add pybind11 if it is installed try: from pybind11 import get_cmake_dir except ImportError: pass else: cmake_args.append('-Dpybind11_DIR:PATH=' + get_cmake_dir()) setup( name='avogadro', use_scm_version=True, setup_requires=['setuptools_scm'], description= 'Avogadro provides analysis and data processing useful in computational chemistry, molecular modeling, bioinformatics, materials science, and related areas.', author='Kitware', license='BSD', url='https://github.com/OpenChemistry/avogadrolibs', classifiers=[ 'License :: OSI Approved :: BSD License', 'Programming Language :: Python', 'Programming Language :: C++', 'Development Status :: 4 - Beta', 'Intended Audience :: Developers', 'Intended Audience :: Education',
def build_extension(self, ext): extdir = os.path.abspath( os.path.dirname(self.get_ext_fullpath(ext.name))) # required for auto-detection of auxiliary "native" libs if not extdir.endswith(os.path.sep): extdir += os.path.sep cfg = "Debug" if self.debug else "Release" # CMake lets you override the generator - we need to check this. # Can be set with Conda-Build, for example. cmake_generator = os.environ.get("CMAKE_GENERATOR", "") # Set Python_EXECUTABLE instead if you use PYBIND11_FINDPYTHON # EXAMPLE_VERSION_INFO shows you how to pass a value into the C++ code # from Python. cmake_args = [ "-DCMAKE_LIBRARY_OUTPUT_DIRECTORY={}".format(extdir), "-DPYTHON_EXECUTABLE={}".format(sys.executable), "-DPYDICAL_VERSION_INFO={}".format( self.distribution.get_version()), "-Dpybind11_ROOT={}".format(get_cmake_dir()), "-DCMAKE_BUILD_TYPE={}".format( cfg), # not used on MSVC, but no harm ] build_args = [] if self.compiler.compiler_type != "msvc": # Using Ninja-build since it a) is available as a wheel and b) # multithreads automatically. MSVC would require all variables be # exported for Ninja to pick it up, which is a little tricky to do. # Users can override the generator with CMAKE_GENERATOR in CMake # 3.15+. if not cmake_generator: cmake_args += ["-GNinja"] else: # Single config generators are handled "normally" single_config = any(x in cmake_generator for x in {"NMake", "Ninja"}) # CMake allows an arch-in-generator style for backward compatibility contains_arch = any(x in cmake_generator for x in {"ARM", "Win64"}) # Specify the arch if using MSVC generator, but only if it doesn't # contain a backward-compatibility arch spec already in the # generator name. if not single_config and not contains_arch: cmake_args += ["-A", PLAT_TO_CMAKE[self.plat_name]] # Multi-config generators have a different way to specify configs if not single_config: cmake_args += [ "-DCMAKE_LIBRARY_OUTPUT_DIRECTORY_{}={}".format( cfg.upper(), extdir) ] build_args += ["--config", cfg] # Set CMAKE_BUILD_PARALLEL_LEVEL to control the parallel build level # across all generators. if "CMAKE_BUILD_PARALLEL_LEVEL" not in os.environ: # self.parallel is a Python 3 only way to set parallel jobs by hand # using -j in the build_ext call, not supported by pip or PyPA-build. if hasattr(self, "parallel") and self.parallel: # CMake 3.12+ only. build_args += ["-j{}".format(self.parallel)] if not os.path.exists(self.build_temp): os.makedirs(self.build_temp) subprocess.check_call(["cmake", ext.sourcedir] + cmake_args, cwd=self.build_temp) subprocess.check_call(["cmake", "--build", "."] + build_args, cwd=self.build_temp)
import subprocess import sys import pathlib import pybind11 lib_name = sys.argv[1] tag_name = sys.argv[2] pybind11.get_cmake_dir() repo_url = 'https://github.com/xtensor-stack/' + lib_name home = pathlib.Path.home() subprocess.check_call(['git', 'clone', repo_url], cwd=home) subprocess.check_call(['git', 'checkout', f'tags/{tag_name}', '-b', tag_name], cwd=home / lib_name) build = home / lib_name / "build" build.mkdir() subprocess.check_call(['cmake', '..'], cwd=build) subprocess.check_call(['make', 'install'], cwd=build)