ZeroGPU native support

.changeset/beige-jobs-switch.md

@@ -0,0 +1,5 @@
+---
+"gradio": minor
+---
+
+feat:ZeroGPU native support

gradio/block_function.py

@@ -6,12 +6,6 @@
 
 from . import utils
 
-try:
-    import spaces  # type: ignore
-except Exception:
-    spaces = None
-
-
 if TYPE_CHECKING:  # Only import for type checking (is False at runtime).
     from gradio.components.base import Component
     from gradio.renderable import Renderable
@@ -114,15 +108,6 @@ def __init__(
         self.component_prop_inputs = component_prop_inputs or []
         self.key = key
 
-        self.spaces_auto_wrap()
-
-    def spaces_auto_wrap(self):
-        if spaces is None:
-            return
-        if utils.get_space() is None:
-            return
-        self.fn = spaces.gradio_auto_wrap(self.fn)
-
     def __str__(self):
         return str(
             {

gradio/blocks.py

@@ -1,5 +1,7 @@
 from __future__ import annotations
 
+import asyncio
+import contextvars
 import copy
 import dataclasses
 import hashlib
@@ -76,7 +78,11 @@
 from gradio.helpers import create_tracker, skip, special_args
 from gradio.i18n import I18n, I18nData
 from gradio.node_server import start_node_server
-from gradio.route_utils import API_PREFIX, MediaStream, slugify
+from gradio.route_utils import (
+    API_PREFIX,
+    MediaStream,
+    slugify,
+)
 from gradio.routes import INTERNAL_ROUTES, VERSION, App, Request
 from gradio.state_holder import SessionState, StateHolder
 from gradio.themes import ThemeClass as Theme
@@ -96,12 +102,7 @@
     get_package_version,
     get_upload_folder,
 )
-
-try:
-    import spaces  # type: ignore
-except Exception:
-    spaces = None
-
+from gradio.zerogpu import maybe_setup_zerogpu_middleware
 
 if TYPE_CHECKING:  # Only import for type checking (is False at runtime).
     from gradio.components.base import Component
@@ -1592,6 +1593,7 @@ async def call_function(
         event_data: EventData | None = None,
         in_event_listener: bool = False,
         state: SessionState | None = None,
+        context: contextvars.Context | None = None,
     ):
         """
         Calls function with given index and preprocessed input, and measures process time.
@@ -1652,7 +1654,16 @@ async def call_function(
                 processed_input[progress_index] = progress_tracker
 
             if inspect.iscoroutinefunction(fn):
-                prediction = await fn(*processed_input)
+                if context is not None:
+                    prediction = await context.copy().run(
+                        asyncio.create_task, fn(*processed_input)
+                    )
+                else:
+                    prediction = await fn(*processed_input)
+            elif context is not None:
+                prediction = await anyio.to_thread.run_sync(  # type: ignore
+                    context.copy().run, fn, *processed_input, limiter=self.limiter
+                )
             else:
                 prediction = await anyio.to_thread.run_sync(  # type: ignore
                     fn, *processed_input, limiter=self.limiter
@@ -1665,8 +1676,10 @@ async def call_function(
                 if iterator is None:
                     iterator = cast(AsyncIterator[Any], prediction)
                 if inspect.isgenerator(iterator):
-                    iterator = utils.SyncToAsyncIterator(iterator, self.limiter)
-                prediction = await utils.async_iteration(iterator)
+                    iterator = utils.SyncToAsyncIterator(
+                        iterator, self.limiter, context
+                    )
+                prediction = await utils.async_iteration(iterator, context=context)
                 is_generating = True
             except StopAsyncIteration:
                 n_outputs = len(block_fn.outputs)
@@ -2188,6 +2201,7 @@ async def process_api(
         simple_format: bool = False,
         explicit_call: bool = False,
         root_path: str | None = None,
+        context: contextvars.Context | None = None,
     ) -> dict[str, Any]:
         """
         Processes API calls from the frontend. First preprocesses the data,
@@ -2251,6 +2265,7 @@ async def process_api(
                     event_data,
                     in_event_listener,
                     state,
+                    context=context,
                 )
                 manual_cache_used = used_manual_cache()
             preds = result["prediction"]
@@ -2286,6 +2301,7 @@ async def process_api(
                         event_data,
                         in_event_listener,
                         state,
+                        context=context,
                     )
                 manual_cache_used = used_manual_cache()
 
@@ -2529,8 +2545,6 @@ def queue(
         """
         if api_open is not None:
             self.api_open = api_open
-        if utils.is_zero_gpu_space():
-            max_size = 1 if max_size is None else max_size
         self._queue = queueing.Queue(
             live_updates=status_update_rate == "auto",
             concurrency_count=self.max_threads,
@@ -2931,6 +2945,9 @@ def reverse(text):
             mcp_server=mcp_server,
             debug=debug,
         )
+
+        maybe_setup_zerogpu_middleware(self.app)
+
         if self.mcp_error and not quiet:
             print(self.mcp_error)
 

gradio/context.py

@@ -33,6 +33,37 @@ class LocalContext:
     )
 
 
+class MultiprocessWorkerContextualizer:
+    """
+    Refreshes LocalContext for persistent multiprocessing workers processing consecutive requests.
+
+    Example usage:
+        ```
+        pool = ProcessPoolExecutor()
+
+        def handler(value):
+            contextualize = MultiprocessWorkerContextualizer()
+            return e.submit(process_wrapper, contextualize, value).result()
+
+        def process_wrapper(contextualize, value):
+            contextualize()
+            return process(value)
+
+        demo = gr.Interface(handler, gr.Text(), gr.Text())
+        ```
+    """
+
+    def __init__(self):
+        self.event_id = LocalContext.event_id.get(None)
+        self.in_event_listener = LocalContext.in_event_listener.get(False)
+        self.progress = LocalContext.progress.get(None)
+
+    def __call__(self):
+        LocalContext.event_id.set(self.event_id)
+        LocalContext.in_event_listener.set(self.in_event_listener)
+        LocalContext.progress.set(self.progress)
+
+
 def get_render_context() -> BlockContext | None:
     if LocalContext.renderable.get(None):
         return LocalContext.render_block.get(None)

gradio/http_server.py

@@ -31,6 +31,7 @@
 INITIAL_PORT_VALUE = int(os.getenv("GRADIO_SERVER_PORT", "7860"))
 TRY_NUM_PORTS = int(os.getenv("GRADIO_NUM_PORTS", "100"))
 LOCALHOST_NAME = os.getenv("GRADIO_SERVER_NAME", "127.0.0.1")
+START_TIMEOUT = int(os.getenv("GRADIO_START_TIMEOUT", "5"))
 
 GRADIO_HOT_RELOAD = os.getenv("GRADIO_HOT_RELOAD", "false").lower()
 
@@ -69,7 +70,7 @@ def run_in_thread(self):
         start = time.time()
         while not self.started:
             time.sleep(1e-3)
-            if time.time() - start > 5:
+            if time.time() - start > START_TIMEOUT:
                 raise ServerFailedToStartError(
                     "Server failed to start. Please check that the port is available."
                 )