Preliminary Windows support

Also add more readme instructions

Author: harshil21

README.md

@@ -1,6 +1,6 @@
 # python-mscl
 
-Unofficial Python bindings for the [Microstrain Communication Library](https://www.microstrain.com/developers/microstrain-communication-library).
+Unofficial Python package for the [Microstrain Communication Library](https://github.com/LORD-MicroStrain/MSCL/tree/master).
 
 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.
@@ -18,11 +18,49 @@ pip install python-mscl
 ### Usage
 
 ```python
-import mscl
+from python_mscl import mscl
 
 # ... use the MSCL library as you normally would
 ```
 
+### Windows support:
+
+The latest mscl version (v67.0.0) only has a .zip for python 3.11. It is not confirmed if this will work with other python versions.
+
+
+### Versioning system:
+
+This repository follows the same versioning system as the MSCL library. This is reflected in the tags of this repository.
+
+The version reflected in PyPI is as follows:
+
+```
+<MSCL_VERSION>.<REPO_VERSION>
+```
+
+E.g, there could be a version: `67.0.0.3` which would mean that the MSCL version is `67.0.0` and this is the third release of the python-mscl package.
+
 ## Local Development:
 
-TODO
+The below steps assume you have [`uv`](https://docs.astral.sh/uv/) installed.
+
+1. Clone the repo and `cd` into it.
+2. Optional: Create a .env file and insert your GITHUB_TOKEN= to make requests to the GitHub API.
+3. Edit & run `uv run main.py` to fetch the latest tagged MSCL releases and extract them.
+4. Run `uv build`, which will build the source distribution and wheel for your python
+version and architecture.
+
+Notes for me, the maintainer:
+5. Optional: Run `uv publish` to publish the package to PyPI. To upload to TestPyPI, uncomment lines in `pyproject.toml`, and run `uv publish --index testpypi dist/*.tar.gz`.
+6. Optional: To check if the package worked correctly: `uv add --index https://test.pypi.org/simple/ --index-strategy unsafe-best-match python-mscl` in a new uv project directory.
+
+
+## Issues:
+
+If you encounter any issues, please open an issue on this repository. I would have to 
+manually update this repository to the latest MSCL release. If it has been more than 48 hours since the latest release and I didn't update this repository, please open an issue. 
+
+## License
+
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
+

build_helpers/release_extractor.py

@@ -4,6 +4,8 @@
 import subprocess
 from pathlib import Path
 
+MSCL_VERSION = "v67.0.0"
+"""The mscl version to extract."""
 
 class ReleaseExtractor:
     """Will extract the .deb and .zip releases for the mscl library."""
@@ -26,24 +28,24 @@ def extract_deb(self, file: Path):
 
         # 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}"
+        arch, py_ver = parts[1], parts[2]
+        mscl_versioned_name = f"mscl-{arch}-{py_ver}-{MSCL_VERSION}"
         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
+            os.system(f"rm -rf {mscl_versioned_dir}")
 
         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
+        subprocess.run(["ar", "x", str(file_relative)], cwd=mscl_versioned_dir, check=True)
 
         # 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
+        subprocess.run(["tar", "-xzf", data_tar], cwd=mscl_versioned_dir, check=True)
 
         found_mscl_py = list(mscl_versioned_dir.rglob("mscl.py"))
         found_mscl_so = list(mscl_versioned_dir.rglob("_mscl.so"))
@@ -63,9 +65,49 @@ def extract_deb(self, file: Path):
             if f.stem in (mscl_py.stem, mscl_so.stem):
                 continue
             if f.is_dir():
-                os.system(f"rm -rf {f}")  # noqa: S605
+                os.system(f"rm -rf {f}")
             else:
                 f.unlink()
 
     def extract_zip(self, file: Path) -> None:
         """Extracts the .zip release."""
+
+        cwd = Path().cwd()
+
+        # Create a directory to extract the .zip file. Syntax: mscl-<arch>-<python-ver>-<mscl-ver>
+        parts = file.stem.split("_")
+        arch, py_ver = parts[2], parts[3]
+        mscl_versioned_name = f"mscl-Windows-{arch}-{py_ver}-{MSCL_VERSION}"
+        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}")
+
+        mscl_versioned_dir.mkdir(parents=True, exist_ok=True)
+        file_relative = file.absolute().relative_to(mscl_versioned_dir, walk_up=True)
+
+        # Extract the .zip file
+        subprocess.run(["unzip", str(file_relative)], cwd=mscl_versioned_dir, check=True)  # noqa: S603, S607
+
+        found_mscl_py = list(mscl_versioned_dir.rglob("mscl.py"))
+        found_mscl_pyd = list(mscl_versioned_dir.rglob("_mscl.pyd"))
+
+        if not found_mscl_py or not found_mscl_pyd:
+            raise FileNotFoundError(f"Could not find mscl.py or _mscl.pyd in {mscl_versioned_dir}")
+
+        # Move the extracted files to the root of the mscl_versioned_dir:
+        mscl_py = found_mscl_py[0]
+        mscl_pyd = found_mscl_pyd[0]
+
+        mscl_py.rename(mscl_versioned_dir / mscl_py.name)
+        mscl_pyd.rename(mscl_versioned_dir / mscl_pyd.name)
+
+        # Delete the remaining files in mscl_versioned_dir:
+        for f in mscl_versioned_dir.iterdir():
+            if f.stem in (mscl_py.stem, mscl_pyd.stem):
+                continue
+            if f.is_dir():
+                os.system(f"rm -rf {f}")
+            else:
+                f.unlink()

hatch_build.py

@@ -11,6 +11,9 @@
 
 from build_helpers.release_downloader import GithubDownloader
 
+MSCL_VERSION = "v67.0.0"
+"""The mscl version to build the wheels of."""
+
 
 class CustomBuildHook(BuildHookInterface):
     """Build hook to build wheels from the extracted .deb/.zip files."""
@@ -49,42 +52,53 @@ def initialize(self, version, build_data):
 
         arch = platform.machine()
         if arch == "x86_64":
-            arch = "amd64"
+            mscl_arch = "amd64"
         elif arch == "aarch64":
-            arch = "arm64"
+            mscl_arch = "arm64"
         elif arch == "armv7l":
-            arch = "armhf"
+            mscl_arch = "armhf"
+        elif arch == "AMD64":  # Windows
+            mscl_arch = "x64"
+        elif arch == "x86":  # Windows
+            mscl_arch = "x86"
         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>
+        # Folder name: mscl-<mscl_arch>-<python-ver>-<mscl-ver>  -> Linux
+        # Folder name: mscl-Windows-<mscl_arch>-<python-ver>-<mscl-ver>  -> Windows
 
         # a) Create the folder name:
-        folder_name = f"mscl-{arch}-{py_version}-{mscl_ver}"
+
+        if platform.system() == "Linux":
+            build_data["tag"] = f"{self._python_tag()}-{self._python_tag()}-{self._platform_tag()}"
+            folder_name = f"mscl-{mscl_arch}-{py_version}-{MSCL_VERSION}"
+
+        # Windows is best effort matching since there's only python 3.11 available for v67.0.0:
+        else:
+            if mscl_arch == "x64":
+                build_data["tag"] = "py3-none-win_amd64"
+            elif mscl_arch == "x86":
+                build_data["tag"] = "py3-none-win32"
+            folder_name = f"mscl-Windows-{mscl_arch}-Python3.11-{MSCL_VERSION}"
 
         # b) Use PyGithub to download the files from the folder:
         self.app.display_waiting(f"Downloading files for {folder_name}...")
 
         gh = GithubDownloader()
         gh.download_assets_from_folder(
-            tag=mscl_ver,
+            tag=MSCL_VERSION,
             folder_name=f"mscl_release_assets/{folder_name}",
         )
 
         self.app.display_success("Downloaded files successfully.")
         build_data["artifacts"] = ["_mscl.so", "mscl.py"]
 
-        # Show all files in the current directory:
-        # self.app.display_info(f"Files in {Path().cwd()}: {list(Path().cwd().iterdir())}")
-
         # --- STEP 3: Copy the files ("_mscl.so" & "mscl.py") to the src/mscl/ directory: ---
         # Move from root (i.e. cwd) to src/mscl
-        subprocess.run(["mv", "mscl.py", "src/mscl/"], check=True)  # noqa: S603, S607
-        subprocess.run(["mv", "_mscl.so", "src/mscl/"], check=True)  # noqa: S603, S607
-        self.app.display_success("Moved files to src/mscl/ successfully. Building wheel...")
+        subprocess.run(["mv", "mscl.py", "src/python_mscl/"], check=True)
+        if platform.system() == "Windows":
+            subprocess.run(["mv", "_mscl.pyd", "src/python_mscl/"], check=True)
+        else:
+            subprocess.run(["mv", "_mscl.so", "src/python_mscl/"], check=True)
+        self.app.display_success("Moved files to src/python_mscl/ successfully. Building wheel...")

main.py

@@ -1,14 +1,15 @@
 """Entry point for scripts."""
 
-from build_helpers.release_downloader import GithubDownloader
-from build_helpers.release_extractor import ReleaseExtractor
+# from build_helpers.release_downloader import GithubDownloader
+# from build_helpers.release_extractor import ReleaseExtractor
 
 
 def main():
-    GithubDownloader()
+    """Entry point to fetch the latest release assets from the Github repository & extract them."""
+    # gh = GithubDownloader()
     # gh.download_release_assets("mscl_release_assets")
-    re = ReleaseExtractor()
-    re.extract_assets()
+    # re = ReleaseExtractor()
+    # re.extract_assets()
 
 
 if __name__ == "__main__":