Merge pull request #4 from ducdetronquito/task/clean

refactor: Make the main entrypoint easier to grok

.github/workflows/publish.yml

@@ -7,8 +7,8 @@ on:
         description: "Bun version"
         required: true
         type: string
-      wheel_pre_release:
-        description: "Wheel pre-release, ex: alpha1, alpha2, etc..."
+      pybun_version_suffix:
+        description: "Ex: alpha1, alpha2, post1, etc..."
         type: string
         default: ""
 
@@ -28,7 +28,7 @@ jobs:
         run: poetry install
 
       - name: Build the wheel
-        run: poetry run python src/make_wheels.py ${{ inputs.bun_version }} --wheel-pre-release=${{ inputs.wheel_pre_release }}
+        run: poetry run python src/make_wheels.py ${{ inputs.bun_version }} --pybun-version-suffix=${{ inputs.pybun_version_suffix }}
 
       - name: Publish on PyPI
         run: poetry run twine upload dist/*

src/make_wheels.py

@@ -69,7 +69,7 @@ def parse_bun_target_platform(value: str) -> BunTargetPlatform | None:
             return None
 
 
-def list_bun_target_platforms() -> list[BunTargetPlatform]:
+def all_bun_target_platforms() -> list[BunTargetPlatform]:
     return ["darwin-x64", "darwin-aarch64", "linux-aarch64", "linux-x64", "windows-x64"]
 
 
@@ -200,21 +200,21 @@ def from_archive(
 
 @dataclass(frozen=True, slots=True)
 class Wheel:
-    python_version: str
+    pybun_version: str
     bun_version: str
     python_target_platform: PythonTargetPlatform
     name = "pybun"
 
     def filename(self) -> str:
-        return f"{self.name}-{self.python_version}-{self.get_tag()}.whl"
+        return f"{self.name}-{self.pybun_version}-{self.get_tag()}.whl"
 
     def get_tag(self) -> str:
         return f"py3-none-{self.python_target_platform}"
 
     def write(self, bun_executable: BunExecutable, output_dir: str) -> str:
         Path(output_dir).mkdir(exist_ok=True)
 
-        dist_info = DistInfo(self.name, self.python_version)
+        dist_info = DistInfo(self.name, self.pybun_version)
         dist_info_metadata = DistInfoMetadata(dist_info, self.bun_version)
         dist_info_wheel = DistInfoWheel(dist_info, self.get_tag())
         dist_info_entrypoints = DistInfoEntrypoints(dist_info)
@@ -256,15 +256,15 @@ def get_cli_arg_parser() -> ArgumentParser:
     )
     parser.add_argument(
         "--platform",
-        choices=list_bun_target_platforms(),
+        choices=all_bun_target_platforms(),
         action="append",
         default=[],
         help="platform to build for, can be repeated to target multiple platform. If omitted all platform are targeted.",
     )
     parser.add_argument(
-        "--wheel-pre-release",
+        "--pybun-version-suffix",
         default="",
-        help="Wheel pre-release, ex: alpha1, alpha2, etc...",
+        help="Ex: alpha1, alpha2, post1, etc...",
     )
 
     return parser
@@ -326,58 +326,86 @@ def get_latest_bun_version() -> str:
     return latest_version
 
 
-def main():
-    logging.getLogger("wheel").setLevel(logging.WARNING)
+def get_pybun_version(bun_version: str, pybun_version_suffix: str) -> str:
+    pybun_version = bun_version.replace("v", "")
+    if pybun_version_suffix:
+        pybun_version = f"{pybun_version}.{pybun_version_suffix}"
 
-    cli_args = get_cli_arg_parser().parse_args()
+    return pybun_version
 
-    bun_version: str = cli_args.bun_version
 
-    if bun_version == "latest":
-        bun_version = get_latest_bun_version()
+def build_wheel(
+    bun_target_platform: BunTargetPlatform,
+    bun_version: str,
+    pybun_version: str,
+    expected_release_hash: str,
+) -> None:
+    release_archive = get_release_archive(bun_version, bun_target_platform)
+
+    release_hash = sha256(release_archive).hexdigest()
+    if release_hash != expected_release_hash:
+        logger.error(
+            f"Release {bun_version} hash mismatch for platform {bun_target_platform}: expected={expected_release_hash}, found={release_hash}"
+        )
+        return sys.exit(1)
 
-    wheel_pre_release: str = cli_args.wheel_pre_release
-    python_version = bun_version.replace("v", "")
-    if wheel_pre_release:
-        python_version = f"{python_version}.{wheel_pre_release}"
+    logger.info(
+        f"Release {bun_version} hash for platform {bun_target_platform} is {release_hash}"
+    )
 
-    disered_target_platforms = cli_args.platform or list_bun_target_platforms()
-    bun_target_platforms = []
-    for item in disered_target_platforms:
+    bun_executable = BunExecutable.from_archive(release_archive, bun_target_platform)
+
+    python_target_platform = get_maching_python_target_platform(bun_target_platform)
+    wheel_path = Wheel(pybun_version, bun_version, python_target_platform).write(
+        bun_executable, "dist/"
+    )
+
+    logger.info(f"Wheel has been generated: {wheel_path}")
+
+
+def parse_expected_target_platforms(platforms: list[str]) -> list[BunTargetPlatform]:
+    if not platforms:
+        return all_bun_target_platforms()
+
+    bun_target_platforms = list[BunTargetPlatform]()
+    for item in platforms:
         bun_target_platform = parse_bun_target_platform(item)
         if bun_target_platform is None:
             logger.error(f"Bun target platform '{item}' does not exists")
             return sys.exit(1)
 
         bun_target_platforms.append(bun_target_platform)
 
-    release_hashes = get_release_hashes(bun_version)
+    return bun_target_platforms
 
-    for bun_target_platform in bun_target_platforms:
-        release_archive = get_release_archive(bun_version, bun_target_platform)
 
-        release_hash = sha256(release_archive).hexdigest()
-        expected_release_hash = release_hashes[bun_target_platform]
-        if release_hash != expected_release_hash:
-            logger.error(
-                f"Release {bun_version} hash mismatch for platform {bun_target_platform}: expected={expected_release_hash}, found={release_hash}"
-            )
-            return sys.exit(1)
+def main():
+    logging.getLogger("wheel").setLevel(logging.WARNING)
 
-        logger.info(
-            f"Release {bun_version} hash for platform {bun_target_platform} is {release_hash}"
-        )
+    cli_args = get_cli_arg_parser().parse_args()
 
-        bun_executable = BunExecutable.from_archive(
-            release_archive, bun_target_platform
-        )
+    bun_version: str = cli_args.bun_version
 
-        python_target_platform = get_maching_python_target_platform(bun_target_platform)
-        wheel_path = Wheel(python_version, bun_version, python_target_platform).write(
-            bun_executable, "dist/"
-        )
+    if bun_version == "latest":
+        bun_version = get_latest_bun_version()
 
-        logger.info(f"Wheel has been generated: {wheel_path}")
+    pybun_version_suffix: str = cli_args.pybun_version_suffix
+
+    bun_target_platforms = parse_expected_target_platforms(cli_args.platform)
+
+    release_hashes = get_release_hashes(bun_version)
+
+    pybun_version = get_pybun_version(bun_version, pybun_version_suffix)
+
+    for bun_target_platform in bun_target_platforms:
+        expected_release_hash = release_hashes[bun_target_platform]
+
+        build_wheel(
+            bun_target_platform=bun_target_platform,
+            bun_version=bun_version,
+            pybun_version=pybun_version,
+            expected_release_hash=expected_release_hash,
+        )
 
 
 if __name__ == "__main__":