Initial commit

Author: virtuald

.gitignore

@@ -0,0 +1,8 @@
+*.egg-info
+*.pyc
+__pycache__
+
+.vscode
+
+/dist
+/build

.gitmodules

@@ -0,0 +1,3 @@
+[submodule "robotpy_build/pybind11"]
+	path = robotpy_build/pybind11
+	url = https://github.com/pybind/pybind11.git

MANIFEST.in

@@ -0,0 +1,2 @@
+recursive-include robotpy_build/pybind11/include *.h
+recursive-include robotpy_build/templates *.j2

README.md

@@ -0,0 +1,32 @@
+robotpy-build
+=============
+
+This is a build tool designed to meet the needs of RobotPy's various wrapper
+libraries build needs, chiefly around:
+
+* Managing upstream binary dependencies
+* Autogenerating pybind11 wrappers around those dependencies
+* Building wheels from those generated wrappers
+
+Requires Python 3.6+
+
+Workflow
+--------
+
+There are two types of generated artifacts from RobotPy wrapper library
+projects:
+
+* sdist - This should contain enough information to build a wheel
+  * This is NOT intended to be usable offline, because upstream artifacts
+    can get to be fairly large
+* wheel - Platform specific build installable via pip
+  * Should contain headers and libraries necessary for other projects
+    to build from it
+
+Eventual goal is to support cross-compilation somehow so we can build
+various types of artifacts via CI
+
+Usage
+-----
+
+TODO: This tool is still very much under development

robotpy_build/__init__.py

@@ -0,0 +1,19 @@
+from distutils.core import Command
+
+
+class BuildDl(Command):
+
+    command_name = "build_dl"
+    description = "Downloads files"
+    user_options = []
+    wrappers = []
+
+    def initialize_options(self):
+        pass
+
+    def finalize_options(self):
+        pass
+
+    def run(self):
+        for wrapper in self.wrappers:
+            wrapper.on_build_dl()

robotpy_build/command/__init__.py

@@ -0,0 +1,89 @@
+from setuptools import setup, Extension
+from setuptools.command.build_ext import build_ext
+import sys
+import setuptools
+
+
+# As of Python 3.6, CCompiler has a `has_flag` method.
+# cf http://bugs.python.org/issue26689
+def has_flag(compiler, flagname):
+    """Return a boolean indicating whether a flag name is supported on
+    the specified compiler.
+    """
+    import tempfile
+
+    with tempfile.NamedTemporaryFile("w", suffix=".cpp") as f:
+        f.write("int main (int argc, char **argv) { return 0; }")
+        try:
+            compiler.compile([f.name], extra_postargs=[flagname])
+        except setuptools.distutils.errors.CompileError:
+            return False
+    return True
+
+
+def cpp_flag(compiler):
+    """Return the -std=c++[11/14/17] compiler flag.
+    The newer version is prefered over c++11 (when it is available).
+    """
+    flags = ["-std=c++17", "-std=c++14", "-std=c++11"]
+
+    for flag in flags:
+        if has_flag(compiler, flag):
+            return flag
+
+    raise RuntimeError("Unsupported compiler -- at least C++11 support is needed!")
+
+
+class BuildExt(build_ext):
+    """A custom build extension for adding compiler-specific options."""
+
+    c_opts = {"msvc": ["/EHsc"], "unix": []}
+    l_opts = {"msvc": [], "unix": []}
+
+    if sys.platform == "darwin":
+        darwin_opts = ["-stdlib=libc++", "-mmacosx-version-min=10.7"]
+        c_opts["unix"] += darwin_opts
+        l_opts["unix"] += darwin_opts
+
+    def build_extensions(self):
+        ct = self.compiler.compiler_type
+        opts = self.c_opts.get(ct, [])
+        link_opts = self.l_opts.get(ct, [])
+        if ct == "unix":
+            opts.append("-s")  # strip
+            opts.append("-g0")  # remove debug symbols
+            opts.append('-DVERSION_INFO="%s"' % self.distribution.get_version())
+            opts.append(cpp_flag(self.compiler))
+            if has_flag(self.compiler, "-fvisibility=hidden"):
+                opts.append("-fvisibility=hidden")
+        elif ct == "msvc":
+            opts.append('/DVERSION_INFO=\\"%s\\"' % self.distribution.get_version())
+        for ext in self.extensions:
+            ext.extra_compile_args = opts
+            ext.extra_link_args = link_opts
+
+        # self._gather_global_includes()
+
+        build_ext.build_extensions(self)
+
+    def run(self):
+
+        # files need to be generated before building can occur
+        self.run_command("build_gen")
+
+        build_ext.run(self)
+
+
+# ext_modules = [
+#     Extension(
+#         "python_example",
+#         ["src/main.cpp"],
+#         include_dirs=[
+#             # include dirs: iterate robotpy-build entrypoints, retrieve
+#         ],
+#         # library_dirs=
+#         # libraries=
+#         language="c++",
+#     )
+# ]
+

