Remove scikit-build

Author: thijsmie

.azure/publish-release.yml

@@ -38,7 +38,7 @@ variables:
   CONFIGURE: >-
     mkdir -p build &&
     cd build &&
-    cmake ../main -DCMAKE_INSTALL_PREFIX="$CYCLONEDDS_HOME" -DBUILD_SCHEMA=off -DENABLE_SHM=off -DENABLE_SSL=off -DENABLE_SECURITY=off -DENABLE_TOPIC_DISCOVERY=on -DENABLE_TYPE_DISCOVERY=on
+    cmake ../main -DCMAKE_INSTALL_PREFIX="$CYCLONEDDS_HOME" -DBUILD_SCHEMA=off -DENABLE_SHM=off -DENABLE_SSL=on -DENABLE_SECURITY=on -DENABLE_TOPIC_DISCOVERY=on -DENABLE_TYPE_DISCOVERY=on
   BUILD: >-
     cmake --build . --target install
   CIBW_BEFORE_ALL: >-
@@ -48,16 +48,16 @@ variables:
     auditwheel repair -w {dest_dir} {wheel}
   CIBW_ENVIRONMENT_LINUX: >-
     CYCLONEDDS_HOME=/project/install
-    CMAKE_PREFIX_PATH=/project/install
     LD_LIBRARY_PATH=/project/install/lib:/project/install/lib64
+    STANDALONE_WHEELS=1
   # ---- MACOS ----
   CIBW_REPAIR_WHEEL_COMMAND_MACOS: >-
     DYLD_LIBRARY_PATH=$(Build.Repository.LocalPath)/install/lib delocate-listdeps {wheel} &&
     DYLD_LIBRARY_PATH=$(Build.Repository.LocalPath)/install/lib delocate-wheel --require-archs {delocate_archs} -w {dest_dir} {wheel}
   CIBW_ENVIRONMENT_MACOS: >-
     CYCLONEDDS_HOME=$(Build.Repository.LocalPath)/install
-    CMAKE_PREFIX_PATH=$(Build.Repository.LocalPath)/install
     DYLD_LIBRARY_PATH=$(Build.Repository.LocalPath)/install/lib
+    STANDALONE_WHEELS=1
   # ---- WINDOWS ----
   CIBW_REPAIR_WHEEL_COMMAND_WINDOWS: >-
     pip install delvewheel==0.0.14 &&
@@ -93,9 +93,9 @@ jobs:
          $(CLONE) && $(CONFIGURE) -A Win32 && $(BUILD)
   steps:
   - pwsh: |
+      Write-Host "###vso[task.setvariable variable=STANDALONE_WHEELS;]1"
       Write-Host "###vso[task.setvariable variable=PATH;]$(Build.Repository.LocalPath)\\install\\bin;${env:PATH}"
       Write-Host "###vso[task.setvariable variable=CYCLONEDDS_HOME;]$(Build.Repository.LocalPath)\install"
-      Write-Host "###vso[task.setvariable variable=CMAKE_PREFIX_PATH;]$(Build.Repository.LocalPath)\install"
       $a = "${env:CIBW_BEFORE_ALL_WINDOWS_PRE}" -replace "\`$CYCLONEDDS_HOME","$(Build.Repository.LocalPath)\install"
       Write-Host "###vso[task.setvariable variable=CIBW_BEFORE_ALL_WINDOWS;]$a"
     condition: eq(variables['Agent.OS'], 'Windows_NT')
@@ -128,4 +128,3 @@ jobs:
       find artifacts/ -name "*.whl" -exec mv {} wheelhouse \;
     displayName: Collect wheels for publication
   - template: /.azure/templates/publish-package.yml
-

.gitignore

@@ -1,3 +1,6 @@
+# Custom
+cyclonedds/__library__.py
+
 # Byte-compiled / optimized / DLL files
 __pycache__/
 *.py[cod]

README.md

