feat(client): improve error message for http timeouts

Author: jonathanblade

src/prisma/_async_http.py

@@ -4,15 +4,28 @@
 
 import httpx
 
+from .utils import ExcConverter
 from ._types import Method
+from .errors import HTTPClientTimeoutError
 from .http_abstract import AbstractHTTP, AbstractResponse
 
 __all__ = ('HTTP', 'AsyncHTTP', 'Response', 'client')
 
 
+convert_exc = ExcConverter(
+    {
+        httpx.ConnectTimeout: HTTPClientTimeoutError,
+        httpx.ReadTimeout: HTTPClientTimeoutError,
+        httpx.WriteTimeout: HTTPClientTimeoutError,
+        httpx.PoolTimeout: HTTPClientTimeoutError,
+    }
+)
+
+
 class AsyncHTTP(AbstractHTTP[httpx.AsyncClient, httpx.Response]):
     session: httpx.AsyncClient
 
+    @convert_exc
     @override
     async def download(self, url: str, dest: str) -> None:
         async with self.session.stream('GET', url, timeout=None) as resp:
@@ -21,14 +34,17 @@ async def download(self, url: str, dest: str) -> None:
                 async for chunk in resp.aiter_bytes():
                     fd.write(chunk)
 
+    @convert_exc
     @override
     async def request(self, method: Method, url: str, **kwargs: Any) -> 'Response':
         return Response(await self.session.request(method, url, **kwargs))
 
+    @convert_exc
     @override
     def open(self) -> None:
         self.session = httpx.AsyncClient(**self.session_kwargs)
 
+    @convert_exc
     @override
     async def close(self) -> None:
         if self.should_close():

src/prisma/_constants.py

@@ -1,10 +1,19 @@
-from typing import Dict
+from typing import Any, Dict
 from datetime import timedelta
 
+import httpx
+
 DEFAULT_CONNECT_TIMEOUT: timedelta = timedelta(seconds=10)
 DEFAULT_TX_MAX_WAIT: timedelta = timedelta(milliseconds=2000)
 DEFAULT_TX_TIMEOUT: timedelta = timedelta(milliseconds=5000)
 
+DEFAULT_HTTP_LIMITS: httpx.Limits = httpx.Limits(max_connections=1000)
+DEFAULT_HTTP_TIMEOUT: httpx.Timeout = httpx.Timeout(30)
+DEFAULT_HTTP_CONFIG: Dict[str, Any] = {
+    'limits': DEFAULT_HTTP_LIMITS,
+    'timeout': DEFAULT_HTTP_TIMEOUT,
+}
+
 # key aliases to transform query arguments to make them more pythonic
 QUERY_BUILDER_ALIASES: Dict[str, str] = {
     'startswith': 'startsWith',

src/prisma/_sync_http.py

@@ -3,15 +3,28 @@
 
 import httpx
 
+from .utils import ExcConverter
 from ._types import Method
+from .errors import HTTPClientTimeoutError
 from .http_abstract import AbstractHTTP, AbstractResponse
 
 __all__ = ('HTTP', 'SyncHTTP', 'Response', 'client')
 
 
+convert_exc = ExcConverter(
+    {
+        httpx.ConnectTimeout: HTTPClientTimeoutError,
+        httpx.ReadTimeout: HTTPClientTimeoutError,
+        httpx.WriteTimeout: HTTPClientTimeoutError,
+        httpx.PoolTimeout: HTTPClientTimeoutError,
+    }
+)
+
+
 class SyncHTTP(AbstractHTTP[httpx.Client, httpx.Response]):
     session: httpx.Client
 
+    @convert_exc
     @override
     def download(self, url: str, dest: str) -> None:
         with self.session.stream('GET', url, timeout=None) as resp:
@@ -20,14 +33,17 @@ def download(self, url: str, dest: str) -> None:
                 for chunk in resp.iter_bytes():
                     fd.write(chunk)
 
+    @convert_exc
     @override
     def request(self, method: Method, url: str, **kwargs: Any) -> 'Response':
         return Response(self.session.request(method, url, **kwargs))
 
+    @convert_exc
     @override
     def open(self) -> None:
         self.session = httpx.Client(**self.session_kwargs)
 
+    @convert_exc
     @override
     def close(self) -> None:
         if self.should_close():

src/prisma/_types.py

@@ -23,6 +23,8 @@
 FuncType = Callable[..., object]
 CoroType = Callable[..., Coroutine[Any, Any, object]]
 
+ExcMapping = Mapping[Type[BaseException], Type[BaseException]]
+
 
 @runtime_checkable
 class InheritsGeneric(Protocol):

src/prisma/errors.py

@@ -12,6 +12,7 @@
     'TableNotFoundError',
     'RecordNotFoundError',
     'HTTPClientClosedError',
+    'HTTPClientTimeoutError',
     'ClientNotConnectedError',
     'PrismaWarning',
     'UnsupportedSubclassWarning',
@@ -44,6 +45,14 @@ def __init__(self) -> None:
         super().__init__('Cannot make a request from a closed client.')
 
 
+class HTTPClientTimeoutError(PrismaError):
+    def __init__(self) -> None:
+        super().__init__(
+            'HTTP operation has timed out.\n'
+            'The default timeout is 30 seconds. Maybe you should increase it: prisma.Prisma(http_config={"timeout": httpx.Timeout(30)})'
+        )
+
+
 class UnsupportedDatabaseError(PrismaError):
     context: str
     database: str

src/prisma/http_abstract.py

@@ -12,22 +12,18 @@
 )
 from typing_extensions import override
 
-from httpx import Limits, Headers, Timeout
+from httpx import Headers
 
 from .utils import _NoneType
 from ._types import Method
 from .errors import HTTPClientClosedError
+from ._constants import DEFAULT_HTTP_CONFIG
 
 Session = TypeVar('Session')
 Response = TypeVar('Response')
 ReturnType = TypeVar('ReturnType')
 MaybeCoroutine = Union[Coroutine[Any, Any, ReturnType], ReturnType]
 
-DEFAULT_CONFIG: Dict[str, Any] = {
-    'limits': Limits(max_connections=1000),
-    'timeout': Timeout(30),
-}
-
 
 class AbstractHTTP(ABC, Generic[Session, Response]):
     session_kwargs: Dict[str, Any]
@@ -45,7 +41,7 @@ def __init__(self, **kwargs: Any) -> None:
         # Session = open
         self._session: Optional[Union[Session, Type[_NoneType]]] = _NoneType
         self.session_kwargs = {
-            **DEFAULT_CONFIG,
+            **DEFAULT_HTTP_CONFIG,
             **kwargs,
         }
 

src/prisma/utils.py

@@ -6,11 +6,13 @@
 import inspect
 import logging
 import warnings
+import functools
 import contextlib
-from typing import TYPE_CHECKING, Any, Dict, Union, TypeVar, Iterator, NoReturn, Coroutine
+from types import TracebackType
+from typing import TYPE_CHECKING, Any, Dict, Type, Union, TypeVar, Callable, Iterator, NoReturn, Optional, Coroutine
 from importlib.util import find_spec
 
-from ._types import CoroType, FuncType, TypeGuard
+from ._types import CoroType, FuncType, TypeGuard, ExcMapping
 
 if TYPE_CHECKING:
     from typing_extensions import TypeGuard
@@ -139,3 +141,56 @@ def make_optional(value: _T) -> _T | None:
 
 def is_dict(obj: object) -> TypeGuard[dict[object, object]]:
     return isinstance(obj, dict)
+
+
+# TODO: improve typing
+class MaybeAsyncContextDecorator(contextlib.ContextDecorator):
+    """`ContextDecorator` compatible with sync/async functions."""
+
+    def __call__(self, func: Callable[..., Any]) -> Callable[..., Any]:  # type: ignore[override]
+        @functools.wraps(func)
+        async def async_inner(*args: Any, **kwargs: Any) -> object:
+            async with self._recreate_cm():  # type: ignore[attr-defined]
+                return await func(*args, **kwargs)
+
+        @functools.wraps(func)
+        def sync_inner(*args: Any, **kwargs: Any) -> object:
+            with self._recreate_cm():  # type: ignore[attr-defined]
+                return func(*args, **kwargs)
+
+        if is_coroutine(func):
+            return async_inner
+        else:
+            return sync_inner
+
+
+class ExcConverter(MaybeAsyncContextDecorator):
+    """`MaybeAsyncContextDecorator` to convert exceptions."""
+
+    def __init__(self, exc_mapping: ExcMapping) -> None:
+        self._exc_mapping = exc_mapping
+
+    def __enter__(self) -> 'ExcConverter':
+        return self
+
+    def __exit__(
+        self,
+        exc_type: Optional[Type[BaseException]],
+        exc: Optional[BaseException],
+        exc_tb: Optional[TracebackType],
+    ) -> None:
+        if exc is not None and exc_type is not None:
+            target_exc_type = self._exc_mapping.get(exc_type)
+            if target_exc_type is not None:
+                raise target_exc_type() from exc
+
+    async def __aenter__(self) -> 'ExcConverter':
+        return self.__enter__()
+
+    async def __aexit__(
+        self,
+        exc_type: Optional[Type[BaseException]],
+        exc: Optional[BaseException],
+        exc_tb: Optional[TracebackType],
+    ) -> None:
+        self.__exit__(exc_type, exc, exc_tb)

tests/test_client.py

@@ -10,10 +10,10 @@
 from prisma import ENGINE_TYPE, SCHEMA_PATH, Prisma, errors, get_client
 from prisma.types import HttpConfig
 from prisma.testing import reset_client
+from prisma._constants import DEFAULT_HTTP_CONFIG
 from prisma.cli.prisma import run
 from prisma.engine.http import HTTPEngine
 from prisma.engine.errors import AlreadyConnectedError
-from prisma.http_abstract import DEFAULT_CONFIG
 
 from .utils import Testdir, patch_method
 
@@ -140,7 +140,7 @@ async def _test(config: HttpConfig) -> None:
 
         captured = getter()
         assert captured is not None
-        assert captured == ((), {**DEFAULT_CONFIG, **config})
+        assert captured == ((), {**DEFAULT_HTTP_CONFIG, **config})
 
     await _test({'timeout': 1})
     await _test({'timeout': httpx.Timeout(5, connect=10, read=30)})

tests/test_http.py

@@ -2,11 +2,12 @@
 
 import httpx
 import pytest
+from pytest_mock import MockerFixture
 
 from prisma.http import HTTP
 from prisma.utils import _NoneType
 from prisma._types import Literal
-from prisma.errors import HTTPClientClosedError
+from prisma.errors import HTTPClientClosedError, HTTPClientTimeoutError
 
 from .utils import patch_method
 
@@ -81,3 +82,26 @@ async def test_httpx_default_config(monkeypatch: 'MonkeyPatch') -> None:
             'timeout': httpx.Timeout(30),
         },
     )
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize(
+    'httpx_error',
+    [
+        httpx.ConnectTimeout(''),
+        httpx.ReadTimeout(''),
+        httpx.WriteTimeout(''),
+        httpx.PoolTimeout(''),
+    ],
+)
+async def test_http_timeout_error(httpx_error: BaseException, mocker: MockerFixture) -> None:
+    """Ensure that `httpx.TimeoutException` is converted to `prisma.errors.HTTPClientTimeoutError`."""
+    mocker.patch('httpx.AsyncClient.request', side_effect=httpx_error)
+
+    http = HTTP()
+    http.open()
+
+    with pytest.raises(HTTPClientTimeoutError) as exc_info:
+        await http.request('GET', '/')
+
+    assert exc_info.value.__cause__ == httpx_error

tests/test_utils.py

@@ -0,0 +1,66 @@
+import asyncio
+from typing import Type, NoReturn
+
+import pytest
+
+from prisma.utils import ExcConverter
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize(
+    ('convert_exc', 'raised_exc_type', 'expected_exc_type', 'should_be_converted'),
+    [
+        pytest.param(ExcConverter({ValueError: ImportError}), ValueError, ImportError, True, id='should convert'),
+        pytest.param(
+            ExcConverter({ValueError: ImportError}), RuntimeError, RuntimeError, False, id='should not convert'
+        ),
+    ],
+)
+async def test_exc_converter(
+    convert_exc: ExcConverter,
+    raised_exc_type: Type[BaseException],
+    expected_exc_type: Type[BaseException],
+    should_be_converted: bool,
+) -> None:
+    """Ensure that `prisma.utils.ExcConverter` works as expected."""
+
+    # Test sync context manager
+    with pytest.raises(expected_exc_type) as exc_info_1:
+        with convert_exc:
+            raise raised_exc_type()
+
+    # Test async context manager
+    with pytest.raises(expected_exc_type) as exc_info_2:
+        async with convert_exc:
+            await asyncio.sleep(0.1)
+            raise raised_exc_type()
+
+    # Test sync decorator
+    with pytest.raises(expected_exc_type) as exc_info_3:
+
+        @convert_exc
+        def help_func() -> NoReturn:
+            raise raised_exc_type()
+
+        help_func()
+
+    # Test async decorator
+    with pytest.raises(expected_exc_type) as exc_info_4:
+
+        @convert_exc
+        async def help_func() -> NoReturn:
+            await asyncio.sleep(0.1)
+            raise raised_exc_type()
+
+        await help_func()
+
+    # Test exception cause
+    if should_be_converted:
+        assert all(
+            (
+                type(exc_info_1.value.__cause__) is raised_exc_type,
+                type(exc_info_2.value.__cause__) is raised_exc_type,
+                type(exc_info_3.value.__cause__) is raised_exc_type,
+                type(exc_info_4.value.__cause__) is raised_exc_type,
+            )
+        )