web-dev-qa-db-ja.com

setuptoolsの拡張機能を拡張して、setup.pyでCMakeを使用しますか?

私はC++ライブラリをリンクするPython拡張機能を作成しており、ビルドプロセスを支援するためにcmakeを使用しています。つまり、現在、それをバンドルする方法を知る唯一の方法は、 setup.py bdist_wheelを実行する前に、まずそれらをcmakeでコンパイルする必要があります。

Setup.py ext_modulesビルドプロセスの一部としてCMakeを呼び出すことが可能(または誰かが試みた)かどうか疑問に思っていましたか?何かのサブクラスを作成する方法はあると思いますが、どこを見ればよいかわかりません。

CMakeを使用しています。CMakeを使用すると、複雑なビルドステップを備えたcおよびc ++ライブラリ拡張を思い通りにビルドできるようになります。さらに、findPythonLibs.cmakeのPYTHON_ADD_MODULE()コマンドを使用して、cmakeで直接Python拡張機能を簡単にビルドできます。これがすべて1つのステップであるといいのですが。

20
loneraver

基本的に必要なことは、build_extsetup.pyコマンドクラスをオーバーライドして、コマンドクラスに登録することです。 build_extのカスタム実装で、cmakeを構成して呼び出し、拡張モジュールを構成して構築します。残念ながら、公式ドキュメントはカスタムdistutilsコマンドの実装方法についてはかなり簡潔です( Extending Distutils を参照)。コマンドのコードを直接調べると、はるかに役立ちます。たとえば、以下は build_extコマンド のソースコードです。

プロジェクトの例

単一のC拡張fooとpython module spam.eggs

so-42585210/
├── spam
│   ├── __init__.py  # empty
│   ├── eggs.py
│   ├── foo.c
│   └── foo.h
├── CMakeLists.txt
└── setup.py

セットアップをテストするためのファイル

これらは、セットアップスクリプトをテストするために私が書いたいくつかの単純なスタブです。

spam/eggs.py(ライブラリ呼び出しをテストする場合のみ):

from ctypes import cdll
import pathlib


def wrap_bar():
    foo = cdll.LoadLibrary(str(pathlib.Path(__file__).with_name('libfoo.dylib')))
    return foo.bar()

spam/foo.c

#include "foo.h"

int bar() {
    return 42;
}

spam/foo.h

#ifndef __FOO_H__
#define __FOO_H__

int bar();

#endif

CMakeLists.txt

cmake_minimum_required(VERSION 3.10.1)
project(spam)
set(src "spam")
set(foo_src "spam/foo.c")
add_library(foo SHARED ${foo_src})

設定スクリプト

ここで魔法が起こります。もちろん、改善の余地はたくさんあります。必要に応じて、CMakeExtensionクラスに追加のオプションを渡すことができます(拡張機能の詳細については、 CおよびC++拡張機能のビルド)を参照してください )、setup.cfgおよびinitialize_optionsなどのメソッドをオーバーライドして、finalize_optionsを介してCMakeオプションを構成可能にします。

import os
import pathlib

from setuptools import setup, Extension
from setuptools.command.build_ext import build_ext as build_ext_orig


class CMakeExtension(Extension):

    def __init__(self, name):
        # don't invoke the original build_ext for this special extension
        super().__init__(name, sources=[])


class build_ext(build_ext_orig):

    def run(self):
        for ext in self.extensions:
            self.build_cmake(ext)
        super().run()

    def build_cmake(self, ext):
        cwd = pathlib.Path().absolute()

        # these dirs will be created in build_py, so if you don't have
        # any python sources to bundle, the dirs will be missing
        build_temp = pathlib.Path(self.build_temp)
        build_temp.mkdir(parents=True, exist_ok=True)
        extdir = pathlib.Path(self.get_ext_fullpath(ext.name))
        extdir.mkdir(parents=True, exist_ok=True)

        # example of cmake args
        config = 'Debug' if self.debug else 'Release'
        cmake_args = [
            '-DCMAKE_LIBRARY_OUTPUT_DIRECTORY=' + str(extdir.parent.absolute()),
            '-DCMAKE_BUILD_TYPE=' + config
        ]

        # example of build args
        build_args = [
            '--config', config,
            '--', '-j4'
        ]

        os.chdir(str(build_temp))
        self.spawn(['cmake', str(cwd)] + cmake_args)
        if not self.dry_run:
            self.spawn(['cmake', '--build', '.'] + build_args)
        os.chdir(str(cwd))