robotpy_build/command/build_dl.py

@@ -0,0 +1,22 @@
+from distutils.core import Command
+
+
+class BuildGen(Command):
+
+    command_name = "build_gen"
+    description = "Generates source files"
+    user_options = []
+    wrappers = []
+
+    def initialize_options(self):
+        pass
+
+    def finalize_options(self):
+        pass
+
+    def run(self):
+        # files need to be downloaded before building can occur
+        self.run_command("build_dl")
+
+        for wrapper in self.wrappers:
+            wrapper.on_build_gen()

robotpy_build/command/build_ext.py

@@ -0,0 +1,48 @@
+# For validating pyproject.toml
+
+from schematics.models import Model
+from schematics.types import ModelType, BooleanType, StringType, ListType, DictType
+
+
+class WrapperConfig(Model):
+    """
+        Wrapper configurations
+    """
+
+    # List of extra headers to export
+    extra_headers = ListType(StringType, default=[])
+
+    # List of robotpy-build library dependencies
+    # .. would be nice to auto-infer this from the python install dependencies
+    depends = ListType(StringType, default=[])
+
+    #
+    # Download settings
+    #
+
+    # Library name
+    libname = StringType(required=True)
+
+    # Name of artifact to download, if different than libname
+    artname = StringType(default="")
+
+    # URL to download
+    baseurl = StringType(required=True)
+
+    # Version of artifact to download
+    version = StringType(required=True)
+
+    #
+    # Wrapper generation settings
+    #
+
+    # Source files to compile
+    sources = ListType(StringType, default=[])
+
+    # List of dictionaries: each dictionary key is the function
+    # name for the initialization function, the value is the
+    # header that is being wrapped
+    generate = ListType(DictType(StringType))
+
+    # Path to a data.yml to use during code generation
+    generation_data = StringType()

robotpy_build/command/build_gen.py

@@ -0,0 +1,65 @@
+import atexit
+import os
+from os.path import exists, join
+import posixpath
+import shutil
+import sys
+import tempfile
+import zipfile
+
+
+from urllib.request import urlretrieve, urlcleanup
+
+
+def _download(url):
+    """
+        Downloads a file to a temporary directory
+    """
+
+    print("Downloading", posixpath.basename(url))
+
+    def _reporthook(count, blocksize, totalsize):
+        percent = int(count * blocksize * 100 / totalsize)
+        sys.stdout.write("\r%02d%%" % percent)
+        sys.stdout.flush()
+
+    filename, _ = urlretrieve(url, reporthook=_reporthook)
+    atexit.register(urlcleanup)
+    return filename
+
+
+def download_and_extract_zip(url, to=None):
+    """
+        Utility method intended to be useful for downloading/extracting
+        third party source zipfiles
+
+        :param to: is either a string or a dict of {src: dst}
+    """
+
+    if to is None:
+        # generate temporary directory
+        tod = tempfile.TemporaryDirectory()
+        to = tod.name
+        atexit.register(tod.cleanup)
+
+    zip_fname = None
+    cache = os.environ.get("RPY_DEVDIR")
+    if cache:
+        os.makedirs(cache, exist_ok=True)
+        cache_fname = join(cache, posixpath.basename(url))
+        if not exists(cache_fname):
+            zip_fname = _download(url)
+            shutil.copy(zip_fname, cache_fname)
+        zip_fname = cache_fname
+    else:
+        zip_fname = _download(url)
+
+    with zipfile.ZipFile(zip_fname) as z:
+        if isinstance(to, str):
+            z.extractall(to)
+            return to
+        else:
+            for src, dst in to.items():
+                with z.open(src, "r") as zfp:
+                    with open(dst, "wb") as fp:
+                        shutil.copyfileobj(zfp, fp)