fix(build): recover python wheel build with proper versioning

rcarcasses · rcarcasses · commit 108cf5a7b0e4 · 2025-09-17T11:41:57.000+01:00
diff --git a/BUILD.bazel b/BUILD.bazel
@@ -2,6 +2,8 @@ load("@aspect_rules_js//js:defs.bzl", "js_library")
 load("@aspect_rules_ts//ts:defs.bzl", "ts_config")
 load("@npm//:defs.bzl", "npm_link_all_packages")
 load("@aspect_rules_js//npm:defs.bzl", "npm_link_package")
+load("@bazel_skylib//rules:write_file.bzl", "write_file")
+load("@aspect_bazel_lib//lib:expand_template.bzl", "expand_template")
 
 package(default_visibility = ["//visibility:public"])
 
@@ -35,3 +37,17 @@ js_library(
     name = "package_json",
     srcs = ["package.json"],
 )
+
+# Global version computation that can be reused across all targets
+write_file(
+    name = "version_tmpl",
+    out = "version.txt.tmpl",
+    content = ["{{RTBOT_VERSION}}"],
+)
+
+expand_template(
+    name = "version",
+    out = "version.txt",
+    stamp_substitutions = {"{{RTBOT_VERSION}}": "{{RTBOT_VERSION}}"},
+    template = ":version_tmpl",
+)
diff --git a/libs/wrappers/python/BUILD.bazel b/libs/wrappers/python/BUILD.bazel
@@ -2,6 +2,8 @@ load("@pybind11_bazel//:build_defs.bzl", "pybind_extension")
 load("@rules_python//python:packaging.bzl", "py_package", "py_wheel")
 load("//tools/generator:generator.bzl", "rtbot_generate")
 load("@aspect_bazel_lib//lib:copy_to_directory.bzl", "copy_to_directory")
+load("@aspect_bazel_lib//lib:expand_template.bzl", "expand_template")
+load("@bazel_skylib//rules:write_file.bzl", "write_file")
 load("@py_deps//:requirements.bzl", "requirement")
 
 package(default_visibility = ["//visibility:public"])
@@ -68,25 +70,28 @@ copy_to_directory(
     }),
 )
 
-genrule(
-    name = "version",
-    outs = ["version.txt"],
-    cmd = "cat bazel-out/stable-status.txt | grep '^VERSION ' | cut -d' ' -f2 > $@",
-    stamp = 1,
-)
+# Use global version from root BUILD.bazel
 
 py_wheel(
-    name = "rtbot_wheel",
+    name = "rtbot_wheel_base",
     distribution = "rtbot",
     python_tag = "py3",
     stamp = 1,
     strip_path_prefixes = [
         "libs/wrappers/python",
     ],
-    version = "0.1.0",  # We'll need to read from version file in setup.py
+    version = "{RTBOT_VERSION}",  # Dynamic version from workspace status
     deps = [":copy"],
 )
 
+genrule(
+    name = "rtbot_wheel",
+    srcs = [":rtbot_wheel_base", "//:version"],
+    outs = ["rtbot.whl"],
+    cmd = "cp $(location :rtbot_wheel_base) $(location rtbot.whl)",
+    stamp = 1,
+)
+
 py_test(
     name = "rtbot_test",
     srcs = ["rtbot_test.py"],
diff --git a/libs/wrappers/python/setup.py b/libs/wrappers/python/setup.py
@@ -1,135 +1,99 @@
+#!/usr/bin/env python3
+"""
+Minimal setup.py for RtBot Python wrapper.
+
+This setup.py is designed to work with pre-built artifacts from Bazel.
+For development builds, use: bazel build //libs/wrappers/python:rtbot_wheel
+"""
+
 import os
-import platform
-import subprocess
 import sys
-import tempfile
-import shutil
-from setuptools import setup, Extension
-from setuptools.command.build_ext import build_ext
-from setuptools.command.egg_info import egg_info
-
-RTBOT_REPO = "https://github.com/rtbot-dev/rtbot.git"
+from setuptools import setup, find_packages
 
 def get_version():
+    """Get version from git tags, with dev suffix if ahead of latest tag."""
+    import subprocess
+
     try:
-        output = subprocess.check_output(
-            ['bash', '-c', "grep '^VERSION ' dist/out/stable-status.txt | cut -d' ' -f2"],
+        # Get the latest git tag
+        latest_tag = subprocess.check_output(
+            ['git', 'describe', '--tags', '--abbrev=0'],
             stderr=subprocess.PIPE
         ).decode().strip()
-        return output if output else "0.1.0"
-    except:
-        return "0.1.0"
-
-class BazelExtension(Extension):
-    def __init__(self, name):
-        super().__init__(name, sources=[])
 
-class CustomEggInfo(egg_info):
-    def run(self):
-        os.makedirs('rtbot', exist_ok=True)
-        super().run()
+        # Remove 'v' prefix if present
+        if latest_tag.startswith('v'):
+            latest_tag = latest_tag[1:]
 
-class BazelBuildExt(build_ext):
-    def run(self):
-        self._install_bazelisk()
-        repo_dir = self._get_repo_dir()
-        self._build_rtbot(repo_dir)
-    
-    def _get_repo_dir(self):
-        current_dir = os.path.abspath(os.getcwd())
-        while current_dir != '/':
-            if os.path.exists(os.path.join(current_dir, 'WORKSPACE')):
-                return current_dir
-            current_dir = os.path.dirname(current_dir)
-            
-        tmp_dir = tempfile.mkdtemp()
-        self._clone_repo(tmp_dir)
-        return tmp_dir
+        # Get current commit description
+        git_describe = subprocess.check_output(
+            ['git', 'describe', '--tags', '--always'],
+            stderr=subprocess.PIPE
+        ).decode().strip()
 
-    def _install_bazelisk(self):
-        try:
-            subprocess.check_call(['bazelisk', '--version'])
-            return
-        except (subprocess.CalledProcessError, FileNotFoundError):
-            pass
+        # If we're exactly on a tag, use that version
+        if git_describe == f'v{latest_tag}' or git_describe == latest_tag:
+            return latest_tag
 
-        print("Installing bazelisk...")
-        system = platform.system().lower()
-        arch = platform.machine().lower()
-        
-        if system == 'windows':
-            url = f"https://github.com/bazelbuild/bazelisk/releases/latest/download/bazelisk-windows-{arch}.exe"
-            out = "bazelisk.exe"
-        else:
-            url = f"https://github.com/bazelbuild/bazelisk/releases/latest/download/bazelisk-{system}-{arch}"
-            out = "bazelisk"
-        
-        subprocess.check_call(['curl', '-L', url, '-o', out])
-        if system != 'windows':
-            os.chmod(out, 0o755)
-        
-        os.environ['PATH'] = os.getcwd() + os.pathsep + os.environ['PATH']
+        # If we're ahead of the tag, create a dev version
+        # Format: v0.3.8-135-gc6ee14a -> 0.3.8.dev135+gc6ee14a
+        parts = git_describe.split('-')
+        if len(parts) >= 3:
+            tag_part = parts[0]
+            if tag_part.startswith('v'):
+                tag_part = tag_part[1:]
+            commits_ahead = parts[1]
+            short_sha = parts[2]
+            return f"{tag_part}.dev{commits_ahead}+{short_sha}"
 
-    def _clone_repo(self, tmp_dir):
-        print("Cloning RTBot repository...")
-        subprocess.check_call(['git', 'clone', '--depth', '1', RTBOT_REPO, tmp_dir])
+        # Fallback: just use the tag
+        return latest_tag
 
-    def _get_bazel_bin(self, repo_dir):
-        bazel_cmd = 'bazelisk' if platform.system().lower() != 'windows' else 'bazelisk.exe'
+    except (subprocess.CalledProcessError, FileNotFoundError, IndexError):
+        # Fallback to reading from Bazel build if git fails
         try:
-            bazel_bin = subprocess.check_output(
-                [bazel_cmd, 'info', 'bazel-bin'],
-                cwd=repo_dir,
-                text=True
-            ).strip()
-            return bazel_bin
-        except subprocess.CalledProcessError:
-            return os.path.join(repo_dir, 'dist')  # Fallback to --symlink_prefix value
-
-    def _build_rtbot(self, repo_dir):
-        print("Building RTBot...")
-        bazel_cmd = 'bazelisk' if platform.system().lower() != 'windows' else 'bazelisk.exe'
-        
-        subprocess.check_call(
-            [bazel_cmd, 'build', '//libs/wrappers/python:rtbotapi.so', '//libs/wrappers/python:copy'],
-            cwd=repo_dir
-        )
-        
-        bazel_bin = self._get_bazel_bin(repo_dir)
-        package_dir = os.path.join(self.build_lib, 'rtbot')
-        os.makedirs(package_dir, exist_ok=True)
+            version_file = "dist/bin/libs/wrappers/python/version.txt"
+            if os.path.exists(version_file):
+                with open(version_file, 'r') as f:
+                    return f.read().strip()
+        except:
+            pass
+        return "0.1.0"
 
-        # Copy files from bazel-bin
-        copy_dir = os.path.join(bazel_bin, 'libs/wrappers/python/rtbot')
-        for item in ['MANIFEST.in', 'README.md', 'operators.py', 'setup.py', '__init__.py']:
-            src = os.path.join(copy_dir, item)
-            if os.path.exists(src):
-                shutil.copy2(src, package_dir)
+# Check if we're in development mode (rtbotapi.so exists locally)
+has_extension = os.path.exists("rtbotapi.so") or os.path.exists("rtbotapi.pyd")
 
-        # Copy the extension
-        ext_path = os.path.join(bazel_bin, 'libs/wrappers/python/rtbotapi.so')
-        if platform.system().lower() == 'windows':
-            ext_path = ext_path.replace('.so', '.pyd')
-        
-        if os.path.exists(ext_path):
-            shutil.copy2(ext_path, package_dir)
-        else:
-            raise RuntimeError(f"Built extension not found at {ext_path}")
+if not has_extension:
+    print("Error: rtbot extension not found.")
+    print("This package requires pre-built artifacts from Bazel.")
+    print("Run: bazel build //libs/wrappers/python:copy")
+    print("Then copy the artifacts to this directory before running setup.py")
+    sys.exit(1)
 
 setup(
     name='rtbot',
     version=get_version(),
-    description='Python bindings for RTBot framework',
-    author='RTBot Developers',
+    description='Python bindings for RtBot framework',
+    long_description='RtBot is a real-time data processing framework with Python bindings.',
+    long_description_content_type='text/plain',
+    author='RtBot Developers',
     url='https://github.com/rtbot-dev/rtbot',
-    ext_modules=[BazelExtension('rtbot')],
-    cmdclass={
-        'build_ext': BazelBuildExt,
-        'egg_info': CustomEggInfo,
+    packages=find_packages(),
+    package_data={
+        'rtbot': ['*.so', '*.pyd', '*.py'],
     },
-    packages=['rtbot'],
     install_requires=[
         "pandas>=1.0.0"
     ],
     python_requires='>=3.10',
+    classifiers=[
+        'Development Status :: 3 - Alpha',
+        'Intended Audience :: Developers',
+        'License :: OSI Approved :: Apache Software License',
+        'Programming Language :: Python :: 3',
+        'Programming Language :: Python :: 3.10',
+        'Programming Language :: Python :: 3.11',
+        'Programming Language :: Python :: 3.12',
+        'Programming Language :: Python :: 3.13',
+    ],
 )
diff --git a/tools/bazel_workspace_status.sh b/tools/bazel_workspace_status.sh
@@ -27,3 +27,33 @@ echo "CURRENT_TIME $(date +%s)"
 echo "STABLE_GIT_COMMIT $(git rev-parse HEAD)"
 echo "STABLE_SHORT_GIT_COMMIT $(git rev-parse HEAD | cut -c 1-8)"
 echo "STABLE_USER_NAME $USER"
+
+# Generate dynamic version for RtBot Python wheel
+if git describe --tags --abbrev=0 >/dev/null 2>&1; then
+    LATEST_TAG=$(git describe --tags --abbrev=0)
+    GIT_DESCRIBE=$(git describe --tags --always)
+
+    # Remove 'v' prefix if present
+    LATEST_TAG=${LATEST_TAG#v}
+
+    # If we're exactly on a tag, use that version
+    if [ "$GIT_DESCRIBE" = "v$LATEST_TAG" ] || [ "$GIT_DESCRIBE" = "$LATEST_TAG" ]; then
+        RTBOT_VERSION="$LATEST_TAG"
+    else
+        # Parse format: v0.3.8-135-gc6ee14a -> 0.3.8.dev135+gc6ee14a
+        TAG_PART=$(echo "$GIT_DESCRIBE" | cut -d'-' -f1)
+        TAG_PART=${TAG_PART#v}
+        COMMITS_AHEAD=$(echo "$GIT_DESCRIBE" | cut -d'-' -f2)
+        SHORT_SHA=$(echo "$GIT_DESCRIBE" | cut -d'-' -f3)
+
+        if [ -n "$TAG_PART" ] && [ -n "$COMMITS_AHEAD" ] && [ -n "$SHORT_SHA" ]; then
+            RTBOT_VERSION="${TAG_PART}.dev${COMMITS_AHEAD}+${SHORT_SHA}"
+        else
+            RTBOT_VERSION="$LATEST_TAG"
+        fi
+    fi
+else
+    RTBOT_VERSION="0.1.0"
+fi
+
+echo "RTBOT_VERSION $RTBOT_VERSION"