setup(
    name='spam',
    version='0.1',
    packages=['spam'],
    ext_modules=[CMakeExtension('spam/foo')],
    cmdclass={
        'build_ext': build_ext,
    }
)

テスト中

プロジェクトのホイールをビルドしてインストールします。ライブラリがインストールされていることをテストします。

$ pip show -f spam
Name: spam
Version: 0.1
Summary: UNKNOWN
Home-page: UNKNOWN
Author: UNKNOWN
Author-email: UNKNOWN
License: UNKNOWN
Location: /Users/hoefling/.virtualenvs/stackoverflow/lib/python3.6/site-packages
Requires: 
Files:
  spam-0.1.dist-info/DESCRIPTION.rst
  spam-0.1.dist-info/INSTALLER
  spam-0.1.dist-info/METADATA
  spam-0.1.dist-info/RECORD
  spam-0.1.dist-info/WHEEL
  spam-0.1.dist-info/metadata.json
  spam-0.1.dist-info/top_level.txt
  spam/__init__.py
  spam/__pycache__/__init__.cpython-36.pyc
  spam/__pycache__/eggs.cpython-36.pyc
  spam/eggs.py
  spam/libfoo.dylib

spam.eggsモジュールからラッパー関数を実行します。

$ python -c "from spam import eggs; print(eggs.wrap_bar())"
42
19
hoefling

私はこれに私自身の答えを付け加えたいと思います。

ありがとうございました。あなたの答えが私自身のレポジトリの場合とほぼ同じ方法でセットアップスクリプトを書くことに私を軌道に乗せるのに役立ちました。

前文

