update requirements

Dockerfile

@@ -1,13 +0,0 @@
-FROM python:3.10-slim
-
-# Install uv
-RUN pip install --no-cache-dir uv
-
-WORKDIR /app
-COPY pyproject.toml .
-COPY . .
-
-# Install deps from pyproject.toml
-RUN uv sync --frozen
-
-CMD ["uv", "run", "python", "app.py"]

app.py

@@ -22,14 +22,13 @@ import numpy as np
 import pandas as pd
 import plotly.graph_objs as go
 import spaces
-import torch
 from embed4d import model3d_viewer
-from metrabs_pytorch.scripts.run_video import run_metrabs_video
 from myo_tools.mjs.marker.marker_api import get_marker_names
 from myo_tools.utils.file_ops.dataframe_utils import from_array_to_dataframe
 from myo_tools.utils.file_ops.io_utils import from_qpos_to_joint_angles
 from myo_tools.utils.mocap_ops.mocap_utils import rotate_mocap_ydown_to_zup
 from myosdk import Client
+from myosdk.exceptions import ApiError, InsufficientCreditsError
 
 PLOT_CONFIG = {
     "plot_bgcolor": "#0f172a",
@@ -40,7 +39,16 @@ PLOT_CONFIG = {
 }
 
 
-DEVICE = "cuda" if torch.cuda.is_available() else "cpu"
+def get_device():
+    """Lazy import torch and get device, falling back to CPU if CUDA unavailable."""
+    try:
+        import torch
+
+        return "cuda" if torch.cuda.is_available() else "cpu"
+    except ImportError:
+        return "cpu"
+
+
 UPLOAD_GLB = os.path.join(os.path.dirname(__file__), "./info_files/upload_files.glb")
 ERROR_GLB = os.path.join(os.path.dirname(__file__), "./info_files/error.glb")
 PROCESSING_GLB = os.path.join(os.path.dirname(__file__), "./info_files/processing.glb")
@@ -167,6 +175,7 @@ def run_retargeting_c3d(api_key, c3d_files, markerset_file):
             gr.update(visible=False),
             gr.update(visible=True, value=model3d_viewer(ERROR_GLB)),
         )
+        return
 
     try:
         # Initialize client
@@ -180,22 +189,11 @@ def run_retargeting_c3d(api_key, c3d_files, markerset_file):
         status.append(
             f"🔹 MyoSDK client initialized in { time.time() - init_time:.2f} seconds"
         )
-        init_time = time.time()
-        # Upload markerset
-        status.append("🔹 Uploading markerset file...")
-        yield "\n".join(status), None, None, gr.update(value=[]), gr.update(
-            visible=False
-        ), gr.update(visible=True, value=model3d_viewer(PROCESSING_GLB)),
-        mk_asset = client.assets.upload_file(markerset_file.name)
 
-        status.append(
-            f"🔹 Markerset file uploaded in {time.time() - init_time:.2f} seconds"
+        # Get markerset file path
+        markerset_path = (
+            markerset_file.name if hasattr(markerset_file, "name") else markerset_file
         )
-        yield "\n".join(status), None, None, gr.update(value=[]), gr.update(
-            visible=False
-        ), gr.update(visible=True, value=model3d_viewer(PROCESSING_GLB)),
-
-        mk_id = mk_asset["asset_id"]
 
         # Process each C3D file
         total_files = len(c3d_files)
@@ -209,55 +207,47 @@ def run_retargeting_c3d(api_key, c3d_files, markerset_file):
             ), gr.update(visible=True, value=model3d_viewer(PROCESSING_GLB)),
 
             init_time = time.time()
-            tracker_asset = client.assets.upload_file(f)
-            status.append(
-                f"\t🔹 C3D file uploaded in {time.time() - init_time:.2f} seconds"
-            )
+            # Use the new simplified API - it handles file uploads automatically
+            status.append("🔹 Starting retargeting job...")
             yield "\n".join(status), None, None, gr.update(value=[]), gr.update(
                 visible=False
             ), gr.update(visible=True, value=model3d_viewer(PROCESSING_GLB)),
-            init_time = time.time()
-            job = client.jobs.start_retarget(
-                tracker_asset_id=tracker_asset["asset_id"],
-                markerset_asset_id=mk_id,
-                export_glb=True,
-            )
 
