spaces 0.49b9__tar.gz → 0.50.dev0__tar.gz

spaces-0.50.dev0/PKG-INFO

@@ -0,0 +1,24 @@
+Metadata-Version: 2.4
+Name: spaces
+Version: 0.50.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: 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
+
+## Installation
+
+`pip install spaces`

spaces-0.50.dev0/pyproject.toml

@@ -0,0 +1,127 @@
+[project]
+name = "spaces"
+version = "0.50.dev0"
+description = "Utilities for Hugging Face Spaces"
+readme = "README.md"
+requires-python = ">=3.10,<3.15"
+license = "Apache-2.0"
+authors = [
+    { name = "Charles Bensimon", email = "charles@huggingface.co" },
+]
+dependencies = [
+    "packaging",
+    "typing-extensions>=4,<5",
+    "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"
+
+[dependency-groups]
+dev = [
+    "pytest>=7.3.1,<8",
+    "pytest-dotenv>=0.5.2,<0.6",
+    "pytest-mock>=3.10.0,<4",
+    "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",
+    "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",
+    "bitsandbytes",
+    "torch==2.9.1",
+    "torchao>=0.10.0,<0.11",
+    "scipy",
+    "peft",
+    "kernels>=0.10.2,<0.11",
+]
+
+[tool.uv]
+constraint-dependencies = [
+    "numpy<2",
+    "peft<0.19",
+    "transformers<4.51",
+]
+
+[tool.pytest.ini_options]
+addopts = "-v"
+testpaths = ["tests"]
+env_files = ["tests/.env"]
+
+[tool.coverage.run]
+source = ["spaces"]
+omit = [
+    "spaces/zero/api.py",
+    "spaces/zero/torch/patching_legacy.py",
+    "spaces/zero/torch/bitsandbytes_legacy.py",
+    "spaces/_vendor/*",
+]
+concurrency = ["thread", "multiprocessing"]
+
+[tool.coverage.report]
+fail_under = 100
+exclude_also = [
+    "^\\s*if TYPE_CHECKING:\\s*$",
+    "^\\s*assert_never\\(.*\\)\\s*$",
+    "^\\s*debug\\(.*\\)\\s*$",
+    "^\\s*\\.\\.\\.\\s*$",
+]
+
+[tool.poe.tasks.test]
+shell = """set -e
+    pyright
+    coverage erase
+    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
+    coverage report -m
+"""
+
+[tool.poe.tasks.publish]
+shell = """set -e
+    git diff --quiet
+    rm -rf dist
+    uv build
+    uv publish
+"""
+
+[tool.pyright]
+include = ["spaces", "tests"]
+exclude = ["spaces/_vendor"]
+pythonVersion = "3.10"
+reportMatchNotExhaustive = "error"
+reportPossiblyUnboundVariable = "error"
+reportUnnecessaryComparison = true
+reportPrivateImportUsage = "information"
+
+[build-system]
+requires = ["uv_build>=0.11.6,<0.12"]
+build-backend = "uv_build"
+
+[tool.uv.build-backend]
+module-name = "spaces"
+module-root = ""

{spaces-0.49b9 → spaces-0.50.dev0}/spaces/__init__.py

@@ -1,6 +1,8 @@
 """
 """
+
 import sys
+import warnings
 from types import FunctionType
 from typing import TYPE_CHECKING
 from typing import Callable
@@ -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:
@@ -50,30 +59,10 @@ def _aoti_compile():
     from .zero.torch.aoti import aoti_compile
     return aoti_compile
 
-def _aoti_compile_and_save():
-    from .zero.torch.aoti import aoti_compile_and_save
-    return aoti_compile_and_save
-
 def _aoti_apply():
     from .zero.torch.aoti import aoti_apply
     return aoti_apply
 
-def _aoti_patch():
-    from .zero.torch.aoti import aoti_patch
-    return aoti_patch
-
-def _aoti_load():
-    from .zero.torch.aoti import aoti_load
-    return aoti_load
-
-def _aoti_load_call_source():
-    from .zero.torch.aoti import aoti_load_call_source
-    return aoti_load_call_source
-
-def _aoti_load_from_package_dir():
-    from .zero.torch.aoti import aoti_load_from_package_dir
-    return aoti_load_from_package_dir
-
 def _aoti_blocks_load():
     from .zero.torch.aoti import aoti_blocks_load
     return aoti_blocks_load
@@ -81,24 +70,14 @@ def _aoti_blocks_load():
 
 aoti_capture = LazyImported(_aoti_capture)
 aoti_compile = LazyImported(_aoti_compile)
-aoti_compile_and_save = LazyImported(_aoti_compile_and_save)
 aoti_apply = LazyImported(_aoti_apply)
-aoti_patch = LazyImported(_aoti_patch)
-aoti_load = LazyImported(_aoti_load)
-aoti_load_call_source = LazyImported(_aoti_load_call_source)
-aoti_load_from_package_dir = LazyImported(_aoti_load_from_package_dir)
 aoti_blocks_load = LazyImported(_aoti_blocks_load)
 
 
 if TYPE_CHECKING:
     from .zero.torch.aoti import aoti_capture
     from .zero.torch.aoti import aoti_compile
-    from .zero.torch.aoti import aoti_compile_and_save
     from .zero.torch.aoti import aoti_apply
-    from .zero.torch.aoti import aoti_patch
-    from .zero.torch.aoti import aoti_load
-    from .zero.torch.aoti import aoti_load_call_source
-    from .zero.torch.aoti import aoti_load_from_package_dir
     from .zero.torch.aoti import aoti_blocks_load
 
 
@@ -109,11 +88,6 @@ __all__ = [
     'enable_gradio_auto_wrap',
     'aoti_capture',
     'aoti_compile',
-    'aoti_compile_and_save',
     'aoti_apply',
-    'aoti_patch',
-    'aoti_load',
-    'aoti_load_call_source',
-    'aoti_load_from_package_dir',
     'aoti_blocks_load',
 ]

spaces-0.50.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.49b9 → spaces-0.50.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.49b9 → spaces-0.50.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.49b9 → spaces-0.50.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
@@ -55,6 +60,7 @@ from .types import ApiFetchContentsResponseSuccess
 from .types import ReloadRegion
 from .types import ReloadOperationError
 from .types import ReloadOperationException
+from .types import ReloadOperationFile
 from .types import ReloadOperationObject
 from .types import ReloadOperationRun
 from .types import ReloadOperationUI
@@ -62,7 +68,6 @@ from .types import ReloadOperationUI
 
 class ReloadRun(NamedTuple):
     activity: EventSource
-    thread: threading.Thread
 
 
 class ReloadServer:
@@ -115,16 +120,22 @@ class ReloadServer:
             return  ApiCreateReloadResponseError(status='alreadyReloading')
 
         filepath = (Path.cwd() / req.filepath).resolve()
-        if not filepath.is_relative_to(Path.cwd()) or (code_file := self.registry.get(str(filepath))) is None:
+        if not filepath.is_relative_to(Path.cwd()):
             return  ApiCreateReloadResponseError(status='fileNotFound')
 
-        Path(req.filepath).write_text(req.contents)
+        created = not filepath.exists()
+        filepath.write_text(req.contents)
         activity = EventSource(save_history=True) # TODO: Generic EventSource[ApiGetReloadEventSourceMessage]
-        code_file.activity = activity
+        reload_id = str(uuid4()) if req.reloadId is None else req.reloadId
+        self.reload_runs[reload_id] = ReloadRun(activity)
 
+        if (code_file := self.registry.get(str(filepath))) is None:
+            activity.emit(ApiGetReloadEventSourceData(data=ReloadOperationFile(kind='file', created=created)))
+            activity.emit(None)
+            return ApiCreateReloadResponseSuccess(status='created', reloadId=reload_id)
+
+        code_file.activity = activity
         thread = create_thread(self.run_reload, code_file)
-        reload_id = str(uuid4()) if req.reloadId is None else req.reloadId
-        self.reload_runs[reload_id] = ReloadRun(activity, thread)
         self.active_reload_id = reload_id
         thread.start()
 
@@ -149,7 +160,7 @@ class ReloadServer:
 
         reload_id = req.reloadId
         if (run := self.reload_runs.get(reload_id, None)) is None:
-            raise HTTPException(404, f"{reload_id=} not found")
+            raise HTTPException(204, f"{reload_id=} not found")
 
         queue = Queue()
         run.activity.register(queue.put, apply_history=True)
@@ -166,7 +177,7 @@ class ReloadServer:
             for data in activity_stream(queue):
                 yield data.model_dump_json()
 
-        return EventSourceResponse(event_source_stream())
+        return EventSourceResponse(event_source_stream(), ping=5)
 
 
     def run_reload(self, code_file: CodeFile):
@@ -211,7 +222,7 @@ def serialize_code_operation(cf_operation: CodeFileOperation):
         if isinstance(cf_operation, AddOperation):
             kind = 'add'
         elif isinstance(cf_operation, UpdateOperation):
-            if not isinstance(defn, FunctionDefinition):
+            if not isinstance(defn, (ClassDefinition, FunctionDefinition)):
                 return None
             kind = 'update'
         else:

{spaces-0.49b9 → spaces-0.50.dev0}/spaces/reloading/types.py

@@ -43,6 +43,11 @@ class ReloadOperationUI(BaseModel):
     updated: bool
 
 
+class ReloadOperationFile(BaseModel):
+    kind: Literal['file']
+    created: bool
+
+
 class ApiCreateReloadRequest(BaseModel):
     filepath: str
     contents: str
@@ -72,6 +77,7 @@ class ApiGetReloadEventSourceData(BaseModel):
         | ReloadOperationObject \
         | ReloadOperationRun \
         | ReloadOperationUI \
+        | ReloadOperationFile \
 
 
 class ApiGetStatusRequest(BaseModel):

{spaces-0.49b9 → spaces-0.50.dev0}/spaces/reloading/types.ts

@@ -39,7 +39,8 @@ export interface ApiGetReloadEventSourceData {
     | ReloadOperationException
     | ReloadOperationObject
     | ReloadOperationRun
-    | ReloadOperationUI;
+    | ReloadOperationUI
+    | ReloadOperationFile;
 }
 export interface ReloadOperationError {
   kind: "error";
@@ -73,6 +74,10 @@ export interface ReloadOperationUI {
   kind: "ui";
   updated: boolean;
 }
+export interface ReloadOperationFile {
+  kind: "file";
+  created: boolean;
+}
 export interface ApiGetReloadRequest {
   reloadId: string;
 }