この回答を書く主な動機は、足りない部分を「接着」しようとすることです。 OPはC/C++の性質を述べていませんPython=開発中のモジュールです。以下の手順はC/C++ cmakeビルドチェーン用であることを前もって明確にしたいと思います。に配置する必要があるいくつかの一般的な.dllファイルに加えて、複数の.so/*.pydファイルとプリコンパイル済み.py/soファイルを作成しますスクリプトディレクトリ。

これらのファイルはすべて実を結びます直後に cmakeビルドコマンドが実行されます...楽しいです。この方法でsetup.pyを構築するための推奨事項はありません。

Setup.pyは、スクリプトがパッケージ/ライブラリの一部になること、およびビルドが必要な.dllファイルは、リストされたソースとインクルードディレクトリを使用して、ライブラリ部分で宣言する必要があることを意味するため、 cmake -bで発生したbuild_extへの1回の呼び出しの結果であるライブラリ、スクリプト、およびデータファイルはすべて、それぞれの場所に配置する必要があることをsetuptoolsに伝える直感的な方法さらに悪いことに、このモジュールをsetuptoolsで追跡して完全にアンインストールできるようにしたい場合は、ユーザーがモジュールをアンインストールして、必要に応じてすべてのトレースをシステムからワイプできます。

私がsetup.pyを書いていたモジュールはbpyです。ここで説明するpythonモジュールとしてのブレンダーの構築に相当する.pyd/.soです:

https://wiki.blender.org/wiki//User:Ideasman42/BlenderAsPyModule (説明は改善されましたが、リンクは無効になりました) http://www.gizmoplex.com/wordpress/compile -blender-as-python-module / (おそらくより悪い指示ですが、まだオンラインのようです)

あなたはgithubの私のリポジトリをここでチェックアウトできます:

https://github.com/TylerGubala/blenderpy

それがこの回答を書く私の動機です。うまくいけば、cmakeビルドチェーンを捨てるのではなく、さらに悪いことに、2つの個別のビルド環境を維持する必要がない他の人を助けることができます。トピックから外れている場合はお詫びします。

これを達成するにはどうすればよいですか?

  1. setuptools.Extensionクラスを、sourcesまたはlibsプロパティのエントリを含まない独自のクラスで拡張します。

  2. 必要なビルドステップ(git、svn、cmake、cmake --build)を実行するカスタムメソッドを持つ独自のクラスでsetuptools.commands.build_ext.build_extクラスを拡張します

  3. 独自のクラスを使用してdistutils.command.install_data.install_dataクラスを拡張し(yuck、distutils...に相当するsetuputilsはないようです)、setuptoolsのレコード作成中にビルドされたバイナリライブラリをマークします(installed-files.txt)など

    • ライブラリは記録され、pip uninstall package_nameでアンインストールされます

    • コマンドpy setup.py bdist_wheelもネイティブで動作し、ソースコードのプリコンパイルされたバージョンを提供するために使用できます

  4. setuptools.command.install_lib.install_libクラスを自分のクラスで拡張します。これにより、ビルドされたライブラリが、結果のビルドフォルダーから、setuptoolsが予期するフォルダーに確実に移動します(Windowsでは、.dllファイルが配置されますbin/Releaseフォルダーにあり、setuptoolsが予期する場所ではありません)

  5. スクリプトファイルが正しいディレクトリにコピーされるように、setuptools.command.install_scripts.install_scriptsクラスを独自のクラスで拡張します(Blenderは2.79または任意のディレクトリがスクリプトの場所にあると想定しています)

  6. ビルド手順が実行された後、それらのファイルを、setuptoolsが私の環境のsite-packagesディレクトリにコピーする既知のディレクトリにコピーします。この時点で、残りのsetuptoolsクラスとdistutilsクラスがinstalled-files.txtレコードの書き込みを引き継ぎ、完全に削除可能になります!

サンプル

これは、多かれ少なかれ私のリポジトリからのサンプルですが、より具体的なものを明確にするためにトリミングされています(いつでもリポジトリにアクセスして自分で確認できます)

from distutils.command.install_data import install_data
from setuptools import find_packages, setup, Extension
from setuptools.command.build_ext import build_ext
from setuptools.command.install_lib import install_lib
from setuptools.command.install_scripts import install_scripts
import struct

BITS = struct.calcsize("P") * 8
PACKAGE_NAME = "example"

class CMakeExtension(Extension):
    """
    An extension to run the cmake build

    This simply overrides the base extension class so that setuptools
    doesn't try to build your sources for you
    """

    def __init__(self, name, sources=[]):

        super().__init__(name = name, sources = sources)

class InstallCMakeLibsData(install_data):
    """
    Just a wrapper to get the install data into the Egg-info

    Listing the installed files in the Egg-info guarantees that
    all of the package files will be uninstalled when the user
    uninstalls your package through pip
    """

    def run(self):
        """
        Outfiles are the libraries that were built using cmake
        """

        # There seems to be no other way to do this; I tried listing the
        # libraries during the execution of the InstallCMakeLibs.run() but
        # setuptools never tracked them, seems like setuptools wants to
        # track the libraries through package data more than anything...
        # help would be appriciated

        self.outfiles = self.distribution.data_files

class InstallCMakeLibs(install_lib):
    """
    Get the libraries from the parent distribution, use those as the outfiles

    Skip building anything; everything is already built, forward libraries to
    the installation step
    """

    def run(self):
        """
        Copy libraries from the bin directory and place them as appropriate
        """

        self.announce("Moving library files", level=3)

        # We have already built the libraries in the previous build_ext step

        self.skip_build = True

        bin_dir = self.distribution.bin_dir

        # Depending on the files that are generated from your cmake
        # build chain, you may need to change the below code, such that
        # your files are moved to the appropriate location when the installation
        # is run

        libs = [os.path.join(bin_dir, _lib) for _lib in 
                os.listdir(bin_dir) if 
                os.path.isfile(os.path.join(bin_dir, _lib)) and 
                os.path.splitext(_lib)[1] in [".dll", ".so"]
                and not (_lib.startswith("python") or _lib.startswith(PACKAGE_NAME))]

        for lib in libs:

            shutil.move(lib, os.path.join(self.build_dir,
                                          os.path.basename(lib)))

        # Mark the libs for installation, adding them to 
        # distribution.data_files seems to ensure that setuptools' record 
        # writer appends them to installed-files.txt in the package's Egg-info
        #
        # Also tried adding the libraries to the distribution.libraries list, 
        # but that never seemed to add them to the installed-files.txt in the 
        # Egg-info, and the online recommendation seems to be adding libraries 
        # into eager_resources in the call to setup(), which I think puts them 
        # in data_files anyways. 
        # 
        # What is the best way?

        # These are the additional installation files that should be
        # included in the package, but are resultant of the cmake build
        # step; depending on the files that are generated from your cmake
        # build chain, you may need to modify the below code

        self.distribution.data_files = [os.path.join(self.install_dir, 
                                                     os.path.basename(lib))
                                        for lib in libs]

        # Must be forced to run after adding the libs to data_files

        self.distribution.run_command("install_data")

        super().run()

class InstallCMakeScripts(install_scripts):
    """
    Install the scripts in the build dir
    """

    def run(self):
        """
        Copy the required directory to the build directory and super().run()
        """

        self.announce("Moving scripts files", level=3)

        # Scripts were already built in a previous step

        self.skip_build = True

        bin_dir = self.distribution.bin_dir

        scripts_dirs = [os.path.join(bin_dir, _dir) for _dir in
                        os.listdir(bin_dir) if
                        os.path.isdir(os.path.join(bin_dir, _dir))]

        for scripts_dir in scripts_dirs:

            shutil.move(scripts_dir,
                        os.path.join(self.build_dir,
                                     os.path.basename(scripts_dir)))

        # Mark the scripts for installation, adding them to 
        # distribution.scripts seems to ensure that the setuptools' record 
        # writer appends them to installed-files.txt in the package's Egg-info

        self.distribution.scripts = scripts_dirs

        super().run()

class BuildCMakeExt(build_ext):
    """
    Builds using cmake instead of the python setuptools implicit build
    """

    def run(self):
        """
        Perform build_cmake before doing the 'normal' stuff
        """

        for extension in self.extensions:

            if extension.name == 'example_extension':

                self.build_cmake(extension)

        super().run()

    def build_cmake(self, extension: Extension):
        """
        The steps required to build the extension
        """

        self.announce("Preparing the build environment", level=3)

        build_dir = pathlib.Path(self.build_temp)

        extension_path = pathlib.Path(self.get_ext_fullpath(extension.name))

        os.makedirs(build_dir, exist_ok=True)
        os.makedirs(extension_path.parent.absolute(), exist_ok=True)

        # Now that the necessary directories are created, build

        self.announce("Configuring cmake project", level=3)

        # Change your cmake arguments below as necessary
        # Below is just an example set of arguments for building Blender as a Python module

        self.spawn(['cmake', '-H'+SOURCE_DIR, '-B'+self.build_temp,
                    '-DWITH_PLAYER=OFF', '-DWITH_PYTHON_INSTALL=OFF',
                    '-DWITH_PYTHON_MODULE=ON',
                    f"-DCMAKE_GENERATOR_PLATFORM=x"
                    f"{'86' if BITS == 32 else '64'}"])

        self.announce("Building binaries", level=3)

        self.spawn(["cmake", "--build", self.build_temp, "--target", "INSTALL",
                    "--config", "Release"])

        # Build finished, now copy the files into the copy directory
        # The copy directory is the parent directory of the extension (.pyd)

        self.announce("Moving built python module", level=3)

        bin_dir = os.path.join(build_dir, 'bin', 'Release')
        self.distribution.bin_dir = bin_dir

        pyd_path = [os.path.join(bin_dir, _pyd) for _pyd in
                    os.listdir(bin_dir) if
                    os.path.isfile(os.path.join(bin_dir, _pyd)) and
                    os.path.splitext(_pyd)[0].startswith(PACKAGE_NAME) and
                    os.path.splitext(_pyd)[1] in [".pyd", ".so"]][0]

        shutil.move(pyd_path, extension_path)

        # After build_ext is run, the following commands will run:
        # 
        # install_lib
        # install_scripts
        # 
        # These commands are subclassed above to avoid pitfalls that
        # setuptools tries to impose when installing these, as it usually
        # wants to build those libs and scripts as well or move them to a
        # different place. See comments above for additional information

setup(name='my_package',
      version='1.0.0a0',
      packages=find_packages(),
      ext_modules=[CMakeExtension(name="example_extension")],
      description='An example cmake extension module',
      long_description=open("./README.md", 'r').read(),
      long_description_content_type="text/markdown",
      keywords="test, cmake, extension",
      classifiers=["Intended Audience :: Developers",
                   "License :: OSI Approved :: "
                   "GNU Lesser General Public License v3 (LGPLv3)",
                   "Natural Language :: English",
                   "Programming Language :: C",
                   "Programming Language :: C++",
                   "Programming Language :: Python",
                   "Programming Language :: Python :: 3.6",
                   "Programming Language :: Python :: Implementation :: CPython"],
      license='GPL-3.0',
      cmdclass={
          'build_ext': BuildCMakeExt,
          'install_data': InstallCMakeLibsData,
          'install_lib': InstallCMakeLibs,
          'install_scripts': InstallCMakeScripts
          }
    )

setup.pyがこの方法で作成されると、pythonモジュールのビルドはpy setup.pyを実行するのと同じくらい簡単で、ビルドを実行して出力ファイルを生成します。

遅いインターネットを使用しているユーザー、またはソースからビルドしたくないユーザーのためにホイールを作成することをお勧めします。そのためには、wheelパッケージ(py -m pip install wheel)をインストールし、py setup.py bdist_wheelを実行してホイールディストリビューションを作成し、twineを使用してアップロードします。他のパッケージ。

8
Tyler Gubala