vercel-queue-bundle 0.8.0__tar.gz → 0.9.0__tar.gz

{vercel_queue_bundle-0.8.0 → vercel_queue_bundle-0.9.0}/PKG-INFO

@@ -1,15 +1,15 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.5
 Name: vercel-queue-bundle
-Version: 0.8.0
+Version: 0.9.0
 Summary: Vercel Queue client for Python
 License-Expression: MIT
 License-File: LICENSE
 License-File: vercel/queue/_vendor/LICENSE.python-multipart.txt
 Requires-Python: >=3.10
-Requires-Dist: vercel-headers-bundle>=0.7.1
-Requires-Dist: vercel-internal-core-bundle<0.2.0,>=0.1.2
-Requires-Dist: vercel-internal-shared-vendored-deps>=0.1.1
-Requires-Dist: vercel-oidc-bundle>=0.8.0
+Requires-Dist: vercel-headers-bundle>=0.7.2
+Requires-Dist: vercel-internal-core-bundle<0.3.0,>=0.2.0
+Requires-Dist: vercel-internal-shared-vendored-deps>=0.1.2
+Requires-Dist: vercel-oidc-bundle>=0.9.0
 Provides-Extra: devserver
 Requires-Dist: uvicorn; extra == 'devserver'
 Provides-Extra: trio
@@ -29,7 +29,7 @@ designed for seamless integration with Vercel deployments.
 
 ## Features
 
-- **Simple API**: `send`, `subscribe`, and `asgi_app` cover standard workflows.
+- **Simple API**: `send`, `subscribe`, and `poll` cover standard workflows.
 - **Automatic Triggering on Vercel**: Vercel invokes your function when messages are ready.
 - **Works Anywhere**: `send`, decorated subscribers, and manual `poll` loops work on Vercel, self-hosted workers, and locally.
 - **Sync and Async Clients**: Prefer async for applications, use sync for scripts and blocking workers.
@@ -326,6 +326,8 @@ custom queue service URLs, create a `QueueClient` explicitly:
 
 ```python
 # explicit_client.py
+import httpx2
+
 from vercel.queue import ALL_DEPLOYMENTS, QueueClient
 
 queue = QueueClient(
@@ -340,6 +342,12 @@ queue = QueueClient(
 await queue.send("my-topic", {"message": "Hello world"})
 ```
 
+HTTPX2 is the default and the only HTTPX family installed by the SDK. For
+migration, an application that explicitly installs legacy `httpx` may return a
+complete `httpx.Client` or `httpx.AsyncClient` from `http_client_factory`.
+Legacy transport objects must remain inside a legacy client; they cannot be
+mounted in an `httpx2.Client`.
+
 By default queue clients send requests to `https://<region>.vercel-queue.com/`. A custom endpoint
 can be configured by passing a `base_url` keyword argument to the client constructor. The value
 can be a fixed string, a `format()` template containing a `{region}` placeholder, or a callable

{vercel_queue_bundle-0.8.0 → vercel_queue_bundle-0.9.0}/README.md

@@ -9,7 +9,7 @@ designed for seamless integration with Vercel deployments.
 
 ## Features
 
-- **Simple API**: `send`, `subscribe`, and `asgi_app` cover standard workflows.
+- **Simple API**: `send`, `subscribe`, and `poll` cover standard workflows.
 - **Automatic Triggering on Vercel**: Vercel invokes your function when messages are ready.
 - **Works Anywhere**: `send`, decorated subscribers, and manual `poll` loops work on Vercel, self-hosted workers, and locally.
 - **Sync and Async Clients**: Prefer async for applications, use sync for scripts and blocking workers.
@@ -306,6 +306,8 @@ custom queue service URLs, create a `QueueClient` explicitly:
 
 ```python
 # explicit_client.py
+import httpx2
+
 from vercel.queue import ALL_DEPLOYMENTS, QueueClient
 
 queue = QueueClient(
@@ -320,6 +322,12 @@ queue = QueueClient(
 await queue.send("my-topic", {"message": "Hello world"})
 ```
 
