spaces 0.51.3__tar.gz → 0.52.0.dev0__tar.gz

{spaces-0.51.3 → spaces-0.52.0.dev0}/PKG-INFO

@@ -1,19 +1,20 @@
 Metadata-Version: 2.4
 Name: spaces
-Version: 0.51.3
+Version: 0.52.0.dev0
 Summary: Utilities for Hugging Face Spaces
 Author: Charles Bensimon
 Author-email: Charles Bensimon <charles@huggingface.co>
 License-Expression: Apache-2.0
 Requires-Dist: packaging
 Requires-Dist: typing-extensions>=4,<5
-Requires-Dist: requests>=2.19,<3
-Requires-Dist: gradio
 Requires-Dist: pydantic>=1,<3
 Requires-Dist: httpx>=0.20
+Requires-Dist: fastapi ; extra == 'serving'
+Requires-Dist: uvicorn ; extra == 'serving'
 Requires-Python: >=3.10, <3.15
 Project-URL: Homepage, https://huggingface.co
 Project-URL: Repository, https://github.com/huggingface/huggingface_hub
+Provides-Extra: serving
 Description-Content-Type: text/markdown
 
 # Hugging Face Spaces

{spaces-0.51.3 → spaces-0.52.0.dev0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "spaces"
-version = "0.51.3"
+version = "0.52.0.dev0"
 description = "Utilities for Hugging Face Spaces"
 readme = "README.md"
 requires-python = ">=3.10,<3.15"
@@ -11,12 +11,16 @@ authors = [
 dependencies = [
     "packaging",
     "typing-extensions>=4,<5",
-    "requests>=2.19,<3",
-    "gradio", # Actually requires 3.2+ if for `@spaces.GPU`
     "pydantic>=1,<3",
     "httpx>=0.20",
 ]
 
+[project.optional-dependencies]
+serving = [
+    "fastapi",
+    "uvicorn"
+]
+
 [project.urls]
 Homepage = "https://huggingface.co"
 Repository = "https://github.com/huggingface/huggingface_hub"
@@ -26,20 +30,20 @@ dev = [
     "pytest>=7.3.1,<8",
     "pytest-dotenv>=0.5.2,<0.6",
     "pytest-mock>=3.10.0,<4",
-    "requests-mock>=1.10.0,<2",
     "pytest-timeout>=2.1.0,<3",
     "poethepoet>=0.20.0,<0.21",
     "coverage>=7.2.6,<8",
     "pyright>=1.1.403,<2",
     "pytest-order>=1.1.0,<2",
     "pynvml>=11.5.0,<12",
-    "websockets>=13.0,<14",
     "pytest-asyncio>=0.21.1,<0.22",
     "pytest-httpx>=0.27.0,<0.28",
     "pydantic-to-typescript>=2.0.0,<3",
+    "requests>=2.19,<3",
     "setuptools",
 ]
 test = [
+    "gradio",
     "diffusers",
     "transformers",
     "accelerate",
@@ -51,6 +55,13 @@ test = [
     "kernels>=0.10.2,<0.11",
 ]
 
+[tool.uv]
+constraint-dependencies = [
+    "numpy<2",
+    "peft<0.19",
+    "transformers<4.51",
+]
+
 [tool.pytest.ini_options]
 addopts = "-v --durations=0 --durations-min=1"
 testpaths = ["tests"]
@@ -83,6 +94,8 @@ shell = """set -e
     coverage run -m pytest tests/cpu
     coverage run -m pytest tests/gpu
     find e2e -name '*.py' | xargs -I {} coverage run {}
+    pytest tests/cpu/serving/test_middleware.py::test_fds_server_hang --fd-xfail
+    pytest tests/cpu/serving/test_middleware.py::test_fds_requests_hang --fd-xfail
     coverage combine -q
     coverage xml  || true
     coverage html || true
@@ -101,17 +114,11 @@ shell = """set -e
 include = ["spaces", "tests"]
 exclude = ["spaces/_vendor"]
 pythonVersion = "3.10"
+reportMatchNotExhaustive = "error"
 reportPossiblyUnboundVariable = "error"
 reportUnnecessaryComparison = true
 reportPrivateImportUsage = "information"
 
-[tool.uv]
-constraint-dependencies = [
-    "numpy<2",
-    "peft<0.19",
-    "transformers<4.51",
-]
-
 [build-system]
 requires = ["uv_build>=0.11.6,<0.12"]
 build-backend = "uv_build"

{spaces-0.51.3 → spaces-0.52.0.dev0}/spaces/__init__.py

@@ -1,12 +1,14 @@
 """
 """
+
 import sys
+import warnings
 from types import FunctionType
 from typing import TYPE_CHECKING
 from typing import Callable
 
 
-# Prevent gradio from importing spaces
+# Prevent partially-imported gradio from importing spaces
 if (gr := sys.modules.get('gradio')) is not None: # pragma: no cover
     try:
         gr.Blocks
@@ -15,9 +17,16 @@ if (gr := sys.modules.get('gradio')) is not None: # pragma: no cover
 
 
 from .zero.decorator import GPU
-from .gradio import gradio_auto_wrap
-from .gradio import disable_gradio_auto_wrap
-from .gradio import enable_gradio_auto_wrap
+
+
+def gradio_auto_wrap(*args, **kwargs): # pragma: no cover
+    warnings.warn("gradio_auto_wrap has no effect and is deprecated")
+
+def disable_gradio_auto_wrap(*args, **kwargs): # pragma: no cover
+    warnings.warn("gradio_auto_wrap has no effect and is deprecated")
+
+def enable_gradio_auto_wrap(*args, **kwargs): # pragma: no cover
+    warnings.warn("gradio_auto_wrap has no effect and is deprecated")
 
 
 class LazyImported:

spaces-0.52.0.dev0/spaces/_vendor/asgiref/typing.py

@@ -0,0 +1,279 @@
+import sys
+from typing import (
+    Any,
+    Awaitable,
+    Callable,
+    Dict,
+    Iterable,
+    Literal,
+    Optional,
+    Protocol,
+    Tuple,
+    Type,
+    TypedDict,
+    Union,
+)
+
+if sys.version_info >= (3, 11):
+    from typing import NotRequired
+else:
+    from typing_extensions import NotRequired
+
+__all__ = (
+    "ASGIVersions",
+    "HTTPScope",
+    "WebSocketScope",
+    "LifespanScope",
+    "WWWScope",
+    "Scope",
+    "HTTPRequestEvent",
+    "HTTPResponseStartEvent",
+    "HTTPResponseBodyEvent",
+    "HTTPResponseTrailersEvent",
+    "HTTPResponsePathsendEvent",
+    "HTTPServerPushEvent",
+    "HTTPDisconnectEvent",
+    "WebSocketConnectEvent",
+    "WebSocketAcceptEvent",
+    "WebSocketReceiveEvent",
+    "WebSocketSendEvent",
+    "WebSocketResponseStartEvent",
+    "WebSocketResponseBodyEvent",
+    "WebSocketDisconnectEvent",
+    "WebSocketCloseEvent",
+    "LifespanStartupEvent",
+    "LifespanShutdownEvent",
+    "LifespanStartupCompleteEvent",
+    "LifespanStartupFailedEvent",
+    "LifespanShutdownCompleteEvent",
+    "LifespanShutdownFailedEvent",
+    "ASGIReceiveEvent",
+    "ASGISendEvent",
+    "ASGIReceiveCallable",
+    "ASGISendCallable",
+    "ASGI2Protocol",
+    "ASGI2Application",
+    "ASGI3Application",
+    "ASGIApplication",
+)
+
+
+class ASGIVersions(TypedDict):
+    spec_version: str
+    version: Union[Literal["2.0"], Literal["3.0"]]
+
+
+class HTTPScope(TypedDict):
+    type: Literal["http"]
+    asgi: ASGIVersions
+    http_version: str
+    method: str
+    scheme: str
+    path: str
+    raw_path: bytes
+    query_string: bytes
+    root_path: str
+    headers: Iterable[Tuple[bytes, bytes]]
+    client: Optional[Tuple[str, int]]
+    server: Optional[Tuple[str, Optional[int]]]
+    state: NotRequired[Dict[str, Any]]
+    extensions: Optional[Dict[str, Dict[object, object]]]
+
+
+class WebSocketScope(TypedDict):
+    type: Literal["websocket"]
+    asgi: ASGIVersions
+    http_version: str
+    scheme: str
+    path: str
+    raw_path: bytes
+    query_string: bytes
+    root_path: str
+    headers: Iterable[Tuple[bytes, bytes]]
+    client: Optional[Tuple[str, int]]
+    server: Optional[Tuple[str, Optional[int]]]
+    subprotocols: Iterable[str]
+    state: NotRequired[Dict[str, Any]]
+    extensions: Optional[Dict[str, Dict[object, object]]]
+
+
+class LifespanScope(TypedDict):
+    type: Literal["lifespan"]
+    asgi: ASGIVersions
+    state: NotRequired[Dict[str, Any]]
+
+
+WWWScope = Union[HTTPScope, WebSocketScope]
+Scope = Union[HTTPScope, WebSocketScope, LifespanScope]
+
+
+class HTTPRequestEvent(TypedDict):
+    type: Literal["http.request"]
+    body: bytes
+    more_body: bool
+
+
+class HTTPResponseDebugEvent(TypedDict):
+    type: Literal["http.response.debug"]
+    info: Dict[str, object]
+
+
+class HTTPResponseStartEvent(TypedDict):
+    type: Literal["http.response.start"]
+    status: int
+    headers: Iterable[Tuple[bytes, bytes]]
+    trailers: bool
+
+
+class HTTPResponseBodyEvent(TypedDict):
+    type: Literal["http.response.body"]
+    body: bytes
+    more_body: bool
+
+
+class HTTPResponseTrailersEvent(TypedDict):
+    type: Literal["http.response.trailers"]
+    headers: Iterable[Tuple[bytes, bytes]]
+    more_trailers: bool
+
+
+class HTTPResponsePathsendEvent(TypedDict):
+    type: Literal["http.response.pathsend"]
+    path: str
+
+
+class HTTPServerPushEvent(TypedDict):
+    type: Literal["http.response.push"]
+    path: str
+    headers: Iterable[Tuple[bytes, bytes]]
+
+
+class HTTPDisconnectEvent(TypedDict):
+    type: Literal["http.disconnect"]
+
+
+class WebSocketConnectEvent(TypedDict):
+    type: Literal["websocket.connect"]
+
+
+class WebSocketAcceptEvent(TypedDict):
+    type: Literal["websocket.accept"]
+    subprotocol: Optional[str]
+    headers: Iterable[Tuple[bytes, bytes]]
+
+
+class WebSocketReceiveEvent(TypedDict):
+    type: Literal["websocket.receive"]
+    bytes: Optional[bytes]
+    text: Optional[str]
+
+
+class WebSocketSendEvent(TypedDict):
+    type: Literal["websocket.send"]
+    bytes: Optional[bytes]
+    text: Optional[str]
+
+
+class WebSocketResponseStartEvent(TypedDict):
+    type: Literal["websocket.http.response.start"]
+    status: int
+    headers: Iterable[Tuple[bytes, bytes]]
+
+
+class WebSocketResponseBodyEvent(TypedDict):
+    type: Literal["websocket.http.response.body"]
+    body: bytes
+    more_body: bool
+
+
+class WebSocketDisconnectEvent(TypedDict):
+    type: Literal["websocket.disconnect"]
+    code: int
+    reason: Optional[str]
+
+
+class WebSocketCloseEvent(TypedDict):
+    type: Literal["websocket.close"]
+    code: int
+    reason: Optional[str]
+
+
+class LifespanStartupEvent(TypedDict):
+    type: Literal["lifespan.startup"]
+
+
+class LifespanShutdownEvent(TypedDict):
+    type: Literal["lifespan.shutdown"]
+
+
+class LifespanStartupCompleteEvent(TypedDict):
+    type: Literal["lifespan.startup.complete"]
+
+
+class LifespanStartupFailedEvent(TypedDict):
+    type: Literal["lifespan.startup.failed"]
+    message: str
+
+
+class LifespanShutdownCompleteEvent(TypedDict):
+    type: Literal["lifespan.shutdown.complete"]
+
+
+class LifespanShutdownFailedEvent(TypedDict):
+    type: Literal["lifespan.shutdown.failed"]
+    message: str
+
+
+ASGIReceiveEvent = Union[
+    HTTPRequestEvent,
+    HTTPDisconnectEvent,
+    WebSocketConnectEvent,
+    WebSocketReceiveEvent,
+    WebSocketDisconnectEvent,
+    LifespanStartupEvent,
+    LifespanShutdownEvent,
+]
+
+
+ASGISendEvent = Union[
+    HTTPResponseStartEvent,
+    HTTPResponseBodyEvent,
+    HTTPResponseTrailersEvent,
+    HTTPServerPushEvent,
+    HTTPDisconnectEvent,
+    WebSocketAcceptEvent,
+    WebSocketSendEvent,
+    WebSocketResponseStartEvent,
+    WebSocketResponseBodyEvent,
+    WebSocketCloseEvent,
+    LifespanStartupCompleteEvent,
+    LifespanStartupFailedEvent,
+    LifespanShutdownCompleteEvent,
+    LifespanShutdownFailedEvent,
+]
+
+
+ASGIReceiveCallable = Callable[[], Awaitable[ASGIReceiveEvent]]
+ASGISendCallable = Callable[[ASGISendEvent], Awaitable[None]]
+
+
+class ASGI2Protocol(Protocol):
+    def __init__(self, scope: Scope) -> None:
+        ...
+
+    async def __call__(
+        self, receive: ASGIReceiveCallable, send: ASGISendCallable
+    ) -> None:
+        ...
+
+
+ASGI2Application = Type[ASGI2Protocol]
+ASGI3Application = Callable[
+    [
+        Scope,
+        ASGIReceiveCallable,
+        ASGISendCallable,
+    ],
+    Awaitable[None],
+]
+ASGIApplication = Union[ASGI2Application, ASGI3Application]

{spaces-0.51.3 → spaces-0.52.0.dev0}/spaces/config.py

@@ -18,8 +18,6 @@ class Settings:
             os.getenv('SPACES_ZERO_GPU'))
         self.zero_device_api_url = (
             os.getenv('SPACES_ZERO_DEVICE_API_URL'))
-        self.gradio_auto_wrap = boolean(
-            os.getenv('SPACES_GRADIO_AUTO_WRAP'))
         self.zero_patch_torch_device = boolean(
             os.getenv('ZERO_GPU_PATCH_TORCH_DEVICE'))
         self.zero_gpu_v2 = boolean(

{spaces-0.51.3 → spaces-0.52.0.dev0}/spaces/reloading/__init__.py

@@ -1,8 +1,10 @@
 """
 """
+
 import threading
 from typing import Any
 from typing import Callable
+from uuid import uuid4
 
 
 reload_server_ports: set[int] = set()
@@ -14,6 +16,7 @@ def start_reload_server(
     stop_event: threading.Event,
     port: int = 7887,
 ):
+    from ..zero.context import GlobalContext
     from .server import ReloadServer
 
     reload_server = ReloadServer(
@@ -22,8 +25,9 @@ def start_reload_server(
         stop_event=stop_event,
     )
 
-    reload_server_ports.add(port)
+    server_port_uuid = uuid4()
+    GlobalContext.server_ports[server_port_uuid] = port
     try:
         reload_server.run(port=port)
     finally:
-        reload_server_ports.remove(port)
+        del GlobalContext.server_ports[server_port_uuid]

{spaces-0.51.3 → spaces-0.52.0.dev0}/spaces/reloading/server.py

@@ -12,6 +12,11 @@ from typing_extensions import assert_type
 from typing_extensions import Never
 from uuid import uuid4
 
+try:
+    import fastapi, uvicorn
+except ModuleNotFoundError: # pragma: no cover
+    raise RuntimeError("spaces.reloading.server requires FastAPI and uvicorn")
+
 from fastapi import APIRouter
 from fastapi import FastAPI
 from fastapi import HTTPException

{spaces-0.51.3 → spaces-0.52.0.dev0}/spaces/utils.py

@@ -30,10 +30,8 @@ class SimpleQueue(_SimpleQueue[T]):
             raise # pragma: no cover
         # https://bugs.python.org/issue29187
         except Exception as e:
-            message = str(e)
-            if not "pickle" in message:
-                raise # pragma: no cover
-            raise PicklingError(message)
+            # Always assume a PicklingError
+            raise PicklingError from e
     def wlock_release(self):
         if (lock := getattr(self, '_wlock', None)) is None:
             return # pragma: no cover
@@ -49,17 +47,12 @@ def drop_params(fn: Callable[[], T]) -> Callable[..., T]:
     return drop
 
 
-def gradio_request_var():
-    try:
-        from gradio.context import LocalContext
-    except ImportError: # pragma: no cover
-        raise RuntimeError(GRADIO_VERSION_ERROR_MESSAGE)
-    return LocalContext.request
-
-
 debug = partial(print, 'SPACES_ZERO_GPU_DEBUG')
 
 
 # Type-safe threads
 def create_thread(fn: Callable[P, Any], *args: P.args, **kwargs: P.kwargs) -> Thread:
     return Thread(target=fn, args=args, kwargs=kwargs)
+
+def create_thread_daemon(fn: Callable[P, Any], *args: P.args, **kwargs: P.kwargs) -> Thread:
+    return Thread(target=fn, args=args, kwargs=kwargs, daemon=True)

spaces-0.52.0.dev0/spaces/zero/__init__.py

@@ -0,0 +1,46 @@
+"""
+"""
+
+from importlib import metadata
+
+from packaging.version import Version
+
+from ..config import Config
+from .context import ZeroGPUError
+from .context import ZeroGPUErrorResponse
+from .context import ZeroGPUException
+from .context import ZeroGPULog
+from .middleware import ZeroGPUMiddleware
+from .lifecycle import default_gpu_size
+from .lifecycle import zerogpu_mode_enable
+from .lifecycle import zerogpu_mode_enabled
+from .lifecycle import zerogpu_startup
+
+
+def _maybe_enable_gradio_compat():
+    try:
+        gradio_version = metadata.version('gradio')
+    except metadata.PackageNotFoundError: # pragma: no cover
+        pass
+    else:
+        if Version(gradio_version) < Version('7.0.0.dev0'):
+            from . import gradio
+            gradio.patch()
+
+
+if Config.zero_gpu:
+    zerogpu_mode_enable()
+    _maybe_enable_gradio_compat()
+
+
+__all__ = [
+    'ZeroGPUError',
+    'ZeroGPUErrorResponse',
+    'ZeroGPUException',
+    'ZeroGPULog',
+    'ZeroGPUMiddleware',
+    'default_gpu_size',
+    'zerogpu_mode_enable',
+    'zerogpu_mode_enabled',
+    'zerogpu_startup',
+]