Fix linters (encode#550)

Author: igor.stulikov

httpcore/_async/connection_pool.py

@@ -174,7 +174,9 @@ async def _attempt_to_acquire_connection(self, status: RequestStatus) -> bool:
 
         # Attempt to close CONNECTING connections that no one needs
         if self._is_pool_full:
-            for idx, connection in enumerate(self._pool):  # Try to check old connections first
+            for idx, connection in enumerate(
+                self._pool
+            ):  # Try to check old connections first
                 if not connection.is_connecting():
                     continue
                 for req_status in self._requests:

httpcore/_sync/connection_pool.py

@@ -174,7 +174,9 @@ def _attempt_to_acquire_connection(self, status: RequestStatus) -> bool:
 
         # Attempt to close CONNECTING connections that no one needs
         if self._is_pool_full:
-            for idx, connection in enumerate(self._pool):  # Try to check old connections first
+            for idx, connection in enumerate(
+                self._pool
+            ):  # Try to check old connections first
                 if not connection.is_connecting():
                     continue
                 for req_status in self._requests:

httpcore/backends/mock.py

@@ -6,8 +6,9 @@
 import anyio
 
 from httpcore import ReadTimeout
-from .base import AsyncNetworkBackend, AsyncNetworkStream, NetworkBackend, NetworkStream
+
 from .._exceptions import ReadError
+from .base import AsyncNetworkBackend, AsyncNetworkStream, NetworkBackend, NetworkStream
 
 
 class MockSSLObject:
@@ -51,18 +52,16 @@ def get_extra_info(self, info: str) -> typing.Any:
 
 class HangingStream(MockStream):
     def read(self, max_bytes: int, timeout: Optional[float] = None) -> bytes:
-        if self._closed:
-            raise ReadError("Connection closed")
         time.sleep(timeout or 0.1)
         raise ReadTimeout
 
 
 class MockBackend(NetworkBackend):
     def __init__(
-            self,
-            buffer: typing.List[bytes],
-            http2: bool = False,
-            resp_stream_cls: Optional[Type[NetworkStream]] = None,
+        self,
+        buffer: typing.List[bytes],
+        http2: bool = False,
+        resp_stream_cls: Optional[Type[MockStream]] = None,
     ) -> None:
         self._buffer = buffer
         self._http2 = http2
@@ -119,22 +118,22 @@ def get_extra_info(self, info: str) -> typing.Any:
 
 class AsyncHangingStream(AsyncMockStream):
     async def read(self, max_bytes: int, timeout: Optional[float] = None) -> bytes:
-        if self._closed:
-            raise ReadError("Connection closed")
         await anyio.sleep(timeout or 0.1)
         raise ReadTimeout
 
 
 class AsyncMockBackend(AsyncNetworkBackend):
     def __init__(
-            self,
-            buffer: typing.List[bytes],
-            http2: bool = False,
-            resp_stream_cls: Optional[Type[AsyncNetworkStream]] = None,
+        self,
+        buffer: typing.List[bytes],
+        http2: bool = False,
+        resp_stream_cls: Optional[Type[AsyncMockStream]] = None,
     ) -> None:
         self._buffer = buffer
         self._http2 = http2
-        self._resp_stream_cls: Type[AsyncMockStream] = resp_stream_cls or AsyncMockStream
+        self._resp_stream_cls: Type[AsyncMockStream] = (
+            resp_stream_cls or AsyncMockStream
+        )
 
     async def connect_tcp(
         self,

tests/_async/test_connection_pool.py

@@ -8,12 +8,12 @@
     AsyncConnectionPool,
     ConnectError,
     PoolTimeout,
-    ReadTimeout,
     ReadError,
+    ReadTimeout,
     UnsupportedProtocol,
 )
 from httpcore.backends.base import AsyncNetworkStream
-from httpcore.backends.mock import AsyncMockBackend, AsyncHangingStream
+from httpcore.backends.mock import AsyncHangingStream, AsyncMockBackend
 
 
 @pytest.mark.anyio
@@ -511,21 +511,22 @@ async def test_pool_under_load():
     """
     network_backend = AsyncMockBackend([], resp_stream_cls=AsyncHangingStream)
 
-    async def fetch(_pool: AsyncConnectionPool, *exceptions: Type[BaseException]):
+    async def fetch(
+        _pool: AsyncConnectionPool, *exceptions: Type[BaseException]
+    ) -> None:
         with contextlib.suppress(*exceptions):
-            async with pool.stream(
-                    "GET",
-                    "http://a.com/",
-                    extensions={
-                        "timeout": {
-                            "connect": 0.1,
-                            "read": 0.1,
-                            "pool": 0.1,
-                            "write": 0.1,
-                        },
+            await pool.request(
+                "GET",
+                "http://a.com/",
+                extensions={
+                    "timeout": {
+                        "connect": 0.1,
+                        "read": 0.1,
+                        "pool": 0.1,
+                        "write": 0.1,
                     },
-            ) as response:
-                await response.aread()
+                },
+            )
 
     async with AsyncConnectionPool(
         max_connections=1, network_backend=network_backend
@@ -535,13 +536,13 @@ async def fetch(_pool: AsyncConnectionPool, *exceptions: Type[BaseException]):
                 # Sending many requests to the same url. All of them but one will have PoolTimeout. One will
                 # be finished with ReadTimeout
                 nursery.start_soon(fetch, pool, PoolTimeout, ReadTimeout)
-        if pool.connections:  # There is one connection in pool in "CONNECTING" state
-            assert pool.connections[0].is_connecting()
-        with pytest.raises(ReadTimeout):  # ReadTimeout indicates that connection could be retrieved
+            assert pool.connections[0].is_connecting() if pool.connections else True
+        with pytest.raises(
+            ReadTimeout
+        ):  # ReadTimeout indicates that connection could be retrieved
             await fetch(pool)
 
 
-
 @pytest.mark.trio
 async def test_pool_timeout_connection_cleanup():
     """
@@ -555,7 +556,8 @@ async def test_pool_timeout_connection_cleanup():
             b"Content-Length: 13\r\n",
             b"\r\n",
             b"Hello, world!",
-        ] * 2,
+        ]
+        * 2,
     )
 
     async with AsyncConnectionPool(
@@ -568,12 +570,18 @@ async def test_pool_timeout_connection_cleanup():
             "write": 0.1,
         }
         with contextlib.suppress(PoolTimeout):
-            await pool.request("GET", "https://example.com/", extensions={"timeout": timeout})
+            await pool.request(
+                "GET", "https://example.com/", extensions={"timeout": timeout}
+            )
 
         # wait for a considerable amount of time to make sure all requests time out
         await concurrency.sleep(0.1)
 
-        await pool.request("GET", "https://example.com/", extensions={"timeout": {**timeout, 'pool': 0.1}})
+        await pool.request(
+            "GET",
+            "https://example.com/",
+            extensions={"timeout": {**timeout, "pool": 0.1}},
+        )
 
         if pool.connections:
             for conn in pool.connections:

tests/_sync/test_connection_pool.py

@@ -1,20 +1,20 @@
 import contextlib
-import time
 from typing import List, Optional, Type
 
 import pytest
+from tests import concurrency
 
 from httpcore import (
     ConnectionPool,
     ConnectError,
     PoolTimeout,
-    ReadTimeout,
     ReadError,
+    ReadTimeout,
     UnsupportedProtocol,
 )
 from httpcore.backends.base import NetworkStream
-from httpcore.backends.mock import MockBackend, HangingStream
-from tests import concurrency
+from httpcore.backends.mock import HangingStream, MockBackend
+
 
 
 def test_connection_pool_with_keepalive():
@@ -511,21 +511,22 @@ def test_pool_under_load():
     """
     network_backend = MockBackend([], resp_stream_cls=HangingStream)
 
-    def fetch(_pool: ConnectionPool, *exceptions: Type[BaseException]):
+    def fetch(
+        _pool: ConnectionPool, *exceptions: Type[BaseException]
+    ) -> None:
         with contextlib.suppress(*exceptions):
-            with pool.stream(
-                    "GET",
-                    "http://a.com/",
-                    extensions={
-                        "timeout": {
-                            "connect": 0.1,
-                            "read": 0.1,
-                            "pool": 0.1,
-                            "write": 0.1,
-                        },
+            pool.request(
+                "GET",
+                "http://a.com/",
+                extensions={
+                    "timeout": {
+                        "connect": 0.1,
+                        "read": 0.1,
+                        "pool": 0.1,
+                        "write": 0.1,
                     },
-            ) as response:
-                response.read()
+                },
+            )
 
     with ConnectionPool(
         max_connections=1, network_backend=network_backend
@@ -535,9 +536,10 @@ def fetch(_pool: ConnectionPool, *exceptions: Type[BaseException]):
                 # Sending many requests to the same url. All of them but one will have PoolTimeout. One will
                 # be finished with ReadTimeout
                 nursery.start_soon(fetch, pool, PoolTimeout, ReadTimeout)
-        if pool.connections:  # There is one connection in pool in "CONNECTING" state
-            assert pool.connections[0].is_connecting()
-        with pytest.raises(ReadTimeout):  # ReadTimeout indicates that connection could be retrieved
+            assert pool.connections[0].is_connecting() if pool.connections else True
+        with pytest.raises(
+            ReadTimeout
+        ):  # ReadTimeout indicates that connection could be retrieved
             fetch(pool)
 
 
@@ -554,11 +556,12 @@ def test_pool_timeout_connection_cleanup():
             b"Content-Length: 13\r\n",
             b"\r\n",
             b"Hello, world!",
-        ] * 2,
+        ]
+        * 2,
     )
 
     with ConnectionPool(
-        network_backend=network_backend, max_connections=2
+        network_backend=network_backend, max_connections=1
     ) as pool:
         timeout = {
             "connect": 0.1,
@@ -567,12 +570,18 @@ def test_pool_timeout_connection_cleanup():
             "write": 0.1,
         }
         with contextlib.suppress(PoolTimeout):
-            pool.request("GET", "https://example.com/", extensions={"timeout": timeout})
+            pool.request(
+                "GET", "https://example.com/", extensions={"timeout": timeout}
+            )
 
         # wait for a considerable amount of time to make sure all requests time out
-        time.sleep(0.1)
+        concurrency.sleep(0.1)
 
-        pool.request("GET", "https://example.com/", extensions={"timeout": {**timeout, 'pool': 0.1}})
+        pool.request(
+            "GET",
+            "https://example.com/",
+            extensions={"timeout": {**timeout, "pool": 0.1}},
+        )
 
         if pool.connections:
             for conn in pool.connections:

tests/concurrency.py

@@ -9,6 +9,7 @@
 childen, because we don't need that for our use-case.
 """
 import threading
+import time
 from types import TracebackType
 from typing import Any, Callable, List, Optional, Type
 
@@ -38,3 +39,7 @@ def start_soon(self, func: Callable[..., object], *args: Any) -> None:
 
 def open_nursery() -> Nursery:
     return Nursery()
+
+
+def sleep(seconds: float) -> None:
+    time.sleep(seconds)