python-mscl 67.0.0__tar.gz → 67.1.0.1__tar.gz

{python_mscl-67.0.0 → python_mscl-67.1.0.1}/.github/workflows/build_wheels.yml

@@ -1,4 +1,4 @@
-name: Build wheels
+name: Download, extract, build, and test wheels
 
 on:
   pull_request:
@@ -10,19 +10,14 @@ on:
 
 jobs:
   build-wheels:
-    name: Build wheels
+    name: Download, extract, build, and wheels
     runs-on: ${{ matrix.os }}
     timeout-minutes: 5
     strategy:
       fail-fast: false
       matrix:
-        os: [ubuntu-latest, windows-latest]
-        python-version: [3.9, 3.11, 3.13]
-        exclude:
-          - os: windows-latest
-            python-version: 3.9
-          - os: windows-latest
-            python-version: 3.13
+        os: [ubuntu-latest, windows-latest, ubuntu-24.04-arm]
+        python-version: [3.13]
 
     steps:
       - uses: actions/checkout@v4
@@ -39,15 +34,21 @@ jobs:
 
       - name: Install the project
         run: uv sync
+      
+      - name: Download and extract the mscl assets
+        run: |
+          uv run download_and_extract_assets.py
 
-      - name: Build the wheel
-        run: uv build --wheel
+      - name: Build the wheels
+        run: |
+          uv run run_build.py
 
-      - name: Initialize test environment
+      # There should be only one wheel so it should work:
+      - name: Initialize test environment and install wheel
         run: |
           uv init --no-workspace test
           cd test
