fix missing static files on git+ installs

Author: Archmonger

.github/workflows/publish.yml

@@ -14,7 +14,7 @@ jobs:
         uses: ./.github/workflows/.hatch-run.yml
         with:
             job-name: "Publish to PyPI"
-            run-cmd: "hatch run javascript:build && hatch build --clean && hatch publish --yes"
+            run-cmd: "hatch build --clean && hatch publish --yes"
         secrets:
             pypi-username: ${{ secrets.PYPI_USERNAME }}
             pypi-password: ${{ secrets.PYPI_PASSWORD }}

pyproject.toml

@@ -71,7 +71,7 @@ installer = "uv"
 reactpy = "reactpy._console.cli:entry_point"
 
 [[tool.hatch.build.hooks.build-scripts.scripts]]
-commands = ['python "src/build_scripts/build_local_wheel.py"']
+commands = ['python "src/build_scripts/build_py_wheel.py"']
 artifacts = ["src/reactpy/static/wheels/*.whl"]
 
 #############################

src/build_scripts/build_local_wheel.py src/build_scripts/build_py_wheel.pysrc/build_scripts/build_local_wheel.py renamed to src/build_scripts/build_py_wheel.py

@@ -15,7 +15,7 @@
 from pathlib import Path
 
 _logger = logging.getLogger(__name__)
-_SKIP_ENV_VAR = "REACTPY_SKIP_LOCAL_WHEEL_BUILD"
+_SKIP_ENV_VAR = "REACTPY_SKIP_PY_WHEEL_BUILD"
 
 
 def _reactpy_version(root_dir: Path) -> str:
@@ -38,29 +38,80 @@ def _matching_reactpy_wheel(dist_dir: Path, version: str) -> Path | None:
     return matching_wheels[0] if matching_wheels else None
 
 
-def _hatch_build_command(root_dir: Path) -> list[str] | None:
+def _hatch_command(root_dir: Path, *args: str) -> list[str] | None:
     for candidate in (
         root_dir / ".venv" / "Scripts" / "hatch.exe",
         root_dir / ".venv" / "bin" / "hatch",
     ):
         if candidate.exists():
-            return [str(candidate), "build", "-t", "wheel"]
+            return [str(candidate), *args]
 
     if hatch_command := shutil.which("hatch"):
-        return [hatch_command, "build", "-t", "wheel"]
+        return [hatch_command, *args]
 
     if importlib.util.find_spec("hatch") is not None:
-        return [sys.executable, "-m", "hatch", "build", "-t", "wheel"]
+        return [sys.executable, "-m", "hatch", *args]
 
     return None
 
 
+def _hatch_build_command(root_dir: Path) -> list[str] | None:
+    return _hatch_command(root_dir, "build", "-t", "wheel")
+
+
+def _without_hatch_env_vars(env: dict[str, str]) -> dict[str, str]:
+    cleaned_env = env.copy()
+    for key in tuple(cleaned_env):
+        if key.startswith("HATCH_ENV_"):
+            cleaned_env.pop(key)
+    return cleaned_env
+
+
+def _run_hatch_command(root_dir: Path, command: list[str], failure_message: str) -> int:
+    result = subprocess.run(  # noqa: S603
+        command,
+        capture_output=True,
+        text=True,
+        check=False,
+        cwd=root_dir,
+        env=_without_hatch_env_vars(os.environ.copy()),
+    )
+
+    if result.returncode != 0:
+        _logger.error(
+            "%s\nstdout:\n%s\nstderr:\n%s",
+            failure_message,
+            result.stdout,
+            result.stderr,
+        )
+        return result.returncode
+
+    return 0
+
+
+def _build_packaged_static_assets(root_dir: Path) -> int:
+    hatch_command = _hatch_command(root_dir, "run", "javascript:build")
+    if not hatch_command:
+        _logger.error("Could not locate Hatch while building packaged static assets.")
+        return 1
+
+    return _run_hatch_command(
+        root_dir,
+        hatch_command,
+        "Failed to build packaged static assets.",
+    )
+
+
 def main() -> int:
     if os.environ.get(_SKIP_ENV_VAR):
         print("Skipping local ReactPy wheel build.")  # noqa: T201
         return 0
 
     root_dir = Path(__file__).parent.parent.parent
+
+    if static_assets_result := _build_packaged_static_assets(root_dir):
+        return static_assets_result
+
     version = _reactpy_version(root_dir)
     static_wheels_dir = root_dir / "src" / "reactpy" / "static" / "wheels"
     dist_dir = root_dir / "dist"
@@ -74,28 +125,16 @@ def main() -> int:
     for wheel_file in static_wheels_dir.glob("reactpy-*.whl"):
         wheel_file.unlink()
 
-    env = os.environ.copy()
-    env[_SKIP_ENV_VAR] = "1"
-    for key in tuple(env):
-        if key.startswith("HATCH_ENV_"):
-            env.pop(key)
-
-    result = subprocess.run(  # noqa: S603
-        hatch_build_command,
-        capture_output=True,
-        text=True,
-        check=False,
-        cwd=root_dir,
-        env=env,
-    )
-
-    if result.returncode != 0:
-        _logger.error(
-            "Failed to build the embedded ReactPy wheel.\nstdout:\n%s\nstderr:\n%s",
-            result.stdout,
-            result.stderr,
-        )
-        return result.returncode
+    os.environ[_SKIP_ENV_VAR] = "1"
+    try:
+        if wheel_build_result := _run_hatch_command(
+            root_dir,
+            hatch_build_command,
+            "Failed to build the embedded ReactPy wheel.",
+        ):
+            return wheel_build_result
+    finally:
+        os.environ.pop(_SKIP_ENV_VAR, None)
 
     built_wheel = _matching_reactpy_wheel(dist_dir, version)
     if not built_wheel:

tests/test_build_local_wheel.py

@@ -0,0 +1,143 @@
+from __future__ import annotations
+
+import importlib.util
+import subprocess
+from pathlib import Path
+from unittest import mock
+
+
+def _load_build_py_wheel_module():
+    module_path = (
+        Path(__file__).resolve().parents[1]
+        / "src"
+        / "build_scripts"
+        / "build_py_wheel.py"
+    )
+    spec = importlib.util.spec_from_file_location("build_py_wheel", module_path)
+    assert spec is not None
+    assert spec.loader is not None
+
+    module = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(module)
+    return module
+
+
+def _write_text(path: Path, content: str) -> Path:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(content, encoding="utf-8")
+    return path
+
+
+def test_hatch_build_command_uses_python_module_when_available(tmp_path):
+    build_py_wheel = _load_build_py_wheel_module()
+
+    with (
+        mock.patch.object(build_py_wheel.shutil, "which", return_value=None),
+        mock.patch.object(
+            build_py_wheel.importlib.util,
+            "find_spec",
+            return_value=object(),
+        ),
+    ):
+        assert build_py_wheel._hatch_build_command(tmp_path) == [
+            build_py_wheel.sys.executable,
+            "-m",
+            "hatch",
+            "build",
+            "-t",
+            "wheel",
+        ]
+
+
+def test_build_packaged_static_assets_runs_javascript_build(tmp_path):
+    build_py_wheel = _load_build_py_wheel_module()
+
+    with (
+        mock.patch.object(build_py_wheel.shutil, "which", return_value=None),
+        mock.patch.object(
+            build_py_wheel.importlib.util,
+            "find_spec",
+            return_value=object(),
+        ),
+        mock.patch.object(build_py_wheel.subprocess, "run") as run,
+    ):
+        run.return_value = subprocess.CompletedProcess([], 0, "built", "")
+
+        assert build_py_wheel._build_packaged_static_assets(tmp_path) == 0
+
+    run.assert_called_once()
+    assert run.call_args.args[0] == [
+        build_py_wheel.sys.executable,
+        "-m",
+        "hatch",
+        "run",
+        "javascript:build",
+    ]
+
+
+def test_main_skips_all_work_when_skip_env_var_is_set(tmp_path):
+    build_py_wheel = _load_build_py_wheel_module()
+    build_script = _write_text(
+        tmp_path / "src" / "build_scripts" / "build_py_wheel.py",
+        "",
+    )
+
+    with (
+        mock.patch.object(build_py_wheel, "__file__", str(build_script)),
+        mock.patch.object(
+            build_py_wheel, "_build_packaged_static_assets"
+        ) as build_static_assets,
+        mock.patch.dict(
+            build_py_wheel.os.environ,
+            {build_py_wheel._SKIP_ENV_VAR: "1"},
+            clear=False,
+        ),
+    ):
+        assert build_py_wheel.main() == 0
+
+    build_static_assets.assert_not_called()
+
+
+def test_main_builds_static_assets_before_embedded_wheel(tmp_path):
+    build_py_wheel = _load_build_py_wheel_module()
+    build_script = _write_text(
+        tmp_path / "src" / "build_scripts" / "build_py_wheel.py",
+        "",
+    )
+    built_wheel = _write_text(
+        tmp_path / "dist" / "reactpy-2.0.0b11-py3-none-any.whl",
+        "wheel",
+    )
+    steps: list[str] = []
+
+    with (
+        mock.patch.object(build_py_wheel, "__file__", str(build_script)),
+        mock.patch.object(
+            build_py_wheel,
+            "_build_packaged_static_assets",
+            side_effect=lambda root_dir: steps.append("javascript") or 0,
+        ),
+        mock.patch.object(
+            build_py_wheel,
+            "_reactpy_version",
+            return_value="2.0.0b11",
+        ),
+        mock.patch.object(
+            build_py_wheel,
+            "_hatch_build_command",
+            return_value=["hatch", "build", "-t", "wheel"],
+        ),
+        mock.patch.object(
+            build_py_wheel,
+            "_run_hatch_command",
+            side_effect=lambda root_dir, command, message: steps.append("wheel") or 0,
+        ),
+        mock.patch.object(
+            build_py_wheel,
+            "_matching_reactpy_wheel",
+            return_value=built_wheel,
+        ),
+    ):
+        assert build_py_wheel.main() == 0
+
+    assert steps == ["javascript", "wheel"]