Initial commit

Author: harshil21

.gitignore

@@ -0,0 +1,17 @@
+# Python-generated files
+__pycache__/
+*.py[oc]
+build/
+dist/
+wheels/
+*.egg-info
+
+# Virtual environments
+.venv
+
+# Environment variables:
+.env
+
+# Exclude local .deb and .zip files from mscl:
+mscl_release_assets/*.zip
+mscl_release_assets/*.deb

.python-version

@@ -0,0 +1 @@
+3.13

README.md

@@ -0,0 +1,28 @@
+#python-mscl
+
+Unofficial Python bindings for the [Microstrain Communication Library](https://www.microstrain.com/developers/microstrain-communication-library).
+
+This library just makes it so that we can install the MSCL library using pip. Wheels are not provided. This will fetch the necessary files for your architecture and python
+version, and then build the wheel for you.
+
+It is therefore recommended to use a cache for your CI or package manager, unless you're okay with the ~20MB download every time you run your CI.
+
+## Note: NOT PUBLISHED TO PYPI YET - STILL A WIP! CHECK BACK IN A FEW DAYS!
+
+### Installation
+
+```bash
+pip install python-mscl
+```
+
+### Usage
+
+```python
+import mscl
+
+# ... use the MSCL library as you normally would
+```
+
+## Local Development:
+
+TODO

build_helpers/__init__.py

@@ -0,0 +1,72 @@
+"""Downloads the Github release assets for the mscl library."""
+
+import os
+from pathlib import Path
+
+import requests
+from github import Github
+from github.GitRelease import GitRelease
+from github.GitReleaseAsset import GitReleaseAsset
+
+
+class GithubDownloader:
+    """Manages downloading the Github release assets for the mscl library, along with the
+    extracted files from this repository."""
+
+    def __init__(self):
+        self.github = Github(os.getenv("GITHUB_TOKEN"))
+        self.mscl_repo = "LORD-MicroStrain/MSCL"
+        self.python_mscl_repo = "harshil21/python-mscl"
+        self.latest_release = None
+
+    def get_latest_release(self) -> GitRelease:
+        """Returns the latest stable release for the given repo."""
+        if self.latest_release:
+            return self.latest_release
+
+        releases = self.github.get_repo(self.mscl_repo).get_releases()
+        for release in releases:
+            if release.prerelease:
+                continue
+            if release.tag_name.startswith("v"):
+                self.latest_release = release
+                break
+        return self.latest_release
+
+    def download_release_assets(self, output_dir: str):
+        """Downloads the release assets for the given repo and tag."""
+        release = self.get_latest_release()
+        output_path = Path(output_dir)
+        output_path.mkdir(parents=True, exist_ok=True)
+
+        asset: GitReleaseAsset
+        for asset in release.get_assets():
+            # Don't download the "Documentation" or "Examples"
+            if "Documentation" in asset.name or "Examples" in asset.name:
+                continue
+            # Don't download anything non-python:
+            if "Python" not in asset.name:
+                continue
+            # Only python 3 and above:
+            if "3" not in asset.name:
+                continue
+
+            self.download_asset(output_path, asset)
+
+    def download_asset(self, output_path: Path, asset: GitReleaseAsset) -> None:
+        response = requests.get(asset.browser_download_url, timeout=15)
+        asset_path = output_path / asset.name
+        asset_path.write_bytes(response.content)
+
+    def download_assets_from_folder(self, tag: str, folder_name: str) -> None:
+        """Downloads all the files under the `folder_name` for the given tag, from the
+        root of the repository."""
+
+        repo = self.github.get_repo(self.python_mscl_repo)
+        contents = repo.get_contents(folder_name, ref=tag)
+
+        for content in contents:
+            if content.type == "file":
+                response = requests.get(content.download_url, timeout=15)
+                file_path = Path(content.name)
+                file_path.write_bytes(response.content)

build_helpers/release_downloader.py

@@ -0,0 +1,71 @@
+"""Extracts the .deb and .zip releases for the mscl library."""
+
+import os
+import subprocess
+from pathlib import Path
+
+
+class ReleaseExtractor:
+    """Will extract the .deb and .zip releases for the mscl library."""
+
+    def __init__(self):
+        self.asset_dir = Path("mscl_release_assets")
+
+    def extract_assets(self):
+        """Extracts the .deb and .zip releases into the same directory."""
+
+        for file in self.asset_dir.iterdir():
+            if file.suffix == ".deb":
+                self.extract_deb(file)
+            elif file.suffix == ".zip":
+                self.extract_zip(file)
+
+    def extract_deb(self, file: Path):
+        """Extracts the .deb release."""
+        cwd = Path().cwd()
+
+        # Create a directory to extract the .deb file. Syntax: mscl-<arch>-<python-ver>-<mscl-ver>
+        parts = file.stem.split("_")
+        arch, py_ver, mscl_ver = parts[1], parts[2], parts[3]
+        mscl_versioned_name = f"mscl-{arch}-{py_ver}-{mscl_ver}"
+        mscl_versioned_dir = cwd / self.asset_dir / mscl_versioned_name
+
+        # If output directory exists, remove it:
+        if mscl_versioned_dir.exists():
+            os.system(f"rm -rf {mscl_versioned_dir}")  # noqa: S605
+
+        mscl_versioned_dir.mkdir(parents=True, exist_ok=True)
+        file_relative = file.absolute().relative_to(mscl_versioned_dir, walk_up=True)
+
+        # Extract the .deb file
+        subprocess.run(["ar", "x", str(file_relative)], cwd=mscl_versioned_dir, check=True)  # noqa: S603, S607
+
+        # Extract the data.tar.gz file:
+        data_tar = "data.tar.gz"
+
+        subprocess.run(["tar", "-xzf", data_tar], cwd=mscl_versioned_dir, check=True)  # noqa: S603, S607
+
+        found_mscl_py = list(mscl_versioned_dir.rglob("mscl.py"))
+        found_mscl_so = list(mscl_versioned_dir.rglob("_mscl.so"))
+
+        if not found_mscl_py or not found_mscl_so:
+            raise FileNotFoundError(f"Could not find mscl.py or _mscl.so in {mscl_versioned_dir}")
+
+        # Move the extracted files to the root of the mscl_versioned_dir:
+        mscl_py = found_mscl_py[0]
+        mscl_so = found_mscl_so[0]
+
+        mscl_py.rename(mscl_versioned_dir / mscl_py.name)
+        mscl_so.rename(mscl_versioned_dir / mscl_so.name)
+
+        # Delete the remaining files in mscl_versioned_dir:
+        for f in mscl_versioned_dir.iterdir():
+            if f.stem in (mscl_py.stem, mscl_so.stem):
+                continue
+            if f.is_dir():
+                os.system(f"rm -rf {f}")  # noqa: S605
+            else:
+                f.unlink()
+
+    def extract_zip(self, file: Path) -> None:
+        """Extracts the .zip release."""

build_helpers/release_extractor.py

@@ -0,0 +1,76 @@
+"""Specifies a hatch build hook to create the wheel for mscl."""
+
+import platform
+import sys
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).parent))
+
+from hatchling.builders.hooks.plugin.interface import BuildHookInterface
+
+from build_helpers.release_downloader import GithubDownloader
+
+
+class CustomBuildHook(BuildHookInterface):
+    """Build hook to build wheels from the extracted .deb/.zip files."""
+
+    def _python_tag(self) -> str:
+        """Generate the Python tag (e.g., py39 for Python 3.9)."""
+        major = sys.version_info.major
+        minor = sys.version_info.minor
+        return f"cp{major}{minor}"
+
+    def _platform_tag(self) -> str:
+        """Generate the platform tag (e.g., linux_x86_64)."""
+        return platform.system().lower() + "_" + platform.machine()
+
+    def initialize(self, version, build_data):
+        """
+        Called before building the wheel/sdist.
+        We can download & extract the .deb here, and place
+        mscl.py and _mscl.so into src/mscl_pip/.
+        """
+        build_data["pure_python"] = False
+        self.app.display_info(f"Running on {version=} and {build_data=}")
+        self.app.display_info(self.target_name)
+
+        # --- STEP 1: Determine which python version and arch we are on: ---
+        # a) Python version:
+        # syntax: Python<MAJOR>.<MINOR>
+
+        py_version = f"Python{sys.version_info.major}.{sys.version_info.minor}"
+
+        # b) Architecture:
+        # possible values: amd64, arm64, armhf.
+
+        arch = platform.machine()
+        if arch == "x86_64":
+            arch = "amd64"
+        elif arch == "aarch64":
+            arch = "arm64"
+        elif arch == "armv7l":
+            arch = "armhf"
+        else:
+            # TODO: Windows support
+            raise RuntimeError(f"Unknown architecture: {arch}")
+
+        # c) mscl version to download:
+        mscl_ver = "v67.0.0"
+
+        build_data["tag"] = f"{self._python_tag()}-{self._python_tag()}-{self._platform_tag()}"
+        # --- STEP 2: Download the 2 mscl files (mscl.py and _mscl.so) from the git repo: ---
+        # Folder name: mscl-<arch>-<python-ver>-<mscl-ver>
+
+        # a) Create the folder name:
+        folder_name = f"mscl-{arch}-{py_version}-{mscl_ver}"
+
+        # b) Use PyGithub to download the files from the folder:
+        self.app.display_info(f"Downloading files for {folder_name}...")
+
+        gh = GithubDownloader()
+        gh.download_assets_from_folder(
+            tag=mscl_ver,
+            folder_name=f"mscl_release_assets/{folder_name}",
+        )
+
+        self.display_info("Downloaded files successfully. Building the wheel...")

hatch_build.py

@@ -0,0 +1,15 @@
+"""Entry point for scripts."""
+
+from build_helpers.release_downloader import GithubDownloader
+from build_helpers.release_extractor import ReleaseExtractor
+
+
+def main():
+    GithubDownloader()
+    # gh.download_release_assets("mscl_release_assets")
+    re = ReleaseExtractor()
+    re.extract_assets()
+
+
+if __name__ == "__main__":
+    main()