-          uv add ../dist/*.whl
+          uv add "$(python -c 'import glob; print(glob.glob("../dist/*.whl")[0])')"
 
       - name: Verify installation
         run: uv run -- python -c "from python_mscl import mscl"

{python_mscl-67.0.0 → python_mscl-67.1.0.1}/.gitignore

@@ -15,10 +15,12 @@ wheels/
 # Exclude local .deb and .zip files from mscl:
 mscl_release_assets/*.zip
 mscl_release_assets/*.deb
+mscl_release_assets/
 
 # VSCode:
 .vscode/
 
 # Exclude build downloaded mscl files:
-src/mscl/mscl.py
-src/mscl/_mscl.so
+src/python_mscl/mscl.py
+src/python_mscl/_mscl.so
+src/python_mscl/_mscl.pyd

python_mscl-67.1.0.1/.python-version

@@ -0,0 +1 @@
+3.14+gil

{python_mscl-67.0.0 → python_mscl-67.1.0.1}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.5
 Name: python-mscl
-Version: 67.0.0
+Version: 67.1.0.1
 Summary: Easy to install python wrapper for the MSCL library.
 Author-email: Harshil <37377066+harshil21@users.noreply.github.com>
 License-File: LICENSE
@@ -8,23 +8,25 @@ Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.9
-Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
 Classifier: Topic :: Scientific/Engineering
-Requires-Python: >=3.9
+Requires-Python: >=3.11
 Description-Content-Type: text/markdown
 
 # python-mscl
 
+# ARCHIVED: There is now an official mscl library: [`pymscl`](https://pypi.org/project/pymscl). Please use that library instead.
+
+[![PyPI Downloads](https://static.pepy.tech/badge/python-mscl/week)](https://pepy.tech/projects/python-mscl)
+
 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.
+This library just makes it so that we can install the MSCL library using pip, and directly provides the wheels!
 
-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.
+Only Python 3.x wheels are provided. If you need Python 2.x wheels, please open an issue.
 
 ### Installation
 
@@ -40,11 +42,6 @@ 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 has been confirmed that it does not work on other python versions (You would get an import error). However the build itself would still go through.
-
-
 ### Versioning system:
 
 This repository follows the same versioning system as the MSCL library. This is reflected in the tags of this repository.
@@ -63,13 +60,18 @@ 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.
+3. Edit & run `uv run download_and_extract_assets.py` to fetch the latest tagged MSCL releases and extract them.
+4. Run `uv run run_build.py`, which will build the source distribution and wheel for your python
+version and architecture. The wheels will be placed in the `dist/` directory.
 
 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.
+
+5. Make sure that the constants in `constants.py` are updated, and that the MSCL repo still follows their
+versioning system. If not, update rest of the files accordingly.
+
+6. 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/*.whl`.
+
+7. 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:

{python_mscl-67.0.0 → python_mscl-67.1.0.1}/README.md

@@ -1,11 +1,14 @@
 # python-mscl
 
+# ARCHIVED: There is now an official mscl library: [`pymscl`](https://pypi.org/project/pymscl). Please use that library instead.
+
+[![PyPI Downloads](https://static.pepy.tech/badge/python-mscl/week)](https://pepy.tech/projects/python-mscl)
+
 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.
+This library just makes it so that we can install the MSCL library using pip, and directly provides the wheels!
 
-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.
+Only Python 3.x wheels are provided. If you need Python 2.x wheels, please open an issue.
 
 ### Installation
 
@@ -21,11 +24,6 @@ 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 has been confirmed that it does not work on other python versions (You would get an import error). However the build itself would still go through.
-
-
 ### Versioning system:
 
 This repository follows the same versioning system as the MSCL library. This is reflected in the tags of this repository.
@@ -44,13 +42,18 @@ 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.
+3. Edit & run `uv run download_and_extract_assets.py` to fetch the latest tagged MSCL releases and extract them.
+4. Run `uv run run_build.py`, which will build the source distribution and wheel for your python
+version and architecture. The wheels will be placed in the `dist/` directory.
 
 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.
+
+5. Make sure that the constants in `constants.py` are updated, and that the MSCL repo still follows their
+versioning system. If not, update rest of the files accordingly.
+
+6. 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/*.whl`.
+
+7. 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:

{python_mscl-67.0.0 → python_mscl-67.1.0.1}/build_helpers/release_downloader.py

@@ -8,6 +8,8 @@ from github import Github
 from github.GitRelease import GitRelease
 from github.GitReleaseAsset import GitReleaseAsset
 
+from constants import ASSET_DIRECTORY, ReleaseAsset
+
 
 class GithubDownloader:
     """Manages downloading the Github release assets for the mscl library, along with the
@@ -18,6 +20,7 @@ class GithubDownloader:
         self.mscl_repo = "LORD-MicroStrain/MSCL"
         self.python_mscl_repo = "harshil21/python-mscl"
         self.latest_release = None
+        self.asset_dir = Path(ASSET_DIRECTORY)
 
     def get_latest_release(self) -> GitRelease:
         """Returns the latest stable release for the given repo."""
@@ -33,13 +36,19 @@ class GithubDownloader:
                 break
         return self.latest_release
 
-    def download_release_assets(self, output_dir: str):
-        """Downloads the release assets for the given repo and tag."""
+    def download_release_assets(self, only_release: ReleaseAsset | None = None) -> None:
+        """Downloads the release assets from the MSCL repository.
+
+        Args:
+            only_release: If set, only download the release asset for the given Python version and
+                architecture. If not set, download all the release assets.
+        """
         release = self.get_latest_release()
-        output_path = Path(output_dir)
+        output_path = Path(self.asset_dir)
         output_path.mkdir(parents=True, exist_ok=True)
 
         asset: GitReleaseAsset
+        print(f"Downloading release assets for {only_release=}")
         for asset in release.get_assets():
             # Don't download the "Documentation" or "Examples"
             if "Documentation" in asset.name or "Examples" in asset.name:
@@ -51,22 +60,17 @@ class GithubDownloader:
             if "3" not in asset.name:
                 continue
 
+            # Extract the python version, arch, and platform from the only_release, if set:
+            if only_release:
+                if only_release.python_version not in asset.name:
+                    continue
+                if only_release.arch not in asset.name:
+                    continue
+
             self.download_asset(output_path, asset)
+            print(f"Downloaded {asset.name}")
 
     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)

{python_mscl-67.0.0 → python_mscl-67.1.0.1}/build_helpers/release_extractor.py

@@ -1,17 +1,19 @@
 """Extracts the .deb and .zip releases for the mscl library."""
 
 import os
+import shutil
 import subprocess
 from pathlib import Path
+from zipfile import ZipFile
+
+from constants import ASSET_DIRECTORY, MSCL_VERSION
 
-MSCL_VERSION = "v67.0.0"
-"""The mscl version to extract."""
 
 class ReleaseExtractor:
     """Will extract the .deb and .zip releases for the mscl library."""
 
     def __init__(self):
-        self.asset_dir = Path("mscl_release_assets")
+        self.asset_dir = Path(ASSET_DIRECTORY)
 
     def extract_assets(self):
         """Extracts the .deb and .zip releases into the same directory."""
@@ -77,18 +79,19 @@ class ReleaseExtractor:
         # 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_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}")
+            shutil.rmtree(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
+        with ZipFile(file, "r") as zip_ref:
+            zip_ref.extractall(mscl_versioned_dir)
+            print("Extracted the zip file.")
 
         found_mscl_py = list(mscl_versioned_dir.rglob("mscl.py"))
         found_mscl_pyd = list(mscl_versioned_dir.rglob("_mscl.pyd"))
@@ -106,8 +109,18 @@ class ReleaseExtractor:
         # 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):
+                print(f"Skipping deletion of {f}")
                 continue
             if f.is_dir():
-                os.system(f"rm -rf {f}")
+                print(f"Deleting the directory {f}")
+                shutil.rmtree(f)
             else:
+                print(f"Deleting {f}")
                 f.unlink()
+
+        # Confirm that the files still exist after deleting the rest:
+        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"Deleted mscl.py or _mscl.pyd in {mscl_versioned_dir}!")

python_mscl-67.1.0.1/constants.py

@@ -0,0 +1,38 @@
+"""File to store common constants used in the project."""
+
+from pathlib import Path
+from typing import NamedTuple
+
+
+# Named tuple to store the release asset information:
+class ReleaseAsset(NamedTuple):
+    """Named tuple to store the release asset information.
+
+    Args:
+        python_version: The Python version of the release asset. E.g. "Python3.9".
+        arch: The architecture of the release asset. E.g. "amd64".
+    """
+
+    python_version: str
+    arch: str
+
+
+ASSET_DIRECTORY = Path("mscl_release_assets")
+"""The directory to store the downloaded release assets."""
+
+
+# Keep this the same as the one in `hatch_build.py`!
+MSCL_VERSION = "v67.1.0"
+"""The mscl version to extract from the `ASSET_DIRECTORY`. The
+downloader will download the latest version despite this version number."""
+
+
+MACHINE_MAPPING_TO_ARCH = {
+    # Linux:
+    "x86_64": "amd64",
+    "aarch64": "arm64",
+    "armv7l": "armhf",
+    # Windows:
+    "AMD64": "Windows_x64",
+    "x86": "Windows_x86",
+}

python_mscl-67.1.0.1/download_and_extract_assets.py

@@ -0,0 +1,41 @@
+"""Entry point for downloading and extracting mscl release assets."""
+
+import os
+import platform
+import sys
+
+from build_helpers.release_downloader import GithubDownloader, ReleaseAsset
+from build_helpers.release_extractor import ReleaseExtractor
+from constants import MACHINE_MAPPING_TO_ARCH
+
+
+def main(github_actions: bool = False) -> None:
+    """Entry point to fetch the latest release assets from the Github repository & extract them.
+
+    :param github_actions: If the script is running in a Github Actions environment. If true,
+        the script will download and extract the release asset of only the python version and
+        architecture and OS type detected.
+    """
+    gh = GithubDownloader()
+    if github_actions:
+        print(f"Downloading on {sys.version_info=}, {platform.machine()=}")
+        gh.download_release_assets(
+            ReleaseAsset(
+                python_version=f"Python{sys.version_info.major}.{sys.version_info.minor}",
+                arch=MACHINE_MAPPING_TO_ARCH.get(platform.machine()),
+            )
+        )
+    else:
+        gh.download_release_assets()
+
+    re = ReleaseExtractor()
+    re.extract_assets()
+
+
+if __name__ == "__main__":
+    if os.getenv("GITHUB_ACTIONS", "false") == "true":
+        print("Running in Github Actions environment.")
+        main(github_actions=True)
+    else:
+        print("Running locally")
+        main()

python_mscl-67.1.0.1/hatch_build.py

@@ -0,0 +1,112 @@
+"""Specifies a hatch build hook to create the wheel for mscl."""
+
+import os
+import shutil
+from pathlib import Path
+from typing import ClassVar
+
+from hatchling.builders.hooks.plugin.interface import BuildHookInterface
+
+# This is specified here instead of in the constants since we get import errors:
+MSCL_VERSION = "v67.1.0"
+"""The mscl version to build the wheels from."""
+
+BUILD_ARCH = os.getenv("BUILD_ARCH", "false")
+"""The build architecture to use for the wheels. This determines the tag for the wheel.
+
+This will be the arch in folder name (e.g., amd64, arm64, armhf, Windows-x64, Windows-x86).
+"""
+
+PYTHON_BUILD_VERSION = os.getenv("PYTHON_BUILD_VERSION", "false")
+"""The Python build version to use for the wheels. This determines the tag for the wheel.
+
+This will be the python version in folder name (e.g., Python3.9, Python3.11, etc).
+"""
+
+
+class CustomBuildHook(BuildHookInterface):
+    """Build hook to build wheels from the extracted .deb/.zip files."""
+
+    PYTHON_VER_MAPPING: ClassVar[dict[str, str]] = {
+        "Python3.9": "cp39",
+        "Python3.10": "cp310",
+        "Python3.11": "cp311",
+        "Python3.12": "cp312",
+        "Python3.13": "cp313",
+    }
+    """The mapping of Python versions of the folder to the Python tags for the wheel."""
+
+    PYTHON_BUILD_MAPPING: ClassVar[dict[str, str]] = {
+        "amd64": "manylinux2014_x86_64",
+        "arm64": "manylinux2014_aarch64",
+        "armhf": "manylinux2014_armv7l",
+        "Windows_x64": "win_amd64",
+        "Windows_x86": "win32",
+    }
+    """The mapping of architectures (in the folder name) to the platform tags for the wheel."""
+
+    def _python_tag(self) -> str | None:
+        """Generate the Python tag (e.g., py39 for Python 3.9)."""
+        try:
+            return self.PYTHON_VER_MAPPING.get(PYTHON_BUILD_VERSION)
+        except KeyError as e:
+            raise RuntimeError(f"Unknown Python version: {PYTHON_BUILD_VERSION}") from e
+
+    def _platform_tag(self) -> str | None:
+        """Generate the platform tag (e.g., linux_x86_64)."""
+        try:
+            return self.PYTHON_BUILD_MAPPING.get(BUILD_ARCH)
+        except KeyError as e:
+            raise RuntimeError(f"Unknown platform: {BUILD_ARCH}") from e
+
+    def _make_tag(self) -> str:
+        """Generate the tag for the wheel (e.g., py39-linux_x86_64)."""
+        return f"{self._python_tag()}-{self._python_tag()}-{self._platform_tag()}"
+
+    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/.
+        """
+        # Don't run build hook when a user is installing the wheel:
+        if PYTHON_BUILD_VERSION == "false" and BUILD_ARCH == "false":
+            return
+
+        build_data["pure_python"] = False
+        self.app.display_info(
+            f"Running on {version=} on {build_data=}, with "
+            f"{PYTHON_BUILD_VERSION=} and {BUILD_ARCH=}"
+        )
+
+        # --- STEP 1: Determine which python version and arch we are on: ---
+        # Build the folder name based on the python version and arch in the environment variables.
+
+        folder_name = f"mscl-{BUILD_ARCH}-{PYTHON_BUILD_VERSION}-{MSCL_VERSION}"
+
+        build_data["tag"] = self._make_tag()
+
+        # --- STEP 3: Copy the files ("_mscl.so" & "mscl.py") to the src/mscl/ directory: ---
+        # Move from root (i.e. cwd) to src/mscl
+
+        self.remove_existing_files(Path("src/python_mscl/"), ["_mscl.so", "_mscl.pyd", "mscl.py"])
+
+        # Copy files from mscl_release_assets/folder_name to src/mscl/:
+        p = (Path("mscl_release_assets") / folder_name).absolute()
+
+        shutil.copy(p / "mscl.py", "src/python_mscl/")
+        if BUILD_ARCH.startswith("Windows"):  # Windows uses _mscl.pyd
+            shutil.copy(p / "_mscl.pyd", "src/python_mscl/")
+            build_data["artifacts"] = ["_mscl.pyd", "mscl.py"]
+        else:
+            shutil.copy(p / "_mscl.so", "src/python_mscl/")
+            build_data["artifacts"] = ["_mscl.so", "mscl.py"]
+
+        self.app.display_success("Moved files to src/python_mscl/ successfully. Building wheel...")
+
+    def remove_existing_files(self, directory: Path, files: list[str]) -> None:
+        """Remove the existing files from the directory."""
+        for file in files:
+            file_path = directory / file
+            if file_path.exists():
+                file_path.unlink()

{python_mscl-67.0.0 → python_mscl-67.1.0.1}/pyproject.toml

@@ -1,42 +1,45 @@
 [project]
 name = "python-mscl"
-version = "67.0.0"
+version = "67.1.0.1"
 description = "Easy to install python wrapper for the MSCL library."
 readme = "README.md"
 authors = [
     { name = "Harshil", email = "37377066+harshil21@users.noreply.github.com" }
 ]
-requires-python = ">=3.9"
+requires-python = ">=3.11"
 classifiers = [
     "Development Status :: 4 - Beta",
     "Intended Audience :: Developers",
     "License :: OSI Approved :: MIT License",
     "Programming Language :: Python :: 3",
-    "Programming Language :: Python :: 3.9",
-    "Programming Language :: Python :: 3.10",
     "Programming Language :: Python :: 3.11",
     "Programming Language :: Python :: 3.12",
     "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3.14",
     "Topic :: Scientific/Engineering",
     "Intended Audience :: Developers",
 ]
 dependencies = []
 
 [dependency-groups]
-dev = ["ruff", "hatchling"]
+dev = [
+    "ruff",
+    "hatchling",
+    "pygithub>=2.5.0",
+]
 
-[tool.hatch.build.targets.wheel]
-packages = ["src/python_mscl"]
+# [tool.hatch.build.targets.wheel]
+# packages = ["src/python_mscl"]
 
-[tool.hatch.build.hooks.custom]
-path = "hatch_build.py"
+# [tool.hatch.build.hooks.custom]
+# path = "hatch_build.py"
 
 [tool.hatch.build.targets.sdist]
 exclude = ["mscl_release_assets/", "uv.lock", "main.py", "src/python_mscl/_mscl.so", 
-"src/python_mscl/mscl.py"]
+"src/python_mscl/mscl.py", "src/python_mscl/mscl.pyd"]
 
 [build-system]
-requires = ["hatchling", "requests", "pygithub"]
+requires = ["hatchling"]
 build-backend = "hatchling.build"
 
 # [[tool.uv.index]]
@@ -48,13 +51,13 @@ build-backend = "hatchling.build"
 # RUFF:
 [tool.ruff]
 line-length = 100
-target-version = "py39"
+target-version = "py311"
 show-fixes = true
 exclude = ["mscl_release_assets/"]
 
 [tool.ruff.lint]
-ignore = ["ISC001", "S603", "S605", "S607", "PLR0912"]
+ignore = ["ISC001", "S603", "S605", "S607", "PLR0912", "T201"]
 select = ["E", "F", "I", "PL", "UP", "RUF", "PTH", "C4", "B", "PIE", "SIM", "RET", "RSE",
           "G", "ISC", "PT", "ASYNC", "TCH", "SLOT", "PERF", "PYI", "FLY", "AIR", "Q", "INP", 
           "W", "YTT", "DTZ", "ARG", "T20", "FURB", "D100", "D101", "D300", "D418",
-          "D419", "S", "NPY"]
+          "D419", "S", "NPY"]

python_mscl-67.1.0.1/run_build.py

@@ -0,0 +1,57 @@
+"""Script to run the hatch build for a given python version and architecture."""
+
+import itertools
+import os
+import platform
+import subprocess
+import sys
+
+from constants import MACHINE_MAPPING_TO_ARCH
+
+
+def run_hatch_build(python_version: str, build_arch: str) -> None:
+    """Run the hatch build for the given Python version and architecture."""
+
+    # modify_pyproject_toml(python_version, build_arch)
+    env = os.environ.copy()
+    env["PYTHON_BUILD_VERSION"] = python_version
+    env["BUILD_ARCH"] = build_arch
+
+    # Run the hatch build with the environment variables set:
+    subprocess.run(["uv", "build", "--wheel"], check=True, env=env)
+
+
+def main(github_actions: bool = False) -> None:
+    """Entry point to run the hatch build for the given Python version and architecture.
+
+    Make sure to have first downloaded and extracted the release assets from the Github repository.
+    i.e. run `uv run download_and_extract_assets.py` before running this script.
+
+    Args:
+        github_actions: If the script is running in a Github Actions environment. If true, the
+            script will run the hatch build for only the Python version and architecture detected.
+    """
+
+    # Iterate through the Python versions and architectures:
+    # See the file names in the extracted folder for the exact names:
+    # This must be the same as the dictionary in the hatch_build.py file
+    python_versions = ["Python3.9", "Python3.10", "Python3.11", "Python3.12", "Python3.13"]
+    build_architectures = ["amd64", "arm64", "armhf", "Windows_x64", "Windows_x86"]
+
+    if github_actions:
+        detected_python_version = f"Python{sys.version_info.major}.{sys.version_info.minor}"
+        detected_arch = MACHINE_MAPPING_TO_ARCH.get(platform.machine())
+        run_hatch_build(detected_python_version, detected_arch)
+
+    else:
+        for python_version, build_arch in itertools.product(python_versions, build_architectures):
+            run_hatch_build(python_version, build_arch)
+
+
+if __name__ == "__main__":
+    if os.getenv("GITHUB_ACTIONS", "false") == "true":
+        print("Building in Github Actions environment.")
+        main(github_actions=True)
+    else:
+        print("Building locally")
+        main()

python_mscl-67.1.0.1/src/python_mscl/__init__.py

@@ -0,0 +1,13 @@
+from warnings import warn
+
+# from . import mscl
+
+warn(
+    "The 'python_mscl' package is archived, please use the official `pymscl` package instead.",
+    DeprecationWarning,
+    stacklevel=2
+)
+
+# Intentionally make the user can do `from python_mscl import mscl` instead of `import mscl` which
+# can be done by doing a from .mscl import * here.
+# __all__ = ["mscl"]

python_mscl-67.0.0/.python-version

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

python_mscl-67.0.0/hatch_build.py

@@ -1,116 +0,0 @@
-"""Specifies a hatch build hook to create the wheel for mscl."""
-
-import platform
-import shutil
-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
-
-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."""
-
-    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/.
-        """
-        if self.target_name != "wheel":
-            return
-
-        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":
-            mscl_arch = "amd64"
-        elif arch == "aarch64":
-            mscl_arch = "arm64"
-        elif arch == "armv7l":
-            mscl_arch = "armhf"
-        elif arch == "AMD64":  # Windows
-            mscl_arch = "x64"
-        elif arch == "x86":  # Windows
-            mscl_arch = "x86"
-        else:
-            raise RuntimeError(f"Unknown architecture: {arch}")
-
-        # --- STEP 2: Download the 2 mscl files (mscl.py and _mscl.so) from the git repo: ---
-        # 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:
-
-        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_VERSION,
-            folder_name=f"mscl_release_assets/{folder_name}",
-        )
-
-        self.app.display_success("Downloaded files successfully.")
-
-        # --- STEP 3: Copy the files ("_mscl.so" & "mscl.py") to the src/mscl/ directory: ---
-        # Move from root (i.e. cwd) to src/mscl
-        # Use shutil.move() to move the files.
-
-        self.remove_existing_files(Path("src/python_mscl/"), ["_mscl.so", "_mscl.pyd", "mscl.py"])
-        shutil.move("mscl.py", "src/python_mscl/")
-        if platform.system() == "Windows":
-            shutil.move("_mscl.pyd", "src/python_mscl/")
-            build_data["artifacts"] = ["_mscl.pyd", "mscl.py"]
-        else:
-            shutil.move("_mscl.so", "src/python_mscl/")
-            build_data["artifacts"] = ["_mscl.so", "mscl.py"]
-
-        self.app.display_success("Moved files to src/python_mscl/ successfully. Building wheel...")
-
-    def remove_existing_files(self, directory: Path, files: list[str]) -> None:
-        """Remove the existing files from the directory."""
-        for file in files:
-            file_path = directory / file
-            if file_path.exists():
-                file_path.unlink()

python_mscl-67.0.0/src/python_mscl/__init__.py

@@ -1,5 +0,0 @@
-from . import mscl
-
-# Intentionally make the user can do `from python_mscl import mscl` instead of `import mscl` which
-# can be done by doing a from .mscl import * here.
-__all__ = ["mscl"]