Spaces:
Running on Zero
Running on Zero
Download tests/test_prebake.py from broyang/3dai: direct link, hf CLI and curl.
- Browser
- Download file 13.1 kB
-
https://huggingface.co/spaces/broyang/3dai/resolve/main/tests/test_prebake.py
- Command line
-
hf download hf://spaces/broyang/3dai/tests/test_prebake.py
-
curl -L -o test_prebake.py https://huggingface.co/spaces/broyang/3dai/resolve/main/tests/test_prebake.py
13.1 kB
| import json | |
| import os | |
| import sys | |
| import threading | |
| import time | |
| import unittest | |
| from pathlib import Path | |
| from types import SimpleNamespace | |
| from unittest import mock | |
| ROOT = Path(__file__).resolve().parent.parent | |
| sys.path.insert(0, str(ROOT)) | |
| sys.path.insert(0, str(ROOT / "tests")) | |
| os.environ["LABS_FALLBACK_SIGNING_KEY"] = "unit-signing-key" | |
| os.environ.pop("SPACE_ID", None) | |
| os.environ.setdefault("GRADIO_ANALYTICS_ENABLED", "False") | |
| import fallback_stubs # noqa: E402 | |
| fallback_stubs.install() | |
| import gradio as gr # noqa: E402 | |
| import app # noqa: E402 | |
| PAYLOAD = {"glb_name": "model.glb", "glb_b64": "aGFybmVzcw=="} | |
| QUOTA_MESSAGE = "You have exceeded your ZeroGPU runs limit. Try again in 1 hour." | |
| BAKE = "gpu_task:bake" | |
| def request(session="visitor-a"): | |
| return SimpleNamespace(session_hash=session, headers={"x-ip-token": "visitor-token"}) | |
| def fresh_state(**extra): | |
| return {"runtime": "original", "marker": "state-0", **extra} | |
| def labs_events(logs, name): | |
| rows = [json.loads(line.split("LABS_EVENT ", 1)[1]) for line in logs.output if "LABS_EVENT " in line] | |
| return [row for row in rows if row["event"] == name] | |
| class GatedBake: | |
| def __init__(self): | |
| self.release = threading.Event() | |
| self.started = threading.Event() | |
| self.sizes = [] | |
| self.active = 0 | |
| self.overlapped = False | |
| def __call__(self, state, texture_size): | |
| self.active += 1 | |
| self.overlapped |= self.active > 1 | |
| self.sizes.append(texture_size) | |
| self.started.set() | |
| self.release.wait(5) | |
| self.active -= 1 | |
| return {"glb": texture_size} | |
| class PrebakeTestCase(unittest.TestCase): | |
| def setUp(self): | |
| fallback_stubs.GPU_ATTEMPTS.clear() | |
| fallback_stubs.GPU_CALLS.clear() | |
| fallback_stubs.GPU_GATE["error"] = None | |
| app.FLIGHTS = app.BakeFlights() | |
| patches = [ | |
| mock.patch.object(app, "save_export_payload", side_effect=lambda glb, _progress: dict(PAYLOAD, size=glb["glb"])), | |
| mock.patch.object(app, "current_session_tag", return_value=app.session_tag("visitor-a")), | |
| ] | |
| for patch in patches: | |
| patch.start() | |
| self.addCleanup(patch.stop) | |
| def prebake_in_background(self, state, texture_size=1024): | |
| worker = threading.Thread(target=app.prebake_glb, args=(state, 0.95, texture_size, request())) | |
| worker.start() | |
| self.addCleanup(worker.join, 5) | |
| return worker | |
| class PrebakeDedupe(PrebakeTestCase): | |
| def test_click_after_a_finished_prebake_is_served_without_a_second_allocation(self): | |
| state = fresh_state() | |
| with mock.patch.object(app, "_prepare_glb", side_effect=lambda _s, size: {"glb": size}), \ | |
| self.assertLogs("usage_log", "INFO") as logs: | |
| app.prebake_glb(state, 0.95, 1024, request()) | |
| status, payload = app.extract_model(state, 0.95, 1024, None) | |
| self.assertEqual(payload["size"], 1024) | |
| self.assertIn("Finalizing", status["value"]) | |
| self.assertEqual(fallback_stubs.GPU_CALLS, [BAKE]) | |
| self.assertEqual(labs_events(logs, "glb_done")[0]["prebake"], "hit") | |
| self.assertTrue(labs_events(logs, "prebake_done")[0]["ip_token"]) | |
| gpu_calls = [json.loads(line.split("GPU_CALL ", 1)[1]) for line in logs.output if "GPU_CALL " in line] | |
| self.assertEqual([call.get("prebake") for call in gpu_calls], [True]) | |
| def test_click_during_the_prebake_waits_for_it_instead_of_allocating_again(self): | |
| state, bake = fresh_state(), GatedBake() | |
| with mock.patch.object(app, "_prepare_glb", side_effect=bake), \ | |
| self.assertLogs("usage_log", "INFO") as logs: | |
| worker = self.prebake_in_background(state) | |
| self.assertTrue(bake.started.wait(5)) | |
| progress = mock.Mock() | |
| threading.Timer(0.2, bake.release.set).start() | |
| status, payload = app.extract_model(state, 0.95, 1024, progress) | |
| worker.join(5) | |
| self.assertEqual(payload["size"], 1024) | |
| self.assertEqual(bake.sizes, [1024]) | |
| self.assertEqual(fallback_stubs.GPU_CALLS, [BAKE]) | |
| self.assertRegex(progress.call_args.kwargs["desc"], "(?i)textur|glb|bak") | |
| self.assertEqual(labs_events(logs, "glb_done")[0]["prebake"], "joined") | |
| def test_a_changed_size_bakes_fresh_after_the_prebake_without_overlapping_it(self): | |
| state, bake = fresh_state(), GatedBake() | |
| with mock.patch.object(app, "_prepare_glb", side_effect=bake): | |
| worker = self.prebake_in_background(state) | |
| self.assertTrue(bake.started.wait(5)) | |
| threading.Timer(0.2, bake.release.set).start() | |
| status, payload = app.extract_model(state, 0.95, 2048, None) | |
| worker.join(5) | |
| self.assertEqual(payload["size"], 2048) | |
| self.assertEqual(bake.sizes, [1024, 2048]) | |
| self.assertFalse(bake.overlapped) | |
| self.assertEqual(state[app.GLB_SETTINGS_KEY]["texture_size"], 2048) | |
| self.assertFalse(state[app.GLB_PREBAKED_KEY]) | |
| def test_a_second_prebake_of_the_same_generation_does_not_allocate(self): | |
| state = fresh_state() | |
| with mock.patch.object(app, "_prepare_glb", side_effect=lambda _s, size: {"glb": size}): | |
| app.prebake_glb(state, 0.95, 1024, request()) | |
| app.prebake_glb(state, 0.95, 1024, request()) | |
| self.assertEqual(fallback_stubs.GPU_CALLS, [BAKE]) | |
| def test_prebake_joins_nothing_and_skips_when_a_click_bake_is_running(self): | |
| state, bake = fresh_state(), GatedBake() | |
| with mock.patch.object(app, "_prepare_glb", side_effect=bake): | |
| click = threading.Thread(target=app.extract_model, args=(state, 0.95, 1024, None)) | |
| click.start() | |
| self.assertTrue(bake.started.wait(5)) | |
| started = time.perf_counter() | |
| app.prebake_glb(state, 0.95, 1024, request()) | |
| self.assertLess(time.perf_counter() - started, 1) | |
| bake.release.set() | |
| click.join(5) | |
| self.assertEqual(bake.sizes, [1024]) | |
| class PrebakeCancellation(PrebakeTestCase): | |
| def test_new_generation_discards_the_stale_prebake(self): | |
| state, bake = fresh_state(), GatedBake() | |
| with mock.patch.object(app, "_prepare_glb", side_effect=bake): | |
| worker = self.prebake_in_background(state) | |
| self.assertTrue(bake.started.wait(5)) | |
| app.reset_fallback_state(request()) | |
| self.assertEqual(app.FLIGHTS.discard_session(app.session_tag("visitor-a")), 0) | |
| bake.release.set() | |
| worker.join(5) | |
| def test_other_sessions_keep_their_prebake(self): | |
| state, bake = fresh_state(), GatedBake() | |
| with mock.patch.object(app, "_prepare_glb", side_effect=bake): | |
| worker = self.prebake_in_background(state) | |
| self.assertTrue(bake.started.wait(5)) | |
| app.reset_fallback_state(request("visitor-b")) | |
| self.assertEqual(app.FLIGHTS.discard_session(app.session_tag("visitor-a")), 1) | |
| bake.release.set() | |
| worker.join(5) | |
| def test_prebakes_are_capped_and_never_evict_running_work(self): | |
| app.FLIGHTS = app.BakeFlights(prebake_limit=1) | |
| first, second, bake = fresh_state(), fresh_state(), GatedBake() | |
| with mock.patch.object(app, "_prepare_glb", side_effect=bake): | |
| worker = self.prebake_in_background(first) | |
| self.assertTrue(bake.started.wait(5)) | |
| app.prebake_glb(second, 0.95, 1024, request("visitor-b")) | |
| bake.release.set() | |
| worker.join(5) | |
| self.assertEqual(bake.sizes, [1024]) | |
| self.assertIsNotNone(first.get(app.GLB_PAYLOAD_KEY)) | |
| self.assertIsNone(second.get(app.GLB_PAYLOAD_KEY)) | |
| class PrebakeGuards(PrebakeTestCase): | |
| def test_switch_off_never_allocates(self): | |
| with mock.patch.object(app, "PREBAKE_GLB", False), mock.patch.object(app, "_prepare_glb") as prepare: | |
| app.prebake_glb(fresh_state(), 0.95, 1024, request()) | |
| prepare.assert_not_called() | |
| self.assertEqual(fallback_stubs.GPU_ATTEMPTS, []) | |
| def test_pro_fallback_generations_are_not_prebaked(self): | |
| with mock.patch.object(app, "_prepare_glb") as prepare: | |
| app.prebake_glb(fresh_state(**{app.GENERATED_VIA_KEY: "pro"}), 0.95, 1024, request()) | |
| prepare.assert_not_called() | |
| self.assertEqual(fallback_stubs.GPU_ATTEMPTS, []) | |
| def run_pro(self, frames=("frame",), state=None): | |
| state = fresh_state(**{app.GLB_REQUESTED_KEY: {"simplify": 0.95, "texture_size": 1024}}) if state is None else state | |
| entry = SimpleNamespace(args=(object(), 42, 7.5, 12, 3.0, 12, 1024), session_hash="visitor-a") | |
| with mock.patch.object(app, "generate_preview_frames", return_value=(list(frames), state)), \ | |
| mock.patch.object(app, "write_preview_video", return_value="preview.webm"), \ | |
| mock.patch.object(app, "save_run_async"), \ | |
| mock.patch.object(app, "get_preview_settings", return_value=(0, 0, 15, 0)): | |
| return app.run_pro_generate(entry, request()) | |
| def wait_for_bakes(self, count): | |
| deadline = time.time() + 5 | |
| while len(fallback_stubs.GPU_CALLS) < count and time.time() < deadline: | |
| time.sleep(0.01) | |
| def test_pro_generation_prebakes_under_its_own_request_and_the_click_is_a_hit(self): | |
| with mock.patch.object(app, "_prepare_glb", side_effect=lambda _s, size: {"glb": size}), \ | |
| self.assertLogs("usage_log", "INFO") as logs: | |
| _video, state = self.run_pro() | |
| self.wait_for_bakes(1) | |
| deadline = time.time() + 5 | |
| while app.GLB_PAYLOAD_KEY not in state and time.time() < deadline: | |
| time.sleep(0.01) | |
| status, payload = app.extract_model(state, 0.95, 1024, None) | |
| self.assertEqual(payload["size"], 1024) | |
| self.assertEqual(fallback_stubs.GPU_CALLS, [BAKE]) | |
| self.assertEqual(labs_events(logs, "prebake_done")[0]["via"], "pro") | |
| self.assertEqual(labs_events(logs, "glb_done")[0]["prebake"], "hit") | |
| def test_click_during_the_pro_prebake_joins_it(self): | |
| bake = GatedBake() | |
| with mock.patch.object(app, "_prepare_glb", side_effect=lambda _s, size: bake(_s, size)): | |
| _video, state = self.run_pro() | |
| self.assertTrue(bake.started.wait(5)) | |
| clicked = {} | |
| click = threading.Thread(target=lambda: clicked.update(result=app.extract_model(state, 0.95, 1024, None))) | |
| click.start() | |
| time.sleep(0.1) | |
| bake.release.set() | |
| click.join(5) | |
| self.assertEqual(clicked["result"][1]["size"], 1024) | |
| self.assertEqual(fallback_stubs.GPU_CALLS, [BAKE]) | |
| def test_failed_or_disabled_pro_previews_do_not_prebake(self): | |
| with mock.patch.object(app, "_prepare_glb") as prepare: | |
| self.run_pro(frames=()) | |
| with mock.patch.object(app, "PREBAKE_GLB", False): | |
| self.run_pro() | |
| time.sleep(0.1) | |
| prepare.assert_not_called() | |
| self.assertEqual(fallback_stubs.GPU_ATTEMPTS, []) | |
| def test_pro_generation_marks_its_state(self): | |
| entry = SimpleNamespace(args=(object(), 42, 7.5, 12, 3.0, 12, 1024), session_hash="visitor-a") | |
| with mock.patch.object(app, "generate_preview_frames", return_value=(None, fresh_state())): | |
| _video, state = app.run_pro_generate(entry, request()) | |
| self.assertEqual(state[app.GENERATED_VIA_KEY], "pro") | |
| def test_quota_denied_prebake_leaves_no_error_and_the_click_still_routes_normally(self): | |
| state = fresh_state() | |
| fallback_stubs.GPU_GATE["error"] = gr.Error(QUOTA_MESSAGE) | |
| app.prebake_glb(state, 0.95, 1024, request()) | |
| self.assertNotIn(app.GLB_ERROR_KEY, state) | |
| status, payload = app.extract_model(state, 0.95, 1024, None) | |
| self.assertIsNone(payload) | |
| self.assertTrue(app.export_quota_denied(state, status["value"])) | |
| self.assertEqual(fallback_stubs.GPU_ATTEMPTS, [BAKE, BAKE]) | |
| def test_invalid_size_is_refused_before_allocation(self): | |
| app.prebake_glb(fresh_state(), 0.95, 999, request()) | |
| self.assertEqual(fallback_stubs.GPU_ATTEMPTS, []) | |
| class PrebakeWiring(unittest.TestCase): | |
| def test_prebake_follows_every_generation_flow_and_stays_off_the_api(self): | |
| config = app.demo.get_config_file() | |
| deps = config["dependencies"] | |
| prebakes = [dep for dep in deps if (dep.get("api_name") or "").startswith("prebake_glb")] | |
| self.assertEqual(len(prebakes), 3) | |
| self.assertTrue(all(dep["api_visibility"] == "private" for dep in prebakes)) | |
| self.assertTrue(all(dep["show_progress"] == "hidden" and not dep["outputs"] for dep in prebakes)) | |
| by_id = {dep["id"]: dep for dep in deps} | |
| self.assertTrue(all(by_id[dep["trigger_after"]]["api_name"].startswith("enable_model_exports") for dep in prebakes)) | |
| self.assertFalse([name for name in app.demo.get_api_info()["named_endpoints"] if "prebake" in name]) | |
| if __name__ == "__main__": | |
| unittest.main() | |