Fixed linting/formatting

Author: agronholm

httpcore/_async/connection_pool.py

@@ -1,11 +1,10 @@
 from __future__ import annotations
 
-from collections.abc import AsyncGenerator
-
 import ssl
 import sys
 import types
 import typing
+from collections.abc import AsyncGenerator
 
 from .._backends.auto import AutoBackend
 from .._backends.base import SOCKET_OPTION, AsyncNetworkBackend
@@ -17,8 +16,9 @@
 from .interfaces import AsyncConnectionInterface, AsyncRequestInterface
 
 if typing.TYPE_CHECKING:
-    from .http11 import HTTP11ConnectionByteStream
     from .http2 import HTTP2ConnectionByteStream
+    from .http11 import HTTP11ConnectionByteStream
+
 
 class AsyncPoolRequest:
     def __init__(self, request: Request) -> None:

httpcore/_async/http11.py

@@ -21,8 +21,8 @@
 from .._models import Origin, Request, Response
 from .._synchronization import AsyncLock, AsyncShieldCancellation
 from .._trace import Trace
-from .interfaces import AsyncConnectionInterface
 from .._utils import aclosing
+from .interfaces import AsyncConnectionInterface
 
 logger = logging.getLogger("httpcore.http11")
 
@@ -331,7 +331,9 @@ async def __aiter__(self) -> AsyncGenerator[bytes]:
         kwargs = {"request": self._request}
         try:
             async with Trace("receive_response_body", logger, self._request, kwargs):
-                async with aclosing(self._connection._receive_response_body(**kwargs)) as body:
+                async with aclosing(
+                    self._connection._receive_response_body(**kwargs)
+                ) as body:
                     async for chunk in body:
                         yield chunk
         except BaseException as exc:

httpcore/_utils.py

@@ -7,6 +7,8 @@
 if sys.version_info >= (3, 10):
     from contextlib import aclosing as aclosing
 else:
+    from contextlib import AbstractAsyncContextManager
+
     class aclosing(AbstractAsyncContextManager):
         def __init__(self, thing):
             self.thing = thing

scripts/unasync.py

@@ -5,33 +5,36 @@
 from pprint import pprint
 
 SUBS = [
-    ('from .._backends.auto import AutoBackend', 'from .._backends.sync import SyncBackend'),
-    ('import trio as concurrency', 'from tests import concurrency'),
-    ('AsyncIterator', 'Iterator'),
-    ('Async([A-Z][A-Za-z0-9_]*)', r'\2'),
-    ('async def', 'def'),
-    ('async with', 'with'),
-    ('async for', 'for'),
-    ('await ', ''),
-    ('handle_async_request', 'handle_request'),
-    ('aclose', 'close'),
-    ('aiter_stream', 'iter_stream'),
-    ('aread', 'read'),
-    ('asynccontextmanager', 'contextmanager'),
-    ('__aenter__', '__enter__'),
-    ('__aexit__', '__exit__'),
-    ('__aiter__', '__iter__'),
-    ('@pytest.mark.anyio', ''),
-    ('@pytest.mark.trio', ''),
-    ('AutoBackend', 'SyncBackend'),
+    (
+        "from .._backends.auto import AutoBackend",
+        "from .._backends.sync import SyncBackend",
+    ),
+    ("import trio as concurrency", "from tests import concurrency"),
+    ("AsyncIterator", "Iterator"),
+    ("Async([A-Z][A-Za-z0-9_]*)", r"\2"),
+    ("async def", "def"),
+    ("async with", "with"),
+    ("async for", "for"),
+    ("await ", ""),
+    ("handle_async_request", "handle_request"),
+    ("aclose", "close"),
+    ("aiter_stream", "iter_stream"),
+    ("aread", "read"),
+    ("asynccontextmanager", "contextmanager"),
+    ("__aenter__", "__enter__"),
+    ("__aexit__", "__exit__"),
+    ("__aiter__", "__iter__"),
+    ("@pytest.mark.anyio", ""),
+    ("@pytest.mark.trio", ""),
+    ("AutoBackend", "SyncBackend"),
 ]
 COMPILED_SUBS = [
-    (re.compile(r'(^|\b)' + regex + r'($|\b)'), repl)
-    for regex, repl in SUBS
+    (re.compile(r"(^|\b)" + regex + r"($|\b)"), repl) for regex, repl in SUBS
 ]
 
 USED_SUBS = set()
 
+
 def unasync_line(line):
     for index, (regex, repl) in enumerate(COMPILED_SUBS):
         old_line = line
@@ -55,30 +58,30 @@ def unasync_file_check(in_path, out_path):
             for in_line, out_line in zip(in_file.readlines(), out_file.readlines()):
                 expected = unasync_line(in_line)
                 if out_line != expected:
-                    print(f'unasync mismatch between {in_path!r} and {out_path!r}')
-                    print(f'Async code:         {in_line!r}')
-                    print(f'Expected sync code: {expected!r}')
-                    print(f'Actual sync code:   {out_line!r}')
+                    print(f"unasync mismatch between {in_path!r} and {out_path!r}")
+                    print(f"Async code:         {in_line!r}")
+                    print(f"Expected sync code: {expected!r}")
+                    print(f"Actual sync code:   {out_line!r}")
                     sys.exit(1)
 
 
 def unasync_dir(in_dir, out_dir, check_only=False):
     for dirpath, dirnames, filenames in os.walk(in_dir):
         for filename in filenames:
-            if not filename.endswith('.py'):
+            if not filename.endswith(".py"):
                 continue
             rel_dir = os.path.relpath(dirpath, in_dir)
             in_path = os.path.normpath(os.path.join(in_dir, rel_dir, filename))
             out_path = os.path.normpath(os.path.join(out_dir, rel_dir, filename))
-            print(in_path, '->', out_path)
+            print(in_path, "->", out_path)
             if check_only:
                 unasync_file_check(in_path, out_path)
             else:
                 unasync_file(in_path, out_path)
 
 
 def main():
-    check_only = '--check' in sys.argv
+    check_only = "--check" in sys.argv
     unasync_dir("httpcore/_async", "httpcore/_sync", check_only=check_only)
     unasync_dir("tests/_async", "tests/_sync", check_only=check_only)
 
@@ -87,8 +90,8 @@ def main():
 
         print("These patterns were not used:")
         pprint(unused_subs)
-        exit(1)   
-        
+        exit(1)
+
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     main()