Update app.py

app.py

@@ -1,53 +1,32 @@
-import asyncio
-import numpy as np
 import gradio as gr
+import numpy as np
 import spaces
-from fastrtc import WebRTC, get_turn_credentials, AsyncStreamHandler
-from fastrtc.utils import wait_for_item
+from fastrtc import WebRTC, get_turn_credentials
 
-class FrameFlipperHandler(AsyncStreamHandler):
+@spaces.GPU
+def process_frames_on_gpu(frame_stream):
     """
-    A persistent, reactive handler for flipping video frames.
-
-    This class creates a long-running process for each user connection.
-    - The `receive` method is called by the backend whenever a new frame arrives from the user.
-    - The `emit` method is called by the backend in a loop to get processed frames to send back.
-    - An internal `asyncio.Queue` connects these two methods for reactive, low-latency processing.
+    This function runs as a persistent process on the GPU.
+    It iterates over incoming frames, processes them, and yields the results.
     """
-    def __init__(self):
-        super().__init__()
-        self.frame_queue = asyncio.Queue()
-
-    async def receive(self, frame: tuple[int, np.ndarray]) -> None:
-        """Called for each frame received from the client's webcam."""
-        # This is non-blocking and instantly puts the frame into our processing queue.
-        self.frame_queue.put_nowait(frame)
+    print("🚀 GPU Frame processing loop started.")
     
-    @spaces.GPU
-    async def emit(self):
-        """Called in a loop to get the next frame to send to the client."""
-        # This waits for a frame to be available in the queue with a small timeout.
-        frame_data = await wait_for_item(self.frame_queue, timeout=0.01)
-        
-        if frame_data:
-            _rate, frame_array = frame_data
-            if frame_array is not None:
-                # Flip the frame both vertically and horizontally
-                flipped_frame = np.flip(frame_array, axis=(0, 1))
-                return (None, flipped_frame) # The sample rate is ignored for video
-
-        return None
-
-    def copy(self):
-        """Creates a new instance of this handler for each new connection."""
-        return FrameFlipperHandler()
-
+    # This loop will block until a new frame is available, making it reactive.
+    for frame in frame_stream:
+        if frame is not None:
+            # This is where your GPU-intensive work would happen.
+            flipped_frame = np.flip(frame, axis=(0, 1))
+            
+            # Yield the processed frame to the output stream.
+            yield flipped_frame
+            
+    print("🛑 GPU Frame processing loop finished.")
 
 # --- Gradio UI Layout ---
-with gr.Blocks(theme=gr.themes.Soft(), title="FastRTC Webcam Double Flipper") as demo:
-    gr.Markdown("# 🚀 FastRTC Webcam Double Flipper (Reactive)")
+with gr.Blocks(theme=gr.themes.Soft(), title="FastRTC ZeroGPU Flipper") as demo:
+    gr.Markdown("# 🚀 FastRTC Webcam Flipper for ZeroGPU")
     gr.Markdown(
-        "*This version uses a persistent `AsyncStreamHandler` for low-latency, reactive streaming, ideal for environments like ZeroGPU.*"
+        "*This version uses Gradio's native stream iterator pattern. The `process_frames_on_gpu` function is a single, decorated process that receives and yields frames, making it ideal for ZeroGPU.*"
     )
     
     with gr.Row():
@@ -72,13 +51,11 @@ with gr.Blocks(theme=gr.themes.Soft(), title="FastRTC Webcam Double Flipper") as
                 height=480,
                 rtc_configuration=get_turn_credentials(),
             )
-    
-    # Instantiate our custom handler
-    handler = FrameFlipperHandler()
-
-    # Pass the handler instance to the stream method
+        
+    # When webcam_input is used as a streaming input, the `process_frames_on_gpu`
+    # function receives an iterator that it can loop over.
     webcam_input.stream(
-        fn=handler, 
+        fn=process_frames_on_gpu, 
         inputs=[webcam_input],
         outputs=[video_output],
         time_limit=120,