unity-devkit 0.1.0__py3-none-any.whl

unity_devkit/projects.py

@@ -0,0 +1,53 @@
+import json
+import os
+from pathlib import Path
+
+from pydantic import BaseModel
+
+MANIFEST_FILENAME = "unity-build.json"
+PRUNE_DIRECTORIES = {".git", "Library", "Temp", "obj", "Build", "node_modules", "__pycache__"}
+
+
+class UnityBuildManifest(BaseModel, extra="forbid"):
+    builds: list[str] | None = None
+    execute_methods: dict[str, str] | None = None
+    package: str | None = None
+    grant_permissions: list[str] = []
+    tag_prefix: str | None = None
+
+
+class UnityProject(UnityBuildManifest):
+    path: Path
+
+
+def load_unity_projects() -> dict[str, UnityProject]:
+    projects: dict[str, UnityProject] = {}
+    for directory in directories_containing(Path.cwd(), MANIFEST_FILENAME):
+        project_path = directory.resolve()
+        name = project_path.name
+        version_file = project_path / "ProjectSettings" / "ProjectVersion.txt"
+        if not version_file.exists():
+            raise SystemExit(
+                f"{project_path / MANIFEST_FILENAME} is not inside a Unity project: missing {version_file}"
+            )
+        if name in projects:
+            raise SystemExit(f"Duplicate Unity project name '{name}': {projects[name].path} and {project_path}")
+
+        manifest = UnityBuildManifest(**json.loads((project_path / MANIFEST_FILENAME).read_text()))
+        projects[name] = UnityProject(path=project_path, **manifest.model_dump())
+
+    if not projects:
+        raise SystemExit(f"No {MANIFEST_FILENAME} manifests found under {Path.cwd()} — run from the repo root")
+
+    return projects
+
+
+def directories_containing(root: Path, filename: str) -> list[Path]:
+    directories: list[Path] = []
+    for directory, subdirectories, filenames in os.walk(root):
+        subdirectories[:] = sorted(
+            name for name in subdirectories if name not in PRUNE_DIRECTORIES and not name.startswith(".")
+        )
+        if filename in filenames:
+            directories.append(Path(directory))
+    return directories

unity_devkit/setup.py

@@ -0,0 +1,127 @@
+from __future__ import annotations
+
+import os
+import platform
+import re
+import shlex
+import shutil
+from pathlib import Path
+
+from bashrun import bash, bash_no_raise, bash_output
+from pydantic import Field
+from pydantic_settings import BaseSettings
+
+
+class Settings(BaseSettings):
+    github_path: str | None = None
+    system_drive: str = Field("C:", validation_alias="SystemDrive")
+    agent_tools_directory: str | None = Field(None, validation_alias="AGENT_TOOLSDIRECTORY")
+
+
+settings = Settings.model_validate({})
+
+CONTAINER_PATHS = ["/to_clean/android", "/to_clean/dotnet", "/to_clean/ghcup", "/to_clean/swift"]
+
+BARE_LINUX_PATHS = ["/usr/local/lib/android", "/usr/share/dotnet", "/usr/local/.ghcup", "/usr/share/swift", "/opt/ghc"]
+
+LARGE_PACKAGE_PATTERNS = [
+    "^aspnetcore-.*",
+    "^dotnet-.*",
+    "^llvm-.*",
+    "php.*",
+    "^mongodb-.*",
+    "^mysql-.*",
+    "azure-cli",
+    "google-chrome-stable",
+    "firefox",
+    "powershell",
+    "mono-devel",
+    "libgl1-mesa-dri",
+    "google-cloud-sdk",
+    "google-cloud-cli",
+]
+
+
+def _remove_paths(paths: list[str], sudo: bool = False) -> None:
+    existing = [path for path in paths if Path(path).exists()]
+    if not existing:
+        return
+    if sudo:
+        bash_no_raise(f"sudo rm -rf {shlex.join(existing)}")
+    elif platform.system() == "Windows":
+        for path in existing:
+            shutil.rmtree(path, ignore_errors=True)
+    else:
+        bash_no_raise(f"rm -rf {shlex.join(existing)}")
+
+
+# actions/checkout sets safe.directory in a temporary HOME that's cleaned up
+# after the step finishes (actions/checkout#766). Container jobs that run
+# git later need it re-set in the real HOME.
+def configure_git(workspace: str) -> None:
+    bash(f"git config --global --add safe.directory {shlex.quote(workspace)}")
+
+
+def free_disk_space(*, large_packages: bool = False, docker_images: bool = False, swap_storage: bool = False) -> None:
+    system = platform.system()
+    in_container = Path("/to_clean").is_dir()
+
+    if system == "Windows":
+        paths = [os.path.join(settings.system_drive, "Program Files", "dotnet")]
+        if settings.agent_tools_directory:
+            paths.append(settings.agent_tools_directory)
+        print(f"Removing: {', '.join(paths)}")
+        _remove_paths(paths)
+    elif in_container:
+        print("Removing pre-installed toolchains (container)")
+        _remove_paths(CONTAINER_PATHS)
+    else:
+        print("Removing pre-installed toolchains")
+        _remove_paths(BARE_LINUX_PATHS, sudo=True)
+
+        if large_packages:
+            print("Removing large apt packages")
+            bash_no_raise(f"sudo apt-get remove -y --fix-missing {shlex.join(LARGE_PACKAGE_PATTERNS)}")
+            bash_no_raise("sudo apt-get autoremove -y")
+            bash_no_raise("sudo apt-get clean")
+
+        if docker_images:
+            print("Pruning Docker images")
+            bash_no_raise("sudo docker image prune --all --force")
+
+        if swap_storage:
+            print("Removing swap")
+            bash_no_raise("sudo swapoff -a")
+            bash_no_raise("sudo rm -f /mnt/swapfile")
+
+    bash("df -h")
+
+
+def install_dotnet(channel: str) -> None:
+    print(f"Installing .NET SDK {channel}")
+    script = Path(__file__).parent / "third-party" / "dotnet-install.sh"
+    bash(f"bash {script} --channel {channel}")
+    dotnet_path = str(Path.home() / ".dotnet")
+    os.environ["PATH"] = f"{dotnet_path}{os.pathsep}{os.environ['PATH']}"
+    if settings.github_path:
+        with open(settings.github_path, "a") as file:
+            file.write(f"{dotnet_path}\n")
+
+
+def install_node(version: str, registry_url: str | None = None) -> None:
+    system = platform.system()
+    sudo = system == "Linux" and os.geteuid() != 0
+
+    print(f"Installing Node.js {version}")
+    shasums = bash_output(f"curl -fsSL https://nodejs.org/dist/latest-v{version}.x/SHASUMS256.txt")
+    match = re.search(r"(node-v[\d.]+-linux-x64\.tar\.xz)", shasums)
+    if not match:
+        raise SystemExit(f"Could not find Node.js v{version} linux-x64 binary")
+    filename = match.group(1)
+    prefix = "sudo " if sudo else ""
+    bash(f"curl -fsSLO https://nodejs.org/dist/latest-v{version}.x/{filename}")
+    bash(f"{prefix}rm -rf /usr/local/lib/node_modules/npm")
+    bash(f"{prefix}tar -xJf {filename} -C /usr/local --strip-components=1")
+    Path(filename).unlink()
+    if registry_url:
+        (Path.home() / ".npmrc").write_text(f"registry={registry_url}\n")