-            status.append(
-                f"\t🔹 Retargeting job started in {time.time() - init_time:.2f} seconds ... Processing may take a few seconds depending on the file size."
+            result = client.create_retarget_job(
+                tracker=f,
+                markerset=markerset_path,
+                export_glb=True,
+                stream_status=True,  # Stream status updates automatically
             )
-            yield "\n".join(status), None, None, gr.update(value=[]), gr.update(
-                visible=False
-            ), gr.update(visible=True, value=model3d_viewer(PROCESSING_GLB)),
-            init_time = time.time()
-            result = client.jobs.wait(job["job_id"])
 
             status.append(
                 f"\t🔹 Retargeting job completed in {time.time() - init_time:.2f} seconds"
             )
+            if result.processing_time_seconds is not None:
+                status.append(
+                    f"\t   Processing time: {result.processing_time_seconds:.2f}s"
+                )
             yield "\n".join(status), None, None, gr.update(value=[]), gr.update(
                 visible=False
             ), gr.update(visible=True, value=model3d_viewer(PROCESSING_GLB)),
-            assert (
-                result["status"] == "SUCCEEDED"
-            ), f"Failed retarget for {os.path.basename(f)}"
 
             status.append(f"\t✅ Retargeting completed for {os.path.basename(f)}")
             base = os.path.splitext(os.path.basename(f))[0]
             out_path = os.path.join(tempfile.gettempdir(), base + ".parquet")
-            output_glb_path = os.path.join(
-                tempfile.gettempdir(), base + f"_{int(time.time())}_" + ".glb"
-            )
-
-            client.assets.download(
-                result["output"]["retarget_output_asset_ids"]["qpos"], out_path
-            )
 
+            # Download qpos file
+            result.download_qpos(out_path)
             output_files.append(out_path)
-            client.assets.download(
-                result["output"]["retarget_output_asset_ids"]["motion"], output_glb_path
-            )
-            output_glb_files.append(output_glb_path)
+
+            # Download GLB file for rendering (model3d_viewer needs local file path)
+            if result.output.motion:
+                output_glb_path = os.path.join(
+                    tempfile.gettempdir(), base + f"_{int(time.time())}_" + ".glb"
+                )
+                result.output.motion.download(output_glb_path)
+                output_glb_files.append(output_glb_path)
+            else:
+                output_glb_files.append(None)
 
         assert os.path.exists(
             output_files[0]
@@ -265,27 +255,26 @@ def run_retargeting_c3d(api_key, c3d_files, markerset_file):
 
         # Load angles from first output file
         status.append("🔹 Loading animation and angle data...")
-
-        assert os.path.getsize(output_glb_files[0]) > 0
-        if hasattr(os, "sync"):
-            os.sync()
-        else:
-            # Windows doesn't have os.sync
-            pass
-        time.sleep(0.5)  # allow filesystem flush
+        first_glb = (
+            output_glb_files[0] if output_glb_files and output_glb_files[0] else None
+        )
         yield "\n".join(status), None, None, gr.update(
             interactive=True, visible=True
         ), gr.update(visible=True), gr.update(
-            visible=True, value=model3d_viewer(output_glb_files[0])
+            visible=True,
+            value=model3d_viewer(first_glb) if first_glb else model3d_viewer(ERROR_GLB),
         )
+
         assert os.path.exists(out_path)
         df = from_qpos_to_joint_angles(output_files[0])
 
         angle_list = list(df.columns[1:])
         initial_value = [angle_list[0]] if angle_list else []
-        initial_plot = update_plot(df, initial_value)
         status.append("✅ Complete!")
         df_state_path = os.path.abspath(output_files[0])
+
+        # Build an initial plot for the first joint so users see something immediately.
+        initial_plot = update_plot(df_state_path, initial_value)
         yield (
             "\n".join(status),
             gr.update(value=output_files, visible=True),
@@ -293,13 +282,38 @@ def run_retargeting_c3d(api_key, c3d_files, markerset_file):
             gr.update(
                 choices=angle_list, value=initial_value, visible=True, interactive=True
             ),
-            gr.update(value=initial_plot, visible=True),
-            gr.update(visible=True, value=model3d_viewer(output_glb_files[0])),
+            initial_plot,
+            gr.update(
+                visible=True,
+                value=(
+                    model3d_viewer(first_glb)
+                    if first_glb
+                    else model3d_viewer(ERROR_GLB)
+                ),
+            ),
         )
 
+    except InsufficientCreditsError as e:
+        yield (
+            f"❌ Insufficient credits: {e}",
+            None,
+            None,
+            gr.update(visible=False),
+            gr.update(visible=False),
+            gr.update(visible=True, value=model3d_viewer(ERROR_GLB)),
+        )
+    except ApiError as e:
+        yield (
+            f"❌ API error: {e}",
+            None,
+            None,
+            gr.update(visible=False),
+            gr.update(visible=False),
+            gr.update(visible=True, value=model3d_viewer(ERROR_GLB)),
+        )
     except Exception as e:
         yield (
-            f"❌ {e}",
+            f"❌ Unexpected error: {e}",
             None,
             None,
             gr.update(visible=False),
@@ -365,8 +379,26 @@ def run_retargeting_video(
             visible=False
         ), video_path, gr.update(visible=True, value=model3d_viewer(PROCESSING_GLB)),
 
+        # Lazy import torch and metrabs for video processing
+        try:
+            import torch
+            from metrabs_pytorch.scripts.run_video import run_metrabs_video
+
+            device = get_device()
+        except (ImportError, Exception) as e:
+            yield (
+                f"❌ Error: Failed to import PyTorch/Metrabs: {e}. Please check your PyTorch installation.",
+                None,
+                None,
+                gr.update(visible=False),
+                gr.update(visible=False),
+                video_path,
+                gr.update(visible=True, value=model3d_viewer(ERROR_GLB)),
+            )
+            return
+
         results = list(
-            run_metrabs_video(video_path=video_path, device=DEVICE, visualize=False)
+            run_metrabs_video(video_path=video_path, device=device, visualize=False)
         )
         markers = rotate_mocap_ydown_to_zup(
             np.array([res["poses3d"] for res in results]).squeeze()
@@ -410,30 +442,8 @@ def run_retargeting_video(
         status.append(
             f"🔹 MyoSDK client initialized in { time.time() - init_time:.2f} seconds"
         )
-        init_time = time.time()
-        # Upload markerset
-        status.append("🔹 Uploading markerset file...")
-        yield "\n".join(status), None, None, gr.update(visible=False), gr.update(
-            visible=False,
-        ), video_with_keypoints, gr.update(
-            visible=True, value=model3d_viewer(PROCESSING_GLB)
-        ),
-
-        markerset_file_name = "markersets/movi_metrabs_markerset.xml"
-
-        mk_asset = client.assets.upload_file(markerset_file_name)
-
-        status.append(
-            f"🔹 Markerset file uploaded in {time.time() - init_time:.2f} seconds"
-        )
-
-        yield "\n".join(status), None, None, gr.update(visible=False), gr.update(
-            visible=False
-        ), video_with_keypoints, gr.update(
-            visible=True, value=model3d_viewer(PROCESSING_GLB)
-        ),
-        init_time = time.time()
 
+        markerset_file_name = "./markersets/movi_metrabs_markerset.xml"
         marker_names = get_marker_names(markerset_file_name)
 
         from_array_to_dataframe(
@@ -445,82 +455,77 @@ def run_retargeting_video(
 
         fn_parquet = os.path.join(tempfile.gettempdir(), "video_trackers.parquet")
         from_array_to_dataframe(markers, marker_names, fps, fn_parquet)
-        tracker_asset = client.assets.upload_file(fn_parquet)
 
         print("fn_parquet: ", fn_parquet)
 
         init_time = time.time()
-        job = client.jobs.start_retarget(
-            tracker_asset_id=tracker_asset["asset_id"],
-            markerset_asset_id=mk_asset["asset_id"],
-            export_glb=True,
-        )
-
-        status.append(
-            f"\t🔹 Retargeting job started in {time.time() - init_time:.2f} seconds ... Processing may take a few seconds depending on the video length."
-        )
+        status.append("🔹 Starting retargeting job...")
         yield "\n".join(status), None, None, gr.update(value=[]), gr.update(
             visible=False
         ), video_with_keypoints, gr.update(
             visible=True, value=model3d_viewer(PROCESSING_GLB)
         ),
-        init_time = time.time()
-        result = client.jobs.wait(job["job_id"])
+
+        # Use the new simplified API - it handles file uploads automatically
+        result = client.create_retarget_job(
+            tracker=fn_parquet,
+            markerset=markerset_file_name,
+            export_glb=True,
+            stream_status=True,  # Stream status updates automatically
+        )
 
         status.append(
             f"\t🔹 Retargeting job completed in {time.time() - init_time:.2f} seconds"
         )
+        if result.processing_time_seconds is not None:
+            status.append(
+                f"\t   Processing time: {result.processing_time_seconds:.2f}s"
+            )
         yield "\n".join(status), None, None, gr.update(visible=False), gr.update(
             visible=False
         ), video_with_keypoints, gr.update(
             visible=True, value=model3d_viewer(PROCESSING_GLB)
         ),
 
-        print("STATUS: ", result["status"])
-        assert (
-            result["status"] == "SUCCEEDED"
-        ), f"Failed retarget for {os.path.basename(video_path)}"
-
         base = os.path.splitext(os.path.basename(video_path))[0]
         out_path = os.path.join(tempfile.gettempdir(), base + ".parquet")
-        output_glb_path = os.path.join(
-            tempfile.gettempdir(), base + f"_{int(time.time())}_" + ".glb"
-        )
-        client.assets.download(
-            result["output"]["retarget_output_asset_ids"]["qpos"], out_path
-        )
+
+        # Download qpos file
+        result.download_qpos(out_path)
 
         assert os.path.exists(
             out_path
         ), f"Failed to download retargeted data for {os.path.basename(video_path)}"
 
-        client.assets.download(
-            result["output"]["retarget_output_asset_ids"]["motion"], output_glb_path
-        )
+        # Download GLB file for rendering (model3d_viewer needs local file path)
+        glb_path = None
+        if result.output.motion:
+            glb_path = os.path.join(
+                tempfile.gettempdir(), base + f"_{int(time.time())}_" + ".glb"
+            )
+            result.output.motion.download(glb_path)
 
-        assert os.path.getsize(output_glb_path) > 0
-        if hasattr(os, "sync"):
-            os.sync()
-        else:
-            # Windows doesn't have os.sync
-            pass
-        time.sleep(0.5)  # allow filesystem flush
-        print("output_glb_path: ", output_glb_path, os.path.getsize(output_glb_path))
         # Load angles from first output file
         status.append("🔹 Loading animation and angle data...")
         yield "\n".join(status), None, None, gr.update(visible=False), gr.update(
             visible=True
         ), video_with_keypoints, gr.update(
-            visible=True, value=model3d_viewer(output_glb_path)
+            visible=True,
+            value=(
+                model3d_viewer(glb_path) if glb_path else model3d_viewer(PROCESSING_GLB)
+            ),
         )
+
         assert os.path.exists(out_path)
         df = from_qpos_to_joint_angles(out_path)
 
         angle_list = list(df.columns[1:])
         initial_value = [angle_list[0]] if angle_list else []
-        initial_plot = update_plot(df, initial_value)
         status.append("✅ Complete!")
         df_state_path = os.path.abspath(out_path)
+
+        # Build an initial plot for the first joint so users see something immediately.
+        initial_plot = update_plot(df_state_path, initial_value)
         yield (
             "\n".join(status),
             gr.update(value=out_path, visible=True),
@@ -528,12 +533,51 @@ def run_retargeting_video(
             gr.update(
                 choices=angle_list, value=initial_value, visible=True, interactive=True
             ),
-            gr.update(value=initial_plot, visible=True),
+            initial_plot,
             video_with_keypoints,
-            gr.update(visible=True, value=model3d_viewer(output_glb_path)),
+            gr.update(
+                visible=True,
+                value=(
+                    model3d_viewer(glb_path)
+                    if glb_path
+                    else model3d_viewer(PROCESSING_GLB)
+                ),
+            ),
         )
         return
 
+    except InsufficientCreditsError as e:
+        # Use video_path if defined, otherwise use video_file or None
+        error_video = (
+            video_path
+            if "video_path" in locals()
+            else (video_file if video_file else None)
+        )
+        yield (
+            "\n".join(status + [f"\n❌ Insufficient credits: {e}"]),
+            None,
+            None,
+            gr.update(visible=False),
+            gr.update(visible=False),
+            error_video,
+            gr.update(visible=True, value=model3d_viewer(ERROR_GLB)),
+        )
+    except ApiError as e:
+        # Use video_path if defined, otherwise use video_file or None
+        error_video = (
+            video_path
+            if "video_path" in locals()
+            else (video_file if video_file else None)
+        )
+        yield (
+            "\n".join(status + [f"\n❌ API error: {e}"]),
+            None,
+            None,
+            gr.update(visible=False),
+            gr.update(visible=False),
+            error_video,
+            gr.update(visible=True, value=model3d_viewer(ERROR_GLB)),
+        )
     except Exception as e:
         # Use video_path if defined, otherwise use video_file or None
         error_video = (
@@ -542,7 +586,7 @@ def run_retargeting_video(
             else (video_file if video_file else None)
         )
         yield (
-            "\n".join(status + ["\n❌ Error: " + str(e)]),
+            "\n".join(status + [f"\n❌ Unexpected error: {e}"]),
             None,
             None,
             gr.update(visible=False),
@@ -558,27 +602,24 @@ def run_retargeting_video(
 
 
 def update_plot(parquet_path, joints):
-    """Safe Linux/macOS plotting from parquet or DataFrame."""
-    # Check joints first to avoid unnecessary processing
-    if not joints:
-        return go.Figure()
+    """Build a Plotly figure from a parquet file path and selected joints."""
+    # Normalize parquet_path (can come from gr.State as str or list)
+    path = parquet_path
+    if isinstance(path, list):
+        path = path[0] if path else None
 
-    # Check if parquet_path is valid
-    if parquet_path is None:
+    if not joints or path is None or path == "":
         return go.Figure()
 
-    if isinstance(parquet_path, pd.DataFrame):
-        df = parquet_path
-    else:
-        # Nothing loaded yet - check if it's an empty string
-        if parquet_path == "":
-            return go.Figure()
-
-        # File might not exist yet (race-safe)
-        if not os.path.exists(parquet_path):
+    if isinstance(path, str):
+        if not os.path.exists(path):
             return go.Figure()
+        path = os.path.abspath(path)
 
-        df = pd.read_parquet(parquet_path)
+    if isinstance(path, pd.DataFrame):
+        df = path
+    else:
+        df = pd.read_parquet(path)
 
     if df is None or df.empty:
         return go.Figure()
@@ -717,7 +758,7 @@ with gr.Blocks(css=CSS) as app:
     )
     plot_area = gr.Plot(
         label="Joint Angle Visualization - Interactive plot showing the selected joint angles over time. Use the legend to toggle individual joints on/off.",
-        visible=False,
+        visible=True,
     )
     status_box = gr.Textbox(
         label="Processing Status",
@@ -726,38 +767,13 @@ with gr.Blocks(css=CSS) as app:
     )
     gr.Markdown(f"MyoSDK v{myosdk.__version__}")
 
-    def update_plot_wrapper(parquet_path, joints):
-        """Wrapper to ensure plot is visible and updated on Linux."""
-        if not joints:
-            return gr.update(value=go.Figure(), visible=False)
-
-        if parquet_path is None:
-            return gr.update(value=go.Figure(), visible=False)
-
-        # Check if file exists and convert to absolute path for consistency
-        if isinstance(parquet_path, str):
-            if not os.path.exists(parquet_path):
-                return gr.update(value=go.Figure(), visible=False)
-            parquet_path = os.path.abspath(parquet_path)
-
-        try:
-            fig = update_plot(parquet_path, joints)
-            return gr.update(value=fig, visible=True)
-        except Exception:
-            return gr.update(value=go.Figure(), visible=False)
-
+    # When the user changes the joint selection, recompute and update the plot.
     joint_dropdown.change(
-        fn=update_plot_wrapper,
-        inputs=[df_state, joint_dropdown],
-        outputs=[plot_area],
-        show_progress=False,
-    )
-
-    joint_dropdown.input(
-        fn=update_plot_wrapper,
+        fn=update_plot,
         inputs=[df_state, joint_dropdown],
-        outputs=[plot_area],
+        outputs=plot_area,
         show_progress=False,
+        queue=False,
     )
     run_btn_c3d.click(
         fn=run_retargeting_c3d,

pyproject.toml

@@ -1,32 +0,0 @@
-[project]
-name = "myosdk-app"
-version = "0.1.0"
-description = "Add your description here"
-readme = "README.md"
-requires-python = ">=3.10"
-dependencies = [
-    "embed4d>=0.0.5",
-    "gradio>6",
-    "myo-tools>=0.1.1",
-    "numpy<2.0",
-    "plotly>=6.5.2",
-    "spaces>=0.47.0",
-    "torch==2.5.1",
-    "torchaudio==2.5.1",
-    "torchvision==0.20.1",
-    "vtk==9.4.2",
-    "mayavi==4.8.3",
-    "metrabs-pytorch",
-    "myosdk>=0.2.0",
-]
-
-[tool.uv]
-no-build-isolation-package = ["mayavi"]
-
-[[tool.uv.dependency-metadata]]
-name = "mayavi"
-version = "4.8.3"
-requires-dist = ["numpy"]
-
-[tool.uv.sources]
-metrabs-pytorch = { git = "https://github.com/Vittorio-Caggiano/metrabs.git" }

python-version

@@ -1 +0,0 @@
-3.10

requirements.txt

@@ -0,0 +1,8 @@
+gradio>6
+plotly
+myosdk
+myo_tools
+git+https://github.com/Vittorio-Caggiano/metrabs.git@claude/fix-mayavi-gradio-tZHmu
+spaces
+embed4d
+opencv-python-headless