3dai / tests /test_prebake.py
Bobby
Claude Opus 5.5
Pre-bake the GLB under the Pro allowance for embed runs
baf02dc
Raw History Blame Contribute Delete
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()