unity_devkit/setup_oras.py

@@ -0,0 +1,51 @@
+from __future__ import annotations
+
+import os
+import platform
+import shlex
+import shutil
+from pathlib import Path
+
+from bashrun import bash
+from pydantic_settings import BaseSettings
+
+
+class Settings(BaseSettings):
+    github_token: str
+    github_actor: str = ""
+    github_path: str | None = None
+    runner_temp: str = "."
+
+
+def install_oras(version: str = "1.2.2") -> None:
+    settings = Settings.model_validate({})
+    system = platform.system()
+    sudo = system == "Linux" and os.geteuid() != 0
+    prefix = "sudo " if sudo else ""
+
+    if system == "Linux":
+        bash(f"{prefix}apt-get update -qq")
+        bash(f"{prefix}apt-get install -y -qq zstd")
+    elif system == "Windows":
+        bash("choco install zstandard -y --no-progress")
+
+    if system == "Linux":
+        archive = f"oras_{version}_linux_amd64.tar.gz"
+        bash(f"curl -fsSLO https://github.com/oras-project/oras/releases/download/v{version}/{archive}")
+        bash(f"{prefix}tar -xzf {archive} -C /usr/local/bin/ oras")
+        Path(archive).unlink()
+    elif system == "Windows":
+        archive = f"oras_{version}_windows_amd64.zip"
+        oras_directory = Path(settings.runner_temp) / "oras"
+        bash(f"curl -fsSLO https://github.com/oras-project/oras/releases/download/v{version}/{archive}")
+        shutil.unpack_archive(archive, oras_directory)
+        Path(archive).unlink()
+        os.environ["PATH"] = f"{oras_directory}{os.pathsep}{os.environ['PATH']}"
+        if settings.github_path:
+            with open(settings.github_path, "a") as file:
+                file.write(f"{oras_directory}\n")
+
+    bash(
+        f"oras login ghcr.io --username {shlex.quote(settings.github_actor)} --password-stdin",
+        stdin_text=settings.github_token,
+    )

unity_devkit/test_unity.py

@@ -0,0 +1,31 @@
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Annotated
+
+import typer
+
+from .projects import load_unity_projects
+from .unity import run_unity_batchmode
+
+app = typer.Typer(add_completion=False, pretty_exceptions_show_locals=False)
+
+
+@app.command()
+def main(
+    project: Annotated[str, typer.Option(help="Unity project name (directory containing unity-build.json)")],
+    test_platform: Annotated[str, typer.Option(help="Unity test platform (EditMode or PlayMode)")] = "EditMode",
+    results: Annotated[Path, typer.Option(help="Output path for NUnit XML results")] = Path(
+        "artifacts/unity-test-results.xml"
+    ),
+) -> None:
+    projects = load_unity_projects()
+    if project not in projects:
+        raise SystemExit(f"Unknown project '{project}'. Valid: {', '.join(projects)}")
+
+    project_path = projects[project].path
+    results.parent.mkdir(parents=True, exist_ok=True)
+
+    run_unity_batchmode(
+        project_path, f"-runTests -testPlatform {test_platform} -testResults {results.resolve()}", auto_quit=False
+    )

unity_devkit/third-party/README.md

@@ -0,0 +1,9 @@
+# Third-party vendored files
+
+## dotnet-install.sh
+
+- **Source**: https://dot.net/v1/dotnet-install.sh
+- **Upstream repo**: https://github.com/dotnet/install-scripts
+- **License**: MIT (see header in script)
+- **Vendored**: 2026-03-16
+- **Why**: The `actions/setup-dotnet` GitHub Action bundles this script locally to avoid downloading it at runtime. We vendor it for the same reason — downloading it via curl inside CI containers is unreliable (timeouts).