refactor: complete hard switch to httpx2

Remove the try/except dual-import blocks; direct 'import httpx2'
everywhere. pyproject: httpx2>=2.12.0 as the only runtime HTTP dep;
requires-python bumped to >=3.10 (httpx2's floor; 3.8/3.9 are EOL).

Test infra: vcrpy and respx only patch/validate httpx 0.x, so add
tests/_vcr_httpx2_stubs.py (vcr send-stubs adapted for httpx2, wired
via a conftest autouse fixture) and tests/_mock_router.py (a minimal
respx-compatible Router, natively typed for httpx2, replacing respx).
Full suite: 158 passed, 6 skipped (skips need a real API token).

Refs: #470

Author: ProgrammerPlus1998

pyproject.toml

@@ -9,10 +9,9 @@ description = "Python client for Replicate"
 readme = "README.md"
 license = { file = "LICENSE" }
 authors = [{ name = "Replicate, Inc." }]
-requires-python = ">=3.8"
+requires-python = ">=3.10"
 dependencies = [
-    "httpx>=0.21.0,<1",
-    "httpx2>=2.12.0; python_version >= \"3.10\"",
+    "httpx2>=2.12.0",
     "packaging",
     "pydantic>1.10.7",
     "typing_extensions>=4.5.0",
@@ -29,7 +28,6 @@ dev-dependencies = [
     "pyright>=1.1.358",
     "pytest-asyncio>=0.23.6",
     "pytest-recording>=0.13.1",
-    "respx>=0.21.1",
     "ruff>=0.3.7",
 ]
 

replicate/client.py

@@ -16,10 +16,7 @@
     Union,
 )
 
-try:
-    import httpx2 as httpx
-except ImportError:
-    import httpx
+import httpx2
 from typing_extensions import Unpack
 
 from replicate.__about__ import __version__
@@ -43,15 +40,15 @@
 class Client:
     """A Replicate API client library"""
 
-    __client: Optional[httpx.Client] = None
-    __async_client: Optional[httpx.AsyncClient] = None
+    __client: Optional[httpx2.Client] = None
+    __async_client: Optional[httpx2.AsyncClient] = None
 
     def __init__(
         self,
         api_token: Optional[str] = None,
         *,
         base_url: Optional[str] = None,
-        timeout: Optional[httpx.Timeout] = None,
+        timeout: Optional[httpx2.Timeout] = None,
         **kwargs,
     ) -> None:
         super().__init__()
@@ -64,10 +61,10 @@ def __init__(
         self.poll_interval = float(os.environ.get("REPLICATE_POLL_INTERVAL", "0.5"))
 
     @property
-    def _client(self) -> httpx.Client:
+    def _client(self) -> httpx2.Client:
         if not self.__client:
             self.__client = _build_httpx_client(
-                httpx.Client,
+                httpx2.Client,
                 self._api_token,
                 self._base_url,
                 self._timeout,
@@ -76,24 +73,24 @@ def _client(self) -> httpx.Client:
         return self.__client  # type: ignore[return-value]
 
     @property
-    def _async_client(self) -> httpx.AsyncClient:
+    def _async_client(self) -> httpx2.AsyncClient:
         if not self.__async_client:
             self.__async_client = _build_httpx_client(
-                httpx.AsyncClient,
+                httpx2.AsyncClient,
                 self._api_token,
                 self._base_url,
                 self._timeout,
                 **self._client_kwargs,
             )  # type: ignore[assignment]
         return self.__async_client  # type: ignore[return-value]
 
-    def _request(self, method: str, path: str, **kwargs) -> httpx.Response:
+    def _request(self, method: str, path: str, **kwargs) -> httpx2.Response:
         resp = self._client.request(method, path, **kwargs)
         _raise_for_status(resp)
 
         return resp
 
-    async def _async_request(self, method: str, path: str, **kwargs) -> httpx.Response:
+    async def _async_request(self, method: str, path: str, **kwargs) -> httpx2.Response:
         resp = await self._async_client.request(method, path, **kwargs)
         _raise_for_status(resp)
 
@@ -222,8 +219,8 @@ async def async_stream(
         return async_stream(self, ref, input, use_file_output=use_file_output, **params)
 
 
-# Adapted from https://github.com/encode/httpx/issues/108#issuecomment-1132753155
-class RetryTransport(httpx.AsyncBaseTransport, httpx.BaseTransport):
+# Adapted from https://github.com/encode/httpx2/issues/108#issuecomment-1132753155
+class RetryTransport(httpx2.AsyncBaseTransport, httpx2.BaseTransport):
     """A custom HTTP transport that automatically retries requests using an exponential backoff strategy
     for specific HTTP status codes and request methods.
     """
@@ -240,7 +237,7 @@ class RetryTransport(httpx.AsyncBaseTransport, httpx.BaseTransport):
 
     def __init__(  # pylint: disable=too-many-arguments
         self,
-        wrapped_transport: Union[httpx.BaseTransport, httpx.AsyncBaseTransport],
+        wrapped_transport: Union[httpx2.BaseTransport, httpx2.AsyncBaseTransport],
         *,
         max_attempts: int = 10,
         max_backoff_wait: float = MAX_BACKOFF_WAIT,
@@ -272,7 +269,7 @@ def __init__(  # pylint: disable=too-many-arguments
         self.max_backoff_wait = max_backoff_wait
 
     def _calculate_sleep(
-        self, attempts_made: int, headers: Union[httpx.Headers, Mapping[str, str]]
+        self, attempts_made: int, headers: Union[httpx2.Headers, Mapping[str, str]]
     ) -> float:
         retry_after_header = (headers.get("Retry-After") or "").strip()
         if retry_after_header:
@@ -292,7 +289,7 @@ def _calculate_sleep(
         total_backoff = backoff + jitter
         return min(total_backoff, self.max_backoff_wait)
 
-    def handle_request(self, request: httpx.Request) -> httpx.Response:
+    def handle_request(self, request: httpx2.Request) -> httpx2.Response:
         response = self._wrapped_transport.handle_request(request)  # type: ignore
 
         if request.method not in self.retryable_methods:
@@ -318,7 +315,7 @@ def handle_request(self, request: httpx.Request) -> httpx.Response:
             attempts_made += 1
             remaining_attempts -= 1
 
-    async def handle_async_request(self, request: httpx.Request) -> httpx.Response:
+    async def handle_async_request(self, request: httpx2.Request) -> httpx2.Response:
         response = await self._wrapped_transport.handle_async_request(request)  # type: ignore
 
         if request.method not in self.retryable_methods:
@@ -366,12 +363,12 @@ def _get_api_token_from_environment() -> Optional[str]:
 
 
 def _build_httpx_client(
-    client_type: Type[Union[httpx.Client, httpx.AsyncClient]],
+    client_type: Type[Union[httpx2.Client, httpx2.AsyncClient]],
     api_token: Optional[str] = None,
     base_url: Optional[str] = None,
-    timeout: Optional[httpx.Timeout] = None,
+    timeout: Optional[httpx2.Timeout] = None,
     **kwargs,
-) -> Union[httpx.Client, httpx.AsyncClient]:
+) -> Union[httpx2.Client, httpx2.AsyncClient]:
     headers = kwargs.pop("headers", {})
     if "User-Agent" not in headers:
         headers["User-Agent"] = f"replicate-python/{__version__}"
@@ -386,14 +383,14 @@ def _build_httpx_client(
     if base_url == "":
         base_url = "https://api.replicate.com"
 
-    timeout = timeout or httpx.Timeout(
+    timeout = timeout or httpx2.Timeout(
         5.0, read=30.0, write=30.0, connect=5.0, pool=10.0
     )
 
     transport = kwargs.pop("transport", None) or (
-        httpx.HTTPTransport()
-        if client_type is httpx.Client
-        else httpx.AsyncHTTPTransport()
+        httpx2.HTTPTransport()
+        if client_type is httpx2.Client
+        else httpx2.AsyncHTTPTransport()
     )
 
     return client_type(
@@ -405,6 +402,6 @@ def _build_httpx_client(
     )
 
 
-def _raise_for_status(resp: httpx.Response) -> None:
+def _raise_for_status(resp: httpx2.Response) -> None:
     if 400 <= resp.status_code < 600:
         raise ReplicateError.from_response(resp)

replicate/exceptions.py

@@ -1,9 +1,6 @@
 from typing import TYPE_CHECKING, Optional
 
-try:
-    import httpx2 as httpx
-except ImportError:
-    import httpx
+import httpx2
 
 if TYPE_CHECKING:
     from replicate.prediction import Prediction
@@ -60,7 +57,7 @@ def __init__(  # pylint: disable=too-many-arguments
         self.instance = instance
 
     @classmethod
-    def from_response(cls, response: httpx.Response) -> "ReplicateError":
+    def from_response(cls, response: httpx2.Response) -> "ReplicateError":
         """Create a ReplicateError from an HTTP response."""
 
         try:

replicate/helpers.py

@@ -6,7 +6,7 @@
 from types import GeneratorType
 from typing import TYPE_CHECKING, Any, AsyncIterator, Iterator, Optional
 
-import httpx
+import httpx2
 
 if TYPE_CHECKING:
     from replicate.client import Client
@@ -115,7 +115,7 @@ def base64_encode_file(file: io.IOBase) -> str:
     return f"data:{mime_type};base64,{encoded_body}"
 
 
-class FileOutput(httpx.SyncByteStream, httpx.AsyncByteStream):
+class FileOutput(httpx2.SyncByteStream, httpx2.AsyncByteStream):
     """
     An object that can be used to read the contents of an output file
     created by running a Replicate model.

replicate/prediction.py

@@ -16,10 +16,7 @@
     overload,
 )
 
-try:
-    import httpx2 as httpx
-except ImportError:
-    import httpx
+import httpx2
 from typing_extensions import NotRequired, TypedDict, Unpack
 
 from replicate.exceptions import ModelError, ReplicateError
@@ -629,7 +626,7 @@ async def async_cancel(self, id: str) -> Prediction:
 
 class CreatePredictionRequestParams(TypedDict):
     headers: NotRequired[Optional[dict]]
-    timeout: NotRequired[Optional[httpx.Timeout]]
+    timeout: NotRequired[Optional[httpx2.Timeout]]
 
 
 def _create_prediction_request_params(
@@ -646,9 +643,9 @@ def _create_prediction_request_params(
 
 def _create_prediction_timeout(
     *, wait: Optional[Union[int, bool]] = None
-) -> Union[httpx.Timeout, None]:
+) -> Union[httpx2.Timeout, None]:
     """
-    Returns an `httpx.Timeout` instances appropriate for the optional
+    Returns an `httpx2.Timeout` instances appropriate for the optional
     `Prefer: wait=x` header that can be provided with the request. This
     will ensure that we give the server enough time to respond with
     a partial prediction in the event that the request times out.
@@ -658,7 +655,7 @@ def _create_prediction_timeout(
         return None
 
     read_timeout = 60.0 if isinstance(wait, bool) else wait
-    return httpx.Timeout(5.0, read=read_timeout + 0.5)
+    return httpx2.Timeout(5.0, read=read_timeout + 0.5)
 
 
 def _create_prediction_headers(

replicate/stream.py

@@ -10,10 +10,7 @@
     Union,
 )
 
-try:
-    import httpx2 as httpx
-except ImportError:
-    import httpx
+import httpx2
 from typing_extensions import Unpack
 
 from replicate import identifier
@@ -67,13 +64,13 @@ class EventSource:
     """
 
     client: "Client"
-    response: "httpx.Response"
+    response: "httpx2.Response"
     use_file_output: bool
 
     def __init__(
         self,
         client: "Client",
-        response: "httpx.Response",
+        response: "httpx2.Response",
         *,
         use_file_output: Optional[bool] = True,
     ) -> None:

replicate/webhook.py

@@ -11,10 +11,7 @@
 from replicate.resource import Namespace, Resource
 
 if TYPE_CHECKING:
-    try:
-    import httpx2 as httpx
-except ImportError:
-    import httpx
+    import httpx2
 
 
 class WebhookSigningSecret(Resource):
@@ -94,7 +91,7 @@ async def async_secret(self) -> WebhookSigningSecret:
     @overload
     @staticmethod
     def validate(
-        request: "httpx.Request",
+        request: "httpx2.Request",
         secret: WebhookSigningSecret,
         tolerance: Optional[int] = None,
     ) -> bool: ...
@@ -110,7 +107,7 @@ def validate(
 
     @staticmethod
     def validate(  # type: ignore # pylint: disable=too-many-branches,too-many-locals
-        request: Optional["httpx.Request"] = None,
+        request: Optional["httpx2.Request"] = None,
         headers: Optional[Dict[str, str]] = None,
         body: Optional[str] = None,
         secret: Optional[WebhookSigningSecret] = None,
@@ -120,7 +117,7 @@ def validate(  # type: ignore # pylint: disable=too-many-branches,too-many-local
         Validate the signature from an incoming webhook request using the provided secret.
 
         Args:
-            request (httpx.Request): The request object.
+            request (httpx2.Request): The request object.
             headers (Dict[str, str]): The request headers.
             body (str): The request body.
             secret (WebhookSigningSecret): The webhook signing secret.