unity-devkit 0.1.14__tar.gz → 0.1.16__tar.gz

unity_devkit-0.1.16/.gitignore

@@ -0,0 +1,22 @@
+__pycache__/
+*.py[cod]
+.venv/
+.ruff_cache/
+.pytest_cache/
+bookmark.md
+
+# PlayerBuild Unity harness
+packages/unity/PlayerBuild/*.csproj
+packages/unity/PlayerBuild/*.sln
+packages/unity/PlayerBuild/Assets/Packages/
+packages/unity/PlayerBuild/Assets/_LocalWorkspace
+packages/unity/PlayerBuild/Assets/_LocalWorkspace.meta
+packages/unity/PlayerBuild/Build/
+packages/unity/PlayerBuild/Build.meta
+packages/unity/PlayerBuild/Builds/
+packages/unity/PlayerBuild/Library/
+packages/unity/PlayerBuild/Logs/
+packages/unity/PlayerBuild/Temp/
+packages/unity/PlayerBuild/UserSettings/
+packages/unity/PlayerBuild/obj/
+packages/unity/PlayerBuild/.utmp/

{unity_devkit-0.1.14 → unity_devkit-0.1.16}/PKG-INFO

@@ -1,9 +1,7 @@
 Metadata-Version: 2.5
 Name: unity-devkit
-Version: 0.1.14
+Version: 0.1.16
 Summary: Unity build, license, and CI tooling
-License-File: LICENSE
-License-File: NOTICE
 Requires-Python: >=3.13
 Requires-Dist: bashrun>=0.1.0
 Requires-Dist: ci-devkit>=0.1.0

{unity_devkit-0.1.14 → unity_devkit-0.1.16}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "unity-devkit"
-version = "0.1.14"
+version = "0.1.16"
 description = "Unity build, license, and CI tooling"
 requires-python = ">=3.13"
 dependencies = [
@@ -11,18 +11,18 @@ dependencies = [
     "pydantic-settings>=2.9.1",
 ]
 
-[dependency-groups]
-dev = ["basedpyright>=1.39.10", "ruff>=0.14.11", "pytest>=8.0.0"]
-
 [project.scripts]
 activate-unity-license = "unity_devkit.license:activate_app"
 build-unity = "unity_devkit.build_unity:app"
-compile-unity = "unity_devkit.compile_unity:app"
+build-unity-matrix = "unity_devkit.matrix:build_matrix"
+ci-build-unity = "unity_devkit.ci_build_unity:app"
+compile-check-unity = "unity_devkit.compile_check_unity:app"
+compile-check-unity-matrix = "unity_devkit.matrix:compile_check_matrix"
 install = "unity_devkit.install:app"
 lock-unity = "unity_devkit.lock_unity:app"
 test-unity = "unity_devkit.test_unity:app"
 unity-license-tag = "unity_devkit.license_restore:tag_app"
-unity-matrix = "unity_devkit.matrix:main"
+unity-dispatch = "unity_devkit.dispatch_workflow_generator:app"
 
 [build-system]
 requires = ["hatchling"]
@@ -31,17 +31,3 @@ build-backend = "hatchling.build"
 [tool.hatch.build.targets.wheel]
 packages = ["src/unity_devkit"]
 include = ["src/unity_devkit/py.typed"]
-
-[tool.uv.sources]
-
-[tool.basedpyright]
-venvPath = "."
-venv = ".venv"
-typeCheckingMode = "strict"
-include = ["src", "tests"]
-
-[tool.pytest.ini_options]
-testpaths = ["tests"]
-
-[tool.python-devkit.preflight]
-tests = true

unity_devkit-0.1.16/src/unity_devkit/build_unity.py

@@ -0,0 +1,41 @@
+from typing import Annotated
+
+import typer
+
+from .player_build import build_player, parse_environment_fields
+
+app = typer.Typer(add_completion=False, pretty_exceptions_show_locals=False)
+
+
+@app.command()
+def build_unity(
+    project: Annotated[str, typer.Option(help="Unity project name (catalog key in unity-devkit.json)")],
+    build: Annotated[str, typer.Option(help="Build target from the project's builds list (e.g. AndroidMobile)")],
+    version: Annotated[
+        str,
+        typer.Option(help="Version string to stamp into ProjectSettings.asset; empty builds unversioned"),
+    ] = "",
+    run_number: Annotated[int, typer.Option(help="bundleVersionCode to stamp; local builds default to 0")] = 0,
+    development: Annotated[bool, typer.Option(help="Development build column")] = False,
+    environment_preset: Annotated[
+        str,
+        typer.Option(
+            help="Environment preset name (the env class's Presets key); unset leaves the workspace untouched"
+        ),
+    ] = "",
+    environment_field: Annotated[
+        list[str] | None,
+        typer.Option("--environment-field", help="Environment field override as path=value (repeatable)"),
+    ] = None,
+) -> None:
+    fields = parse_environment_fields(environment_field or [])
+    for artifact in build_player(
+        project,
+        build,
+        version=version,
+        run_number=run_number,
+        development=development,
+        environment_preset=environment_preset,
+        environment_fields=fields,
+    ):
+        print(f"Built: {artifact}")

unity_devkit-0.1.14/src/unity_devkit/build_unity.py → unity_devkit-0.1.16/src/unity_devkit/ci_build_unity.py

@@ -1,13 +1,10 @@
 from __future__ import annotations
 
-import json
-import os
 import shutil
 from pathlib import Path
 from typing import Annotated
 
 import typer
-from bashrun.bash import bash_output
 from pydantic_settings import BaseSettings
 
 from ci_devkit.cache import restore, save
@@ -15,7 +12,7 @@ from ci_devkit.ci_step import ci_step
 from .license_restore import restore_license
 from ci_devkit.setup import configure_git, install_dotnet
 from ci_devkit.setup_oras import install_oras
-from .unity import prepare_unity_project, resolve_unity_build, run_unity_batchmode
+from .player_build import build_player, parse_environment_fields, resolve_unity_project
 
 
 class Settings(BaseSettings):
@@ -26,7 +23,7 @@ app = typer.Typer(add_completion=False, pretty_exceptions_show_locals=False)
 
 
 @app.command()
-def main(
+def ci_build_unity(
     project: Annotated[str, typer.Option(help="Project name")],
     project_path: Annotated[Path, typer.Option(help="Path to Unity project")],
     platform: Annotated[str, typer.Option(help="Target platform")],
@@ -34,20 +31,19 @@ def main(
     registry: Annotated[str, typer.Option(help="OCI registry path")],
     run_number: Annotated[int, typer.Option(help="CI run number")] = 0,
     branch: Annotated[str, typer.Option(help="Git branch name")] = "dev",
-    build_env: Annotated[
-        str, typer.Option(help="Newline-separated KEY=VALUE pairs injected into the Unity build process environment")
+    environment_preset: Annotated[
+        str, typer.Option(help="Environment preset name; empty leaves the workspace untouched")
+    ] = "",
+    development: Annotated[bool, typer.Option("--development", help="Development build column")] = False,
+    environment_fields: Annotated[
+        str, typer.Option(help="Newline-separated path=value environment field overrides")
+    ] = "",
+    version: Annotated[
+        str, typer.Option(help="Version string to stamp into ProjectSettings.asset; empty builds unversioned")
     ] = "",
 ) -> None:
     settings = Settings.model_validate({})
-
-    for line in build_env.splitlines():
-        entry = line.strip()
-        if not entry:
-            continue
-        key, separator, value = entry.partition("=")
-        if not separator:
-            raise SystemExit(f"Invalid --build-env entry (expected KEY=VALUE): {entry!r}")
-        os.environ[key.strip()] = value.strip()
+    fields = parse_environment_fields(environment_fields.splitlines())
 
     with ci_step("Setup"):
         configure_git(settings.github_workspace)
@@ -64,26 +60,22 @@ def main(
         restore(registry, "unity-library", tag, Path("."), fallback_tags=fallback_tags)
 
     with ci_step("Prepare build"):
-        project_config, build_flag, execute_method = resolve_unity_build(project, platform)
-        unity_project_path = project_config.path
+        unity_project_path = resolve_unity_project(project).path
         if unity_project_path.resolve() != project_path.resolve():
             raise SystemExit(
                 f"--project-path {project_path} does not match catalog entry '{project}' at {unity_project_path}"
             )
 
-    with ci_step("Prepare project"):
-        prepare_unity_project(unity_project_path)
-
     with ci_step(f"Build {project} [{platform}]"):
-        tag_prefix = project_config.tag_prefix
-        if tag_prefix:
-            version = latest_tag_version(f"{tag_prefix}-v") or "0.0.0"
-            full_version = f"{version}-dev+{run_number}" if branch != "main" else f"{version}+{run_number}"
-            version_file = unity_project_path / ".build-version.json"
-            version_file.write_text(json.dumps({"version": full_version, "runNumber": run_number}))
-            print(f"Wrote version {full_version} (bundleVersionCode={run_number}) to {version_file}")
-
-        run_unity_batchmode(unity_project_path, f"{build_flag} -executeMethod {execute_method}", nographics=False)
+        build_player(
+            project,
+            platform,
+            version=version,
+            run_number=run_number,
+            development=development,
+            environment_preset=environment_preset,
+            environment_fields=fields,
+        )
 
     with ci_step("Save library cache"):
         # PackageCache (~1.6 GiB) is redundant with the shared UPM cache at ~/.cache/Unity/upm/
@@ -98,16 +90,9 @@ def main(
         if build_directory.is_dir():
             artifact_directory = Path("/tmp/unity-builds")
             artifact_directory.mkdir(parents=True, exist_ok=True)
-            if platform == "linux64":
+            if platform == "Linux":
                 shutil.copytree(build_directory, artifact_directory, dirs_exist_ok=True)
             else:
                 for file in build_directory.rglob("*"):
                     if file.suffix in {".apk", ".exe"}:
                         shutil.copy2(file, artifact_directory / file.name)
-
-
-def latest_tag_version(prefix: str) -> str | None:
-    output = bash_output(f'git tag --list "{prefix}*" --sort=-v:refname').strip()
-    if not output:
-        return None
-    return output.splitlines()[0][len(prefix) :]

unity_devkit-0.1.16/src/unity_devkit/compile_check_unity.py

@@ -0,0 +1,33 @@
+from typing import Annotated
+
+import typer
+
+from .player_build import prepare_unity_project, resolve_unity_project, run_unity_batchmode
+
+app = typer.Typer(add_completion=False, pretty_exceptions_show_locals=False)
+
+COMPILE_ERROR_SIGNATURES = ("error CS",)
+
+
+@app.command()
+def compile_check_unity(
+    project: Annotated[str, typer.Option(help="Unity project name (catalog key in unity-devkit.json)")],
+    execute_method: Annotated[
+        str | None,
+        typer.Option(help="Static method to run after load (Class.Method) — one editor session per invocation"),
+    ] = None,
+    build_target: Annotated[
+        str | None,
+        typer.Option(help="Startup build target (e.g. Android) for sessions that must open on a non-default platform"),
+    ] = None,
+) -> None:
+    project_path = resolve_unity_project(project).path
+    extra_flags = ""
+    if build_target:
+        extra_flags += f" -buildTarget {build_target}"
+    if execute_method:
+        extra_flags += f" -executeMethod {execute_method}"
+    print(f"Compile-checking {project}...")
+    prepare_unity_project(project_path)
+    run_unity_batchmode(project_path, extra_flags, extra_failure_signatures=COMPILE_ERROR_SIGNATURES)
+    print("  Compiles clean")

unity_devkit-0.1.16/src/unity_devkit/dispatch_workflow_generator.py

@@ -0,0 +1,266 @@
+import json
+from pathlib import Path
+from typing import Annotated
+
+import typer
+from pydantic import BaseModel, ConfigDict
+
+from .compile_check_unity import COMPILE_ERROR_SIGNATURES
+from .projects import load_catalog
+from .player_build import prepare_unity_project, run_unity_batchmode
+
+app = typer.Typer(add_completion=False, pretty_exceptions_show_locals=False)
+
+DUMP_EXECUTE_METHOD = "Outernet.PlayerBuild.DumpEnvironment"
+DISPATCH_INPUT_CAP = 25
+NUMERIC_FIELD_TYPES = {
+    "Byte",
+    "SByte",
+    "Int16",
+    "UInt16",
+    "Int32",
+    "UInt32",
+    "Int64",
+    "UInt64",
+    "Single",
+    "Double",
+    "Decimal",
+}
+
+
+class EnvironmentEnum(BaseModel):
+    model_config = ConfigDict(extra="forbid")
+
+    name: str
+    values: list[str]
+    flags: bool
+
+
+class EnvironmentFieldDump(BaseModel):
+    model_config = ConfigDict(extra="forbid")
+
+    path: str
+    field_type: str
+
+
+class EnvironmentDump(BaseModel):
+    model_config = ConfigDict(extra="forbid")
+
+    class_name: str
+    mode_field: str
+    target_path: str
+    presets: dict[str, str]
+    enums: list[EnvironmentEnum]
+    fields: list[EnvironmentFieldDump]
+
+
+@app.command()
+def unity_dispatch(
+    project: Annotated[str, typer.Option(help="Unity project name (catalog key in unity-devkit.json)")],
+    output: Annotated[Path, typer.Option(help="Workflow file to write (or check with --check)")],
+    build_workflow: Annotated[
+        str,
+        typer.Option(
+            help="The build job's uses: value — the consumer's pinned build-unity.yml reference "
+            "(owner/repo/.github/workflows/build-unity.yml@sha, or ./.github/workflows/build-unity.yml inside unity-devkit)"
+        ),
+    ],
+    environment_config_class: Annotated[
+        str | None,
+        typer.Option(help="Env class file path override (defaults to build-config.json's environment_config)"),
+    ] = None,
+    check: Annotated[
+        bool, typer.Option("--check", help="Compare against the existing file instead of writing; fail on drift")
+    ] = False,
+) -> None:
+    projects = load_catalog()
+    if project not in projects:
+        raise SystemExit(f"Unknown project '{project}'. Valid: {', '.join(projects)}")
+
+    project_path = projects[project].path
+    env = {"ENVIRONMENT_CONFIG_CLASS": environment_config_class} if environment_config_class else None
+    print(f"Dumping environment of {project}...")
+    prepare_unity_project(project_path)
+    log_path = run_unity_batchmode(
+        project_path,
+        f"-executeMethod {DUMP_EXECUTE_METHOD}",
+        extra_failure_signatures=COMPILE_ERROR_SIGNATURES,
+        env=env,
+    )
+    dump = extract_environment_dump(log_path)
+    workflow = render_dispatch_workflow(dump, project=project, output=output.as_posix(), build_workflow=build_workflow)
+
+    if check:
+        if not output.is_file():
+            raise SystemExit(f"Dispatch workflow drift: {output} does not exist — generate it")
+        committed = output.read_text(encoding="utf-8")
+        if committed != workflow:
+            raise SystemExit(
+                f"Dispatch workflow drift: {output} differs from the environment class — regenerate with "
+                f"'{regen_command(project, output.as_posix(), build_workflow)}'"
+            )
+        print(f"  {output} matches the environment class")
+        return
+
+    output.parent.mkdir(parents=True, exist_ok=True)
+    output.write_text(workflow, encoding="utf-8")
+    print(f"  wrote {output}")
+
+
+def extract_environment_dump(log_path: Path) -> EnvironmentDump:
+    for line in log_path.read_text(encoding="utf-8", errors="replace").splitlines():
+        candidate = line.strip()
+        if not candidate.startswith("{"):
+            continue
+        try:
+            payload = json.loads(candidate)
+        except json.JSONDecodeError:
+            continue
+        if isinstance(payload, dict) and "class_name" in payload:
+            return EnvironmentDump.model_validate(payload)
+
+    raise SystemExit(f"No environment dump JSON found in the editor log at {log_path}")
+
+
+def render_dispatch_workflow(dump: EnvironmentDump, *, project: str, output: str, build_workflow: str) -> str:
+    enums_by_name = {environment_enum.name: environment_enum for environment_enum in dump.enums}
+    input_blocks: list[tuple[str, str, list[str], str | None]] = [
+        (
+            "environment-preset",
+            "Environment preset (Presets key) — empty leaves the workspace untouched",
+            ["type: choice", "options:", *indent_lines([*(f'- "{preset}"' for preset in ("", *dump.presets))], 2)],
+            'default: ""',
+        ),
+        ("development", "Development build column", ["type: boolean"], "default: false"),
+    ]
+    for field in dump.fields:
+        if field.path == dump.mode_field:
+            continue
+        input_blocks.append(field_input_block(field, enums_by_name))
+
+    input_count = len(input_blocks)
+    if input_count > DISPATCH_INPUT_CAP:
+        raise SystemExit(
+            f"Dispatch panel would carry {input_count} inputs — GitHub's workflow_dispatch cap is {DISPATCH_INPUT_CAP}. "
+            "Shrink the env class or move configuration out of it."
+        )
+
+    transport_lines = [field_transport_line(field) for field in dump.fields if field.path != dump.mode_field]
+    header = (
+        f"# Generated by '{regen_command(project, output, build_workflow)}' from the environment class "
+        f"{dump.class_name} —"
+    )
+
+    lines = [
+        header,
+        "# edit the class, then regenerate this workflow.",
+        "name: Unity Dispatch Build",
+        "",
+        "on:",
+        "  workflow_dispatch:",
+        "    inputs:",
+        *indent_lines([line for block in input_blocks for line in build_input_block(block)], 6),
+        "",
+        "jobs:",
+        "  build:",
+        f"    uses: {build_workflow}",
+        "    with:",
+        "      environment-preset: ${{ inputs['environment-preset'] }}",
+        "      development: ${{ inputs.development }}",
+    ]
+    if transport_lines:
+        lines.append("      environment-fields: |-")
+        lines.extend(indent_lines(transport_lines, 8))
+    else:
+        lines.append("      environment-fields: ''")
+    lines.append("    secrets: inherit")
+    return "\n".join(lines) + "\n"
+
+
+def regen_command(project: str, output: str, build_workflow: str) -> str:
+    return f"uv run unity-dispatch --project {project} --output {output} --build-workflow {build_workflow}"
+
+
+def field_input_block(
+    field: EnvironmentFieldDump, enums_by_name: dict[str, EnvironmentEnum]
+) -> tuple[str, str, list[str], str | None]:
+    input_id = field.path.replace(".", "-")
+    if field.field_type == "Boolean":
+        return (
+            input_id,
+            f"environment field {field.path} (bool) — checked overrides the preset value",
+            ["type: boolean"],
+            "default: false",
+        )
+
+    if field.field_type in enums_by_name:
+        environment_enum = enums_by_name[field.field_type]
+        if environment_enum.flags:
+            return (
+                input_id,
+                (
+                    f"environment field {field.path} (flags: {', '.join(environment_enum.values)}) — "
+                    "comma-separated names, empty keeps the preset value"
+                ),
+                ["type: string"],
+                'default: ""',
+            )
+        return (
+            input_id,
+            f"environment field {field.path} ({environment_enum.name}) — empty keeps the preset value",
+            [
+                "type: choice",
+                "options:",
+                *indent_lines([*(f'- "{value}"' for value in ("", *environment_enum.values))], 2),
+            ],
+            'default: ""',
+        )
+
+    if field.field_type == "String":
+        return (
+            input_id,
+            f"environment field {field.path} (string) — empty keeps the preset value",
+            ["type: string"],
+            'default: ""',
+        )
+
+    if field.field_type in NUMERIC_FIELD_TYPES:
+        return (
+            input_id,
+            f"environment field {field.path} ({field.field_type}) — empty keeps the preset value",
+            ["type: number"],
+            None,
+        )
+
+    raise SystemExit(
+        f"Environment field '{field.path}' has type '{field.field_type}' — no dispatch input type maps to it "
+        "(arrays and object references self-exclude from the dump; this is contract drift)"
+    )
+
+
+def field_transport_line(field: EnvironmentFieldDump) -> str:
+    input_id = field.path.replace(".", "-")
+    guard = "" if field.field_type == "Boolean" else " != ''"
+    return (
+        "${{ inputs['"
+        + input_id
+        + "']"
+        + guard
+        + " && format('"
+        + field.path
+        + "={0}', inputs['"
+        + input_id
+        + "']) || '' }}"
+    )
+
+
+def build_input_block(input_block: tuple[str, str, list[str], str | None]) -> list[str]:
+    input_id, description, type_lines, default_line = input_block
+    lines = [f"{input_id}:", f'  description: "{description}"', *[f"  {line}" for line in type_lines]]
+    if default_line is not None:
+        lines.append(f"  {default_line}")
+    return lines
+
+
+def indent_lines(lines: list[str], spaces: int) -> list[str]:
+    return [f"{' ' * spaces}{line}" if line else line for line in lines]

{unity_devkit-0.1.14 → unity_devkit-0.1.16}/src/unity_devkit/install.py

@@ -6,13 +6,13 @@ from pathlib import Path
 from typing import Annotated, Any
 
 import typer
-from bashrun.bash import bash, bash_check, bash_handoff, bash_output
+from bashrun.bash import bash, bash_handoff, bash_output
 
-from .compile_unity import build_unity_project
 from .projects import load_catalog
+from .player_build import build_player
 
-INSTALLABLE_TARGETS = {"android-mobile", "magicleap", "linux64"}
-ADB_TARGETS = {"android-mobile", "magicleap"}
+INSTALLABLE_TARGETS = {"AndroidMobile", "MagicLeap2", "Linux"}
+ADB_TARGETS = {"AndroidMobile", "MagicLeap2"}
 CACHE_ROOT = Path.home() / ".unity-devkit" / "builds"
 
 app = typer.Typer(add_completion=False, pretty_exceptions_show_locals=False)
@@ -23,7 +23,7 @@ def main(
     project: Annotated[str, typer.Option("--project", "-p", help="Unity project name")],
     target: Annotated[
         str | None,
-        typer.Option("--target", "-t", help="Device target (android-mobile, magicleap, linux64)"),
+        typer.Option("--target", "-t", help="Device target (AndroidMobile, MagicLeap2, Linux)"),
     ] = None,
     branch: Annotated[
         str | None,
@@ -31,23 +31,13 @@ def main(
     ] = None,
     run: Annotated[int | None, typer.Option("--run", "-r", help="Specific GitHub Actions run ID")] = None,
     serial: Annotated[str | None, typer.Option("--serial", "-s", help="adb device serial")] = None,
-    no_grant_permissions: Annotated[
-        bool,
-        typer.Option(
-            "--no-grant-permissions",
-            help=(
-                "Skip the post-install `adb shell pm grant` calls listed under `grant_permissions` "
-                "for the project's entry in unity-devkit.json. Permissions are granted by default."
-            ),
-        ),
-    ] = False,
     build_locally: Annotated[
         bool,
         typer.Option(
             "--build",
             "-B",
             help=(
-                "Compile the project locally via `compile-unity` and install the produced APK / "
+                "Build the project locally via `build-unity` and install the produced APK / "
                 "linux executable. Skips the GitHub Actions artifact lookup; --branch / --run are ignored."
             ),
         ),
@@ -81,9 +71,9 @@ def main(
     if build_locally:
         if branch or run:
             print("Warning: --branch / --run are ignored when --build is set")
-        produced = build_unity_project(project_name, target_name)
+        produced = build_player(project_name, target_name)
         apks = [path for path in produced if path.suffix == ".apk"]
-        executables = [path for path in produced if path.suffix == ".exe"]
+        executables = [path for path in produced if path.suffix in {".exe", ".x86_64"}]
     else:
         artifact_name = f"{project_name}-{target_name}"
 
@@ -127,7 +117,7 @@ def main(
         apks = sorted(cache_path.rglob("*.apk"))
 
         executables = []
-        if target_name == "linux64":
+        if target_name == "Linux":
             executable = next(
                 (
                     item
@@ -137,7 +127,7 @@ def main(
                 None,
             )
             if executable is None:
-                print("No linux64 executable found in artifact (expected a file with a matching _Data/ directory)")
+                print("No Linux executable found in artifact (expected a file with a matching _Data/ directory)")
                 raise SystemExit(1)
             executables = [executable]
 
@@ -148,19 +138,7 @@ def main(
 
         print(f"Installing: {apks[0].name}")
         adb_prefix = f"adb -s {serial}" if serial else "adb"
-        package = project_config.package
-        if package:
-            bash_check(f"{adb_prefix} uninstall {package}")
         bash(f"{adb_prefix} install {apks[0]}")
-        permissions = project_config.grant_permissions
-        if permissions and not no_grant_permissions:
-            if not package:
-                raise typer.BadParameter(
-                    f"{project_name} has grant_permissions but no 'package' field in its unity-devkit.json entry"
-                )
-            for permission in permissions:
-                print(f"Granting {permission} to {package}")
-                bash(f"{adb_prefix} shell pm grant {package} {permission}")
         print("Done.")
     else:
         if not executables:

{unity_devkit-0.1.14 → unity_devkit-0.1.16}/src/unity_devkit/lock_unity.py

@@ -3,7 +3,7 @@ from typing import Annotated
 import typer
 
 from .projects import load_catalog
-from .unity import prepare_unity_project, run_unity_batchmode
+from .player_build import prepare_unity_project, run_unity_batchmode
 
 app = typer.Typer(add_completion=False, pretty_exceptions_show_locals=False)