@@ -41,7 +41,7 @@ $ pip3 install --user .[dev]
 $ pip3 install --user .[docs]
 ```
 
-While the quickest way to get going is the `--user` flag it is not the recommended, we recommend using [a virtual environment][2], [poetry][3], [pipenv][4] or [pyenv][5]. After the installation is complete `import cyclonedds` should now work. The `CYCLONEDDS_HOME` variable is essential for the Python backend to locate the CycloneDDS binaries so this always needs to be set when running Python code with Cyclone DDS. Have a look at the [examples](examples/) to learn about how to use the Python API.
+While the quickest way to get going is the `--user` flag it is not the recommended, we recommend using [a virtual environment][2], [poetry][3], [pipenv][4] or [pyenv][5]. After the installation is complete `import cyclonedds` should now work. Have a look at the [examples](examples/) to learn about how to use the Python API.
 
 You can also run the idl compiler in Python mode if it the Python package is installed. Simply run `idlc -l py file.idl` and a Python module with your types will be generated in the current working directory. If you wish to nest the resulting Python module inside an existing package you can specify the path from the intended root. So if you have a package 'wubble' with a submodule 'fruzzy' and want the generated modules and types under there you can do `idlc -l py -p py-root-prefix=wubble.fruzzy file.idl`.
 

buildhelp/bdist_wheel.py

@@ -0,0 +1,39 @@
+from wheel.bdist_wheel import bdist_wheel as _bdist_wheel
+from cyclone_search import find_cyclonedds
+from pathlib import Path
+import shutil
+import os
+
+
+class bdist_wheel(_bdist_wheel):
+    def initialize_options(self):
+        self.standalone = os.environ.get("STANDALONE_WHEELS") == "1"
+        super().initialize_options()
+
+    def finalize_options(self):
+        if self.standalone:
+            self.distribution.entry_points["console_scripts"].append("idlc=cyclonedds.tools.wheel_idlc:command")
+        super().finalize_options()
+
+    def run(self):
+        if self.standalone:
+            cyclone = find_cyclonedds()
+
+            newlibdir = Path(self.bdist_dir) / 'cyclonedds' / '.libs'
+
+            os.makedirs(newlibdir, exist_ok=True)
+            with open(Path(self.bdist_dir) / 'cyclonedds' / '__library__.py', "w", encoding='utf-8') as f:
+                f.write("from pathlib import Path\n\n")
+                f.write("in_wheel = True\n")
+                f.write(f"library_path = Path(__file__).parent / '.libs' / '{cyclone.ddsc_library.name}'")
+
+            shutil.copy(cyclone.ddsc_library, newlibdir / cyclone.ddsc_library.name)
+
+            if cyclone.idlc_executable and cyclone.idlc_library:
+                shutil.copy(cyclone.idlc_executable, newlibdir / cyclone.idlc_executable.name)
+                shutil.copy(cyclone.idlc_library, newlibdir / cyclone.idlc_library.name)
+
+            for lib in cyclone.security_libs:
+                shutil.copy(lib, newlibdir / lib.name)
+
+        super().run()

buildhelp/build_ext.py

@@ -0,0 +1,19 @@
+from setuptools.command.build_ext import build_ext as _build_ext
+from setuptools import Extension
+
+
+class Library(Extension):
+    pass
+
+
+class build_ext(_build_ext):
+    def get_libraries(self, ext):
+        if isinstance(ext, Library):
+            return ext.libraries
+        return super().get_libraries(ext)
+
+    def get_export_symbols(self, ext):
+        if isinstance(ext, Library):
+            return ext.export_symbols
+        return super().get_export_symbols(ext)
+

buildhelp/cyclone_search.py

@@ -0,0 +1,121 @@
+"""
+ * Copyright(c) 2022 ZettaScale Technology and others
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0, or the Eclipse Distribution License
+ * v. 1.0 which is available at
+ * http://www.eclipse.org/org/documents/edl-v10.php.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR BSD-3-Clause
+"""
+import os
+import platform
+from pathlib import Path
+from typing import List, Optional
+from dataclasses import dataclass
+
+
+@dataclass
+class FoundCycloneResult:
+    home: Path
+    library_path: Path
+    include_path: Path
+    binary_path: Path
+    ddsc_library: Path
+    idlc_executable: Optional[Path]
+    idlc_library: Optional[Path]
+    security_libs: List[Path]
+
+
+def first_or_none(alist):
+    alist = list(alist)
+    if alist:
+        return alist[0]
+
+
+def good_directory(directory: Path):
+    dir = directory.resolve()
+    if not dir.exists():
+        return
+
+    include_path = dir / 'include'
+    bindir = dir / 'bin'
+
+    if not include_path.exists() or not bindir.exists():
+        return
+
+    libdir = dir / 'lib'
+    if not libdir.exists():
+        libdir = dir / 'lib64'
+        if not libdir.exists():
+            return None
+
+    if platform.system() == 'Windows':
+        ddsc_library = bindir / "ddsc.dll"
+    elif platform.system() == 'Darwin':
+        ddsc_library = libdir / "libddsc.dylib"
+    else:
+        ddsc_library = libdir / "libddsc.so"
+
+    if not ddsc_library.exists():
+        return None
+
+    idlc_executable = first_or_none(bindir.glob("idlc*"))
+    idlc_library = first_or_none(libdir.glob('libcycloneddsidl*')) or first_or_none(bindir.glob("cycloneddsidl*"))
+    security_libs = list(libdir.glob("*dds_security_*")) + list(bindir.glob("*dds_security_*"))
+
+    return FoundCycloneResult(
+        home=dir,
+        include_path=include_path,
+        library_path=libdir,
+        binary_path=bindir,
+        ddsc_library=ddsc_library,
+        idlc_executable=idlc_executable,
+        idlc_library=idlc_library,
+        security_libs=security_libs
+    )
+
+
+def search_cyclone_pathlike(pathlike, upone=False):
+    for path in pathlike.split(os.pathsep):
+        if upone:
+            return good_directory(Path(path) / '..')
+        else:
+            return good_directory(Path(path))
+
+
+def find_cyclonedds() -> Optional[FoundCycloneResult]:
+    if "CYCLONEDDS_HOME" in os.environ:
+        dir = good_directory(Path(os.environ["CYCLONEDDS_HOME"]))
+        if dir:
+            return dir
+    if "CycloneDDS_ROOT" in os.environ:
+        dir = good_directory(Path(os.environ["CMAKE_CycloneDDS_ROOT"]))
+        if dir:
+            return dir
+    if "CycloneDDS_ROOT" in os.environ:
+        dir = good_directory(Path(os.environ["CycloneDDS_ROOT"]))
+        if dir:
+            return dir
+    if "CMAKE_PREFIX_PATH" in os.environ:
+        dir = search_cyclone_pathlike(os.environ["CMAKE_PREFIX_PATH"])
+        if dir:
+            return dir
+    if "CMAKE_LIBRARY_PATH" in os.environ:
+        dir = search_cyclone_pathlike(os.environ["CMAKE_LIBRARY_PATH"])
+        if dir:
+            return dir
+    if platform.system() != "Windows" and "LIBRARY_PATH" in os.environ:
+        dir = search_cyclone_pathlike(os.environ["LIBRARY_PATH"], upone=True)
+        if dir:
+            return dir
+    if platform.system() != "Windows" and "LD_LIBRARY_PATH" in os.environ:
+        dir = search_cyclone_pathlike(os.environ["LD_LIBRARY_PATH"], upone=True)
+        if dir:
+            return dir
+    if platform.system() == "Windows" and "PATH" in os.environ:
+        dir = search_cyclone_pathlike(os.environ["PATH"], upone=True)
+        if dir:
+            return dir
+

cyclonedds/__idlc__.py

@@ -10,21 +10,13 @@
  * SPDX-License-Identifier: EPL-2.0 OR BSD-3-Clause
 """
 
-from os import path, listdir
 from sys import exit
+from pathlib import Path
 
 
-dir = path.abspath(path.join(path.dirname(__file__), ".libs"))
-libs = [f for f in listdir(dir) if "idl" in f]
-
-if not libs:
-    idlpy_lib = None
-else:
-    idlpy_lib = path.join(dir, libs[0])
+idlpy_path = list(Path(__file__).resolve().parent.glob("_idlpy*"))[0]
 
 
 if __name__ == "__main__":
-    if not idlpy_lib:
-        exit(1)
-    print(idlpy_lib, end="", flush=True)
+    print(idlpy_path, end="", flush=True)
     exit(0)

cyclonedds/internal.py

@@ -18,6 +18,7 @@
 from ctypes.util import find_library
 from functools import wraps
 from dataclasses import dataclass
+from .__library__ import library_path, in_wheel
 
 
 class CycloneDDSLoaderException(Exception):
@@ -26,24 +27,19 @@ class CycloneDDSLoaderException(Exception):
 
 def _load(path):
     """Most basic loader, return the loaded DLL on path"""
-    library = ct.CDLL(path)
+    try:
+        library = ct.CDLL(path)
+    except OSError:
+        raise CycloneDDSLoaderException(f"Failed to load CycloneDDS library from {path}")
     if not library:
-        raise CycloneDDSLoaderException("Failed to load CycloneDDS library from {path}")
+        raise CycloneDDSLoaderException(f"Failed to load CycloneDDS library from {path}")
     return library
 
 
 def _loader_wheel_gen(rel_path, ext):
-    """
-        The tools 'auditwheel', 'delvewheel' and 'delocate' include libddsc into the Python environment in
-        a predictable location. This location differs slightly per tool. Generate a loader given the relative
-        path and platform-dependend extension.
-    """
     def _loader_wheel():
-        origin = os.path.join(os.path.dirname(__file__), *rel_path)
-        if os.path.exists(origin):
-            for file in os.listdir(origin):
-                if "ddsc" in file and ext in file and file.index(ext) > file.index("ddsc"):
-                    return _load(os.path.join(origin, file))
+        if in_wheel:
+            return _load(str(library_path))
         return None
     return _loader_wheel
 
@@ -82,21 +78,32 @@ def _loader_on_path():
     return _loader_on_path
 
 
+
+def _loader_install_path():
+        try:
+            return _load(str(library_path))
+        except CycloneDDSLoaderException:
+            pass
+        return None
+
 _loaders_per_system = {
     "Linux": [
         _loader_wheel_gen(["..", "cyclonedds.libs"], ".so"),
-        _loader_cyclonedds_home_gen("lib/libddsc.so"),
+        _loader_cyclonedds_home_gen(f"lib{os.sep}libddsc.so"),
         _loader_on_path_gen("libddsc.so"),
+        _loader_install_path
     ],
     "Windows": [
         _loader_wheel_gen(["..", "cyclonedds.libs"], ".dll"),
-        _loader_cyclonedds_home_gen("bin\\ddsc.dll"),
-        _loader_on_path_gen("ddsc.dll")
+        _loader_cyclonedds_home_gen(f"bin{os.sep}ddsc.dll"),
+        _loader_on_path_gen("ddsc.dll"),
+        _loader_install_path
     ],
     "Darwin": [
         _loader_wheel_gen([".dylibs"], ".dylib"),
-        _loader_cyclonedds_home_gen("lib/libddsc.dylib"),
+        _loader_cyclonedds_home_gen(f"lib{os.sep}libddsc.dylib"),
         _loader_on_path_gen("libddsc.dylib"),
+        _loader_install_path
     ]
 }
 
@@ -125,7 +132,6 @@ def load_cyclonedds() -> ct.CDLL:
         "Try setting the CYCLONEDDS_HOME variable to what you used as CMAKE_INSTALL_PREFIX."
     )
 
-
 def c_call(cname):
     """
         Decorator. Convert a function into call into the class associated dll.

cyclonedds/tools/wheel_idlc/__init__.py

@@ -11,36 +11,33 @@
 
 
 This tool is used in wheels to perform the idlc command.
-The idlc binary is under cyclonedds/.bin/idlc, libs are under
+The idlc binary is under cyclonedds/.libs/idlc, libs are under
 cyclonedds/.libs.
 """
 
 import os
 import sys
 import platform
-import subprocess
 import cyclonedds
+from pathlib import Path
 
-basedir = os.path.abspath(os.path.dirname(cyclonedds.__file__))
-idlc = os.path.join(basedir, ".bin", "idlc")
-if platform.system() == "Windows":
-    idlc += ".exe"
 
-libdir = os.path.join(basedir, ".libs")
+libdir = Path(__file__).resolve().parent / '.libs'
+idlc = (libdir / 'idlc.exe') if platform.system() == "Windows" else (libdir / 'idlc')
 
 
 def command():
-    if not os.path.exists(idlc):
+    if not idlc.exists():
         print("Python idlc entrypoint active but cyclonedds-python installation does not include idlc executable!")
         sys.exit(1)
 
     environ = os.environ.copy()
 
     if platform.system() == "Windows":
-        environ["PATH"] = ";".join([libdir] + environ.get("PATH", "").split(";"))
+        environ["PATH"] = ";".join([str(libdir)] + environ.get("PATH", "").split(";"))
     elif platform.system() == "Darwin":
-        environ["DYLD_LIBRARY_PATH"] = ":".join([libdir] + environ.get("DYLD_LIBRARY_PATH", "").split(":"))
+        environ["DYLD_LIBRARY_PATH"] = ":".join([str(libdir)] + environ.get("DYLD_LIBRARY_PATH", "").split(":"))
     else:
-        environ["LD_LIBRARY_PATH"] = ":".join([libdir] + environ.get("LD_LIBRARY_PATH", "").split(":"))
+        environ["LD_LIBRARY_PATH"] = ":".join([str(libdir)] + environ.get("LD_LIBRARY_PATH", "").split(":"))
 
     os.execvpe(idlc, sys.argv[1:], environ)