+HTTPX2 is the default and the only HTTPX family installed by the SDK. For
+migration, an application that explicitly installs legacy `httpx` may return a
+complete `httpx.Client` or `httpx.AsyncClient` from `http_client_factory`.
+Legacy transport objects must remain inside a legacy client; they cannot be
+mounted in an `httpx2.Client`.
+
 By default queue clients send requests to `https://<region>.vercel-queue.com/`. A custom endpoint
 can be configured by passing a `base_url` keyword argument to the client constructor. The value
 can be a fixed string, a `format()` template containing a `{region}` placeholder, or a callable

{vercel_queue_bundle-0.8.0 → vercel_queue_bundle-0.9.0}/pyproject.toml

@@ -20,10 +20,10 @@ path = "hatch_build.py"
 
 [tool.vercel.release.dependencies]
 dependencies = [
-    "vercel-headers-bundle>=0.7.1",
-    "vercel-internal-core-bundle>=0.1.2,<0.2.0",
-    "vercel-oidc-bundle>=0.8.0",
-    "vercel-internal-shared-vendored-deps>=0.1.1",
+    "vercel-headers-bundle>=0.7.2",
+    "vercel-internal-core-bundle>=0.2.0,<0.3.0",
+    "vercel-oidc-bundle>=0.9.0",
+    "vercel-internal-shared-vendored-deps>=0.1.2",
 ]
 
 [project.optional-dependencies]
@@ -202,6 +202,7 @@ max-statements-in-try = 10
 "asyncio.wait_for".msg = "prefer-anyio-primitives: use anyio fail_after or move_on_after instead."
 
 [tool.pytest.ini_options]
+pythonpath = ["../.."]
 addopts = "--no-header --capture=tee-sys"
 asyncio_mode = "strict"
 testpaths = ["tests"]

{vercel_queue_bundle-0.8.0 → vercel_queue_bundle-0.9.0}/vercel/queue/_internal/api_common.py

@@ -3,7 +3,6 @@
 
 from .. import version as _version
 from . import (
-    asgi as _asgi,
     config as _config,
     names as _names,
     transports as _transports,
@@ -25,7 +24,6 @@ Handoff = _types.Handoff
 Message = _types.Message
 MessageID = _types.MessageID
 MessageMetadata = _types.MessageMetadata
-QueueClientAsgiApp = _asgi.QueueClientAsgiApp
 QueueDirective = _types.QueueDirective
 RawJsonTransport = _transports.RawJsonTransport
 ReceiptHandle = _types.ReceiptHandle
@@ -38,7 +36,6 @@ Topic = _types.Topic
 TopicPattern = _types.TopicPattern
 TypedJsonTransport = _transports.TypedJsonTransport
 __version__ = _version.__version__
-asgi_app = _asgi.asgi_app
 sanitize_name = _names.sanitize_name
 
 # Only add public symbols to __all__; internal helpers must stay unexported.
@@ -75,7 +72,6 @@ __all__ = (
     "MessageUnavailableError",
     "PayloadValidationError",
     "ProtocolError",
-    "QueueClientAsgiApp",
     "QueueDirective",
     "QueueError",
     "QueueSubscriber",
@@ -99,7 +95,6 @@ __all__ = (
     "UnauthorizedError",
     "UnhandledMessageError",
     "__version__",
-    "asgi_app",
     "get_subscriptions",
     "sanitize_name",
     "subscribe",

{vercel_queue_bundle-0.8.0 → vercel_queue_bundle-0.9.0}/vercel/queue/_internal/client.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, Any, Generic, TypeVar, cast, overload
+from typing import Any, Generic, TypeVar, cast, overload
 
 import warnings
 from collections.abc import (
@@ -112,10 +112,6 @@ T = TypeVar("T")
 QUEUE_API_PATH = "/api/v3/topic"
 
 
-if TYPE_CHECKING:
-    from .asgi import QueueClientAsgiApp
-
-
 class _DuplicateMessageRedirect(Exception):  # noqa: N818
     def __init__(self, message_id: MessageID) -> None:
         self.message_id = message_id
@@ -999,12 +995,6 @@ class QueueClient(BaseQueueClient):
         """
         await retry_message_after_async(message, delay, self._extend_lease)
 
-    def asgi_app(self) -> QueueClientAsgiApp:
-        """Return an ASGI push-callback app backed by this client."""
-        from .asgi import QueueClientAsgiApp  # noqa: PLC0415
-
-        return QueueClientAsgiApp(self)
-
 
 @dataclass(frozen=True, kw_only=True)
 class _LeaseTarget:

{vercel_queue_bundle-0.8.0 → vercel_queue_bundle-0.9.0}/vercel/queue/_internal/devserver.py

@@ -12,29 +12,16 @@ import json
 import signal
 import threading
 import time
-from collections.abc import Callable, Iterator, Mapping
-from dataclasses import dataclass
+from collections.abc import Callable, Iterator
+
+from vercel.internal._vendor import anyio
+from vercel.internal._vendor.anyio import from_thread
 
 from ..embedded import create_embedded_queue_app
-from .asgi import QueueClientAsgiApp, asgi_app
-from .client import QueueClient
-from .config import CURRENT_DEPLOYMENT, BaseUrl, DeploymentOption
 from .embedded import EmbeddedQueueDevServer
-from .http import AsyncHttpClientFactory
-from .types import Duration
-
-
-@dataclass(frozen=True, kw_only=True)
-class QueueClientAsgiDevServer:
-    """Running queue client ASGI dev server."""
-
-    base_url: str
-    app: QueueClientAsgiApp
-    _server: Any
-    _thread: threading.Thread
 
-    def is_running(self) -> bool:
-        return self._thread.is_alive() and not self._server.should_exit
+_GRACEFUL_SHUTDOWN_TIMEOUT_SECONDS = 5.0
+_SERVER_STOP_TIMEOUT_MARGIN_SECONDS = 1.0
 
 
 @contextlib.contextmanager
@@ -55,8 +42,9 @@ def embedded_queue_dev_server(
         log_level="warning",
         lifespan="off",
         ws="none",
+        timeout_graceful_shutdown=_GRACEFUL_SHUTDOWN_TIMEOUT_SECONDS,
     )
-    server = uvicorn.Server(config)
+    server = _cancellable_server(uvicorn, config)
     thread = threading.Thread(target=_profiled_server_run(server, profile), daemon=True)
     thread.start()
     _wait_for_server(server)
@@ -69,64 +57,15 @@ def embedded_queue_dev_server(
             _thread=thread,
         )
     finally:
-        server.should_exit = True
-        thread.join(timeout=5)
-        if thread.is_alive():
-            raise RuntimeError("embedded queue dev server did not stop")
-        app.state.close()
-
-
-@contextlib.contextmanager
-def queue_client_asgi_dev_server(  # noqa: PLR0913
-    *,
-    client: QueueClient | None = None,
-    host: str = "127.0.0.1",
-    port: int = 0,
-    token: str | None = None,
-    region: str | None = None,
-    base_url: BaseUrl | None = None,
-    deployment: DeploymentOption = CURRENT_DEPLOYMENT,
-    headers: Mapping[str, str] | None = None,
-    timeout: Duration | None = 10.0,
-    http_client_factory: AsyncHttpClientFactory | None = None,
-    profile: str | None = None,
-) -> Iterator[QueueClientAsgiDevServer]:
-    """Run a queue client ASGI callback app on a localhost HTTP port."""
-    uvicorn = _uvicorn()
-    app = asgi_app(
-        client=client,
-        token=token,
-        region=region,
-        base_url=base_url,
-        deployment=deployment,
-        headers=headers,
-        timeout=timeout,
-        http_client_factory=http_client_factory,
-    )
-    config = uvicorn.Config(
-        app,
-        host=host,
-        port=port,
-        log_level="warning",
-        lifespan="on",
-        ws="none",
-    )
-    server = uvicorn.Server(config)
-    thread = threading.Thread(target=_profiled_server_run(server, profile), daemon=True)
-    thread.start()
-    _wait_for_server(server, "queue client ASGI dev server")
-    try:
-        yield QueueClientAsgiDevServer(
-            base_url=f"http://{host}:{_server_port(server)}",
-            app=app,
-            _server=server,
-            _thread=thread,
-        )
-    finally:
-        server.should_exit = True
-        thread.join(timeout=5)
-        if thread.is_alive():
-            raise RuntimeError("queue client ASGI dev server did not stop")
+        try:
+            _stop_server(
+                server,
+                thread,
+                "embedded queue dev server",
+                timeout=_GRACEFUL_SHUTDOWN_TIMEOUT_SECONDS,
+            )
+        finally:
+            app.state.close()
 
 
 def main(argv: list[str] | None = None) -> int:
@@ -181,6 +120,52 @@ def _wait_for_server(server: Any, name: str = "embedded queue dev server") -> No
         raise RuntimeError(f"{name} did not start")
 
 
+def _stop_server(
+    server: Any,
+    thread: threading.Thread,
+    name: str,
+    *,
+    timeout: float,
+) -> None:
+    server.should_exit = True
+    thread.join(timeout=timeout + _SERVER_STOP_TIMEOUT_MARGIN_SECONDS)
+    if thread.is_alive():
+        server.force_exit = True
+        server.cancel()
+        thread.join(timeout=timeout)
+    if thread.is_alive():
+        raise RuntimeError(f"{name} did not stop")
+
+
+def _cancellable_server(uvicorn: Any, config: Any) -> Any:
+    class CancellableServer(uvicorn.Server):
+        _cancel_scope: anyio.CancelScope | None = None
+        _portal: from_thread.BlockingPortal | None = None
+
+        def run(self, sockets: list[Any] | None = None) -> None:
+            backend_options: dict[str, Any] = {}
+            get_loop_factory = getattr(self.config, "get_loop_factory", None)
+            if get_loop_factory is not None:
+                backend_options["loop_factory"] = get_loop_factory()
+            else:
+                self.config.setup_event_loop()
+            anyio.run(self._run, sockets, backend_options=backend_options)
+
+        async def _run(self, sockets: list[Any] | None) -> None:
+            async with from_thread.BlockingPortal() as self._portal:
+                with anyio.CancelScope() as self._cancel_scope:
+                    await self.serve(sockets=sockets)
+
+        def cancel(self) -> None:
+            if self._portal is not None and self._cancel_scope is not None:
+                try:
+                    self._portal.start_task_soon(self._cancel_scope.cancel)
+                except RuntimeError:
+                    pass
+
+    return CancellableServer(config)
+
+
 def _server_port(server: Any) -> int:
     for asyncio_server in server.servers:
         sockets = asyncio_server.sockets or ()

{vercel_queue_bundle-0.8.0 → vercel_queue_bundle-0.9.0}/vercel/queue/_internal/embedded.py

@@ -31,7 +31,7 @@ from tempfile import TemporaryDirectory
 from urllib.parse import unquote
 
 from vercel.internal._vendor import anyio
-from vercel.internal._vendor import httpx
+import vercel.internal._vendor.httpx2 as httpx
 from vercel.internal._vendor.anyio.abc import TaskGroup
 
 from .client import QueueClient

{vercel_queue_bundle-0.8.0 → vercel_queue_bundle-0.9.0}/vercel/queue/_internal/http.py

@@ -20,9 +20,14 @@ from email.utils import parsedate_to_datetime
 from threading import Lock
 from urllib.parse import urljoin, urlsplit
 
-from vercel.internal._vendor import httpx
+import vercel.internal._vendor.httpx2 as httpx
 from vercel.internal._vendor.anyio.lowlevel import get_async_backend
 
+from vercel._internal.core.http._compat import (
+    response_not_read_errors,
+    transport_errors,
+)
+
 from .asynctools import iter_bytes_async
 from .config import resolve_token, resolve_token_async
 from .constants import HEADER_RETRY_AFTER
@@ -30,7 +35,7 @@ from .errors import CommunicationError
 from .log import content_type, debug_enabled, debug_log, redact_text, safe_header_names, safe_url
 from .types import Duration, Headers, RawHeaders, RequestContent, duration_to_float_seconds
 
-_httpx_logger = logging.getLogger("httpx")
+_httpx_loggers = (logging.getLogger("httpx2"), logging.getLogger("httpx"))
 
 
 @dataclass
@@ -296,7 +301,7 @@ class _SyncResponse:
 async def response_text(response: AsyncHttpResponse) -> str:
     try:
         return response.text
-    except httpx.ResponseNotRead:
+    except response_not_read_errors():
         body = bytearray()
         async for chunk in response.aiter_bytes():
             body.extend(chunk)
@@ -452,7 +457,7 @@ class SyncQueueRuntime(BaseQueueRuntime):
         client = self._acquire_client()
         try:
             response = client.request(method, url, **kwargs)
-        except httpx.TransportError as exc:
+        except transport_errors() as exc:
             _log_http_error(method, url, exc)
             raise CommunicationError(str(exc)) from exc
         finally:
@@ -480,7 +485,7 @@ class SyncQueueRuntime(BaseQueueRuntime):
             ) as response:
                 _log_http_response(method, resolved_url, response.status_code, response.headers)
                 yield _SyncResponse(response)
-        except httpx.TransportError as exc:
+        except transport_errors() as exc:
             _log_http_error(method, resolved_url, exc)
             raise CommunicationError(str(exc)) from exc
         finally:
@@ -525,7 +530,7 @@ class AsyncQueueRuntime(BaseQueueRuntime):
         key, client = self._acquire_client()
         try:
             response = await client.request(method, url, **kwargs)
-        except httpx.TransportError as exc:
+        except transport_errors() as exc:
             _log_http_error(method, url, exc)
             raise CommunicationError(str(exc)) from exc
         finally:
@@ -553,7 +558,7 @@ class AsyncQueueRuntime(BaseQueueRuntime):
             ) as response:
                 _log_http_response(method, resolved_url, response.status_code, response.headers)
                 yield response
-        except httpx.TransportError as exc:
+        except transport_errors() as exc:
             _log_http_error(method, resolved_url, exc)
             raise CommunicationError(str(exc)) from exc
         finally:
@@ -630,5 +635,7 @@ def _install_httpx_request_log_filter() -> None:
     with _httpx_filter_state.lock:
         if _httpx_filter_state.installed:
             return
-        _httpx_logger.addFilter(_QueueHttpxRequestLogFilter())
+        request_filter = _QueueHttpxRequestLogFilter()
+        for logger in _httpx_loggers:
+            logger.addFilter(request_filter)
         _httpx_filter_state.installed = True

{vercel_queue_bundle-0.8.0 → vercel_queue_bundle-0.9.0}/vercel/queue/_internal/log.py

@@ -40,10 +40,6 @@ def debug_enabled() -> bool:
     return os.environ.get(_DEBUG_ENV) in {"1", "true"}
 
 
-def configure_asgi_logger() -> None:
-    logging.getLogger(_LOGGER_NAME).setLevel(logging.INFO if debug_enabled() else logging.WARNING)
-
-
 def debug_log(event: str, **fields: Any) -> None:
     if not debug_enabled():
         return

{vercel_queue_bundle-0.8.0 → vercel_queue_bundle-0.9.0}/vercel/queue/devserver.py

@@ -4,19 +4,15 @@ from __future__ import annotations
 
 from ._internal.devserver import (
     EmbeddedQueueDevServer,
-    QueueClientAsgiDevServer,
     embedded_queue_dev_server,
     main,
-    queue_client_asgi_dev_server,
 )
 
 # Only add public symbols to __all__; internal helpers must stay unexported.
 __all__ = (
     "EmbeddedQueueDevServer",
-    "QueueClientAsgiDevServer",
     "embedded_queue_dev_server",
     "main",
-    "queue_client_asgi_dev_server",
 )
 
 

{vercel_queue_bundle-0.8.0 → vercel_queue_bundle-0.9.0}/vercel/queue/version.py

@@ -1,3 +1,3 @@
 """Package version metadata."""
 
-__version__ = "0.8.0"
+__version__ = "0.9.0"

vercel_queue_bundle-0.8.0/vercel/queue/_internal/asgi.py

@@ -1,145 +0,0 @@
-from __future__ import annotations
-
-from typing import Any, TypeAlias, TypedDict
-
-import logging
-from collections.abc import AsyncIterator, Awaitable, Callable, Mapping
-
-from vercel.headers import HeadersContext, headers_from_asgi_scope
-
-from .client import QueueClient
-from .config import CURRENT_DEPLOYMENT, BaseUrl, DeploymentOption
-from .errors import ProtocolError
-from .http import AsyncHttpClientFactory
-from .log import configure_asgi_logger, debug_log
-from .types import Duration
-
-logger = logging.getLogger("vercel.queue")
-
-
-class AsgiScope(TypedDict, total=False):
-    type: str
-    method: str
-    headers: list[tuple[bytes, bytes]]
-
-
-AsgiMessage: TypeAlias = dict[str, Any]
-AsgiReceive: TypeAlias = Callable[[], Awaitable[AsgiMessage]]
-AsgiSend: TypeAlias = Callable[[AsgiMessage], Awaitable[None]]
-
-
-class QueueClientAsgiApp:
-    """ASGI push-callback app backed by an async queue client."""
-
-    def __init__(self, client: QueueClient) -> None:
-        configure_asgi_logger()
-        self.client = client
-
-    async def __call__(
-        self,
-        scope: AsgiScope,
-        receive: AsgiReceive,
-        send: AsgiSend,
-    ) -> None:
-        scope_type = scope.get("type")
-        if scope_type == "http":
-            await self._handle_http(scope, receive, send)
-            return
-        if scope_type == "lifespan":
-            await self._handle_lifespan(receive, send)
-            return
-        raise RuntimeError(f"Unsupported ASGI scope type: {scope_type!r}")
-
-    async def _handle_http(
-        self,
-        scope: AsgiScope,
-        receive: AsgiReceive,
-        send: AsgiSend,
-    ) -> None:
-        if scope.get("method") != "POST":
-            await _send_status(send, 405)
-            return
-
-        headers = headers_from_asgi_scope(scope)
-        try:
-            with HeadersContext(headers).use():
-                await self.client.accept_and_handle(
-                    _body_chunks(receive),
-                    headers,
-                )
-        except (ProtocolError, TypeError, ValueError) as exc:
-            debug_log("asgi.bad_request", error=repr(exc))
-            logger.warning("Vercel Queue push callback rejected: %s", exc)
-            await _send_status(send, 400)
-        except Exception as exc:
-            debug_log("asgi.delivery_failure", error=repr(exc))
-            logger.exception("Vercel Queue push callback failed")
-            await _send_status(send, 500)
-        else:
-            await _send_status(send, 204)
-
-    async def _handle_lifespan(self, receive: AsgiReceive, send: AsgiSend) -> None:
-        while True:
-            message = await receive()
-            message_type = message.get("type")
-            if message_type == "lifespan.startup":
-                await send({"type": "lifespan.startup.complete"})
-            elif message_type == "lifespan.shutdown":
-                await send({"type": "lifespan.shutdown.complete"})
-                return
-
-
-def asgi_app(
-    *,
-    client: QueueClient | None = None,
-    token: str | None = None,
-    region: str | None = None,
-    base_url: BaseUrl | None = None,
-    deployment: DeploymentOption = CURRENT_DEPLOYMENT,
-    headers: Mapping[str, str] | None = None,
-    timeout: Duration | None = 10.0,
-    http_client_factory: AsyncHttpClientFactory | None = None,
-) -> QueueClientAsgiApp:
-    """Create an ASGI queue push-callback app."""
-    configure_asgi_logger()
-    resolved_client = client or QueueClient(
-        token=token,
-        region=region,
-        base_url=base_url,
-        deployment=deployment,
-        headers=headers,
-        timeout=timeout,
-        http_client_factory=http_client_factory,
-    )
-    return QueueClientAsgiApp(resolved_client)
-
-
-async def _body_chunks(receive: AsgiReceive) -> AsyncIterator[bytes]:
-    while True:
-        message = await receive()
-        message_type = message.get("type")
-        if message_type == "http.disconnect":
-            raise ValueError("request body disconnected before completion")
-        if message_type != "http.request":
-            raise ValueError(f"unexpected ASGI message: {message_type!r}")
-        body = message.get("body", b"")
-        if body:
-            yield body
-        if not message.get("more_body", False):
-            return
-
-
-async def _send_status(send: AsgiSend, status: int) -> None:
-    headers: list[tuple[bytes, bytes]] = []
-    if status == 405:
-        headers.append((b"allow", b"POST"))
-    await send({
-        "type": "http.response.start",
-        "status": status,
-        "headers": headers,
-    })
-    await send({"type": "http.response.body", "body": b""})
-
-
-# Only add public symbols to __all__; internal helpers must stay unexported.
-__all__ = ("QueueClientAsgiApp", "asgi_app")