Avoid an extra "can_read" call and use timeout directly.

Author: kristjanvalur

redis/asyncio/client.py

@@ -759,18 +759,8 @@ async def parse_response(self, block: bool = True, timeout: float = 0):
         if not conn.is_connected:
             await conn.connect()
 
-        if not block:
-
-            async def read_with_timeout():
-                try:
-                    async with async_timeout.timeout(timeout):
-                        return await conn.read_response()
-                except asyncio.TimeoutError:
-                    return None
-
-            response = await self._execute(conn, read_with_timeout)
-        else:
-            response = await self._execute(conn, conn.read_response)
+        read_timeout = None if block else timeout
+        response = await self._execute(conn, conn.read_response, timeout=read_timeout)
 
         if conn.health_check_interval and response == self.health_check_response:
             # ignore the health check message as user might not expect it

redis/asyncio/connection.py

@@ -1,4 +1,5 @@
 import asyncio
+import contextlib
 import copy
 import enum
 import errno
@@ -55,6 +56,19 @@
 if HIREDIS_AVAILABLE:
     import hiredis
 
+if sys.version_info[:2] >= (3, 10):
+    nullcontext = contextlib.nullcontext()
+else:
+
+    class NullContext:
+        async def __aenter__(self):
+            pass
+
+        async def __aexit__(self, *args):
+            pass
+
+    nullcontext = NullContext()
+
 NONBLOCKING_EXCEPTION_ERROR_NUMBERS = {
     BlockingIOError: errno.EWOULDBLOCK,
     ssl.SSLWantReadError: 2,
@@ -922,19 +936,23 @@ async def can_read_destructive(self):
                 f"Error while reading from {self.host}:{self.port}: {e.args}"
             )
 
-    async def read_response(self, disable_decoding: bool = False):
+    async def read_response(
+        self,
+        disable_decoding: bool = False,
+        timeout: Optional[float] = None,
+    ):
         """Read the response from a previously sent command"""
+        read_timeout = timeout if timeout is not None else self.socket_timeout
         try:
-            if self.socket_timeout:
-                async with async_timeout.timeout(self.socket_timeout):
-                    response = await self._parser.read_response(
-                        disable_decoding=disable_decoding
-                    )
-            else:
+            async with async_timeout.timeout(read_timeout):
                 response = await self._parser.read_response(
                     disable_decoding=disable_decoding
                 )
         except asyncio.TimeoutError:
+            if timeout is not None:
+                # user requested timeout, return None
+                return None
+            # it was a self.socket_timeout error.
             await self.disconnect(nowait=True)
             raise TimeoutError(f"Timeout reading from {self.host}:{self.port}")
         except OSError as e: