Merge branch 'master' into async-graph

Author: dvora-h

.github/workflows/integration.yaml

@@ -39,7 +39,7 @@ jobs:
      strategy:
        max-parallel: 15
        matrix:
-         python-version: ['3.6', '3.7', '3.8', '3.9', '3.10', 'pypy-3.7', 'pypy-3.8']
+         python-version: ['3.7', '3.8', '3.9', '3.10', 'pypy-3.7', 'pypy-3.8']
          test-type: ['standalone', 'cluster']
          connection-type: ['hiredis', 'plain']
      env:
@@ -84,7 +84,7 @@ jobs:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        python-version: ['3.6', '3.7', '3.8', '3.9', '3.10', 'pypy-3.7']
+        python-version: ['3.7', '3.8', '3.9', '3.10', 'pypy-3.7']
     steps:
       - uses: actions/checkout@v2
       - name: install python ${{ matrix.python-version }}

CONTRIBUTING.md

@@ -126,7 +126,7 @@ this, instead of using make test, you need to pass
 Our test suite uses `pytest`. You can run a specific test suite against
 a specific Python version like this:
 
-`$ docker-compose run test tox -e py36 -- --redis-url=redis://master:6379/9 tests/test_commands.py`
+`$ docker-compose run test tox -e py37 -- --redis-url=redis://master:6379/9 tests/test_commands.py`
 
 ### Troubleshooting
 

redis/asyncio/client.py

@@ -754,9 +754,15 @@ async def parse_response(self, block: bool = True, timeout: float = 0):
 
         await self.check_health()
 
-        if not block and not await self._execute(conn, conn.can_read, timeout=timeout):
-            return None
-        response = await self._execute(conn, conn.read_response)
+        async def try_read():
+            if not block:
+                if not await conn.can_read(timeout=timeout):
+                    return None
+            else:
+                await conn.connect()
+            return await conn.read_response()
+
+        response = await self._execute(conn, try_read)
 
         if conn.health_check_interval and response == self.health_check_response:
             # ignore the health check message as user might not expect it

redis/asyncio/cluster.py

@@ -377,8 +377,7 @@ def __del__(self) -> None:
             warnings.warn(f"{self._DEL_MESSAGE} {self!r}", ResourceWarning, source=self)
             try:
                 context = {"client": self, "message": self._DEL_MESSAGE}
-                # TODO: Change to get_running_loop() when dropping support for py3.6
-                asyncio.get_event_loop().call_exception_handler(context)
+                asyncio.get_running_loop().call_exception_handler(context)
             except RuntimeError:
                 ...
 
@@ -834,8 +833,7 @@ def __del__(self) -> None:
                 )
                 try:
                     context = {"client": self, "message": self._DEL_MESSAGE}
-                    # TODO: Change to get_running_loop() when dropping support for py3.6
-                    asyncio.get_event_loop().call_exception_handler(context)
+                    asyncio.get_running_loop().call_exception_handler(context)
                 except RuntimeError:
                     ...
                 break

redis/asyncio/connection.py

@@ -7,7 +7,6 @@
 import os
 import socket
 import ssl
-import sys
 import threading
 import weakref
 from itertools import chain
@@ -864,12 +863,10 @@ async def _ping_failed(self, error):
 
     async def check_health(self):
         """Check the health of the connection with a PING/PONG"""
-        if sys.version_info[0:2] == (3, 6):
-            func = asyncio.get_event_loop
-        else:
-            func = asyncio.get_running_loop
-
-        if self.health_check_interval and func().time() > self.next_health_check:
+        if (
+            self.health_check_interval
+            and asyncio.get_running_loop().time() > self.next_health_check
+        ):
             await self.retry.call_with_retry(self._send_ping, self._ping_failed)
 
     async def _send_packed_command(self, command: Iterable[bytes]) -> None:
@@ -957,11 +954,8 @@ async def read_response(self, disable_decoding: bool = False):
             raise
 
         if self.health_check_interval:
-            if sys.version_info[0:2] == (3, 6):
-                func = asyncio.get_event_loop
-            else:
-                func = asyncio.get_running_loop
-            self.next_health_check = func().time() + self.health_check_interval
+            next_time = asyncio.get_running_loop().time() + self.health_check_interval
+            self.next_health_check = next_time
 
         if isinstance(response, ResponseError):
             raise response from None
@@ -992,11 +986,8 @@ async def read_response_without_lock(self, disable_decoding: bool = False):
             raise
 
         if self.health_check_interval:
-            if sys.version_info[0:2] == (3, 6):
-                func = asyncio.get_event_loop
-            else:
-                func = asyncio.get_running_loop
-            self.next_health_check = func().time() + self.health_check_interval
+            next_time = asyncio.get_running_loop().time() + self.health_check_interval
+            self.next_health_check = next_time
 
         if isinstance(response, ResponseError):
             raise response from None

redis/asyncio/lock.py

@@ -1,5 +1,4 @@
 import asyncio
-import sys
 import threading
 import uuid
 from types import SimpleNamespace
@@ -186,11 +185,6 @@ async def acquire(
         object with the default encoding. If a token isn't specified, a UUID
         will be generated.
         """
-        if sys.version_info[0:2] != (3, 6):
-            loop = asyncio.get_running_loop()
-        else:
-            loop = asyncio.get_event_loop()
-
         sleep = self.sleep
         if token is None:
             token = uuid.uuid1().hex.encode()
@@ -203,14 +197,14 @@ async def acquire(
             blocking_timeout = self.blocking_timeout
         stop_trying_at = None
         if blocking_timeout is not None:
-            stop_trying_at = loop.time() + blocking_timeout
+            stop_trying_at = asyncio.get_event_loop().time() + blocking_timeout
         while True:
             if await self.do_acquire(token):
                 self.local.token = token
                 return True
             if not blocking:
                 return False
-            next_try_at = loop.time() + sleep
+            next_try_at = asyncio.get_event_loop().time() + sleep
             if stop_trying_at is not None and next_try_at > stop_trying_at:
                 return False
             await asyncio.sleep(sleep)

redis/client.py

@@ -1497,9 +1497,15 @@ def parse_response(self, block=True, timeout=0):
 
         self.check_health()
 
-        if not block and not self._execute(conn, conn.can_read, timeout=timeout):
-            return None
-        response = self._execute(conn, conn.read_response)
+        def try_read():
+            if not block:
+                if not conn.can_read(timeout=timeout):
+                    return None
+            else:
+                conn.connect()
+            return conn.read_response()
+
+        response = self._execute(conn, try_read)
 
         if self.is_health_check_response(response):
             # ignore the health check message as user might not expect it

setup.py

@@ -30,7 +30,7 @@
     },
     author="Redis Inc.",
     author_email="[email protected]",
-    python_requires=">=3.6",
+    python_requires=">=3.7",
     install_requires=[
         "deprecated>=1.2.3",
         "packaging>=20.4",
@@ -47,7 +47,6 @@
         "Programming Language :: Python",
         "Programming Language :: Python :: 3",
         "Programming Language :: Python :: 3 :: Only",
-        "Programming Language :: Python :: 3.6",
         "Programming Language :: Python :: 3.7",
         "Programming Language :: Python :: 3.8",
         "Programming Language :: Python :: 3.9",

tests/conftest.py

@@ -130,15 +130,25 @@ def _get_info(redis_url):
 
 
 def pytest_sessionstart(session):
+    # during test discovery, e.g. with VS Code, we may not
+    # have a server running.
     redis_url = session.config.getoption("--redis-url")
-    info = _get_info(redis_url)
-    version = info["redis_version"]
-    arch_bits = info["arch_bits"]
-    cluster_enabled = info["cluster_enabled"]
+    try:
+        info = _get_info(redis_url)
+        version = info["redis_version"]
+        arch_bits = info["arch_bits"]
+        cluster_enabled = info["cluster_enabled"]
+        enterprise = info["enterprise"]
+    except redis.ConnectionError:
+        # provide optimistic defaults
+        version = "10.0.0"
+        arch_bits = 64
+        cluster_enabled = False
+        enterprise = False
     REDIS_INFO["version"] = version
     REDIS_INFO["arch_bits"] = arch_bits
     REDIS_INFO["cluster_enabled"] = cluster_enabled
-    REDIS_INFO["enterprise"] = info["enterprise"]
+    REDIS_INFO["enterprise"] = enterprise
     # store REDIS_INFO in config so that it is available from "condition strings"
     session.config.REDIS_INFO = REDIS_INFO
 

tests/test_asyncio/compat.py

@@ -1,6 +1,15 @@
+import asyncio
+import sys
 from unittest import mock
 
 try:
     mock.AsyncMock
 except AttributeError:
     import mock
+
+
+def create_task(coroutine):
+    if sys.version_info[:2] >= (3, 7):
+        return asyncio.create_task(coroutine)
+    else:
+        return asyncio.ensure_future(coroutine)

tests/test_asyncio/conftest.py

@@ -1,10 +1,10 @@
-import functools
 import random
-import sys
+from contextlib import asynccontextmanager as _asynccontextmanager
 from typing import Union
 from urllib.parse import urlparse
 
 import pytest
+import pytest_asyncio
 from packaging.version import Version
 
 import redis.asyncio as redis
@@ -268,17 +268,5 @@ async def __aexit__(self, exc_type, exc_inst, tb):
         raise RuntimeError("More pickles")
 
 
-if sys.version_info[0:2] == (3, 6):
-
-    def asynccontextmanager(func):
-        @functools.wraps(func)
-        def wrapper(*args, **kwargs):
-            return AsyncContextManager(func(*args, **kwargs))
-
-        return wrapper
-
-else:
-    from contextlib import asynccontextmanager as _asynccontextmanager
-
-    def asynccontextmanager(func):
-        return _asynccontextmanager(func)
+def asynccontextmanager(func):
+    return _asynccontextmanager(func)

tests/test_asyncio/test_bloom.py

@@ -6,9 +6,6 @@
 from redis.exceptions import ModuleError, RedisError
 from redis.utils import HIREDIS_AVAILABLE
 
-if sys.version_info[0:2] == (3, 6):
-    pytestmark = pytest.mark.asyncio
-
 
 def intlist(obj):
     return [int(v) for v in obj]

tests/test_asyncio/test_cluster.py

@@ -2,22 +2,12 @@
 import binascii
 import datetime
 import os
-import sys
 import warnings
 from typing import Any, Awaitable, Callable, Dict, List, Optional, Type, Union
 from urllib.parse import urlparse
 
 import pytest
-
-from .compat import mock
-
-if sys.version_info[0:2] == (3, 6):
-    import pytest as pytest_asyncio
-
-    pytestmark = pytest.mark.asyncio
-else:
-    import pytest_asyncio
-
+import pytest_asyncio
 from _pytest.fixtures import FixtureRequest
 
 from redis.asyncio.cluster import ClusterNode, NodesManager, RedisCluster
@@ -44,6 +34,8 @@
     skip_unless_arch_bits,
 )
 
+from .compat import mock
+
 pytestmark = pytest.mark.onlycluster
 
 

tests/test_asyncio/test_commands.py

@@ -4,18 +4,11 @@
 import binascii
 import datetime
 import re
-import sys
 import time
 from string import ascii_letters
 
 import pytest
-
-if sys.version_info[0:2] == (3, 6):
-    import pytest as pytest_asyncio
-
-    pytestmark = pytest.mark.asyncio
-else:
-    import pytest_asyncio
+import pytest_asyncio
 
 import redis
 from redis import exceptions

tests/test_asyncio/test_connection.py

@@ -1,6 +1,5 @@
 import asyncio
 import socket
-import sys
 import types
 from unittest.mock import patch
 
@@ -19,9 +18,6 @@
 
 from .compat import mock
 
-if sys.version_info[0:2] == (3, 6):
-    pytestmark = pytest.mark.asyncio
-
 
 @pytest.mark.onlynoncluster
 @pytest.mark.skipif(HIREDIS_AVAILABLE, reason="PythonParser only")

tests/test_asyncio/test_connection_pool.py

@@ -1,16 +1,9 @@
 import asyncio
 import os
 import re
-import sys
 
 import pytest
-
-if sys.version_info[0:2] == (3, 6):
-    import pytest as pytest_asyncio
-
-    pytestmark = pytest.mark.asyncio
-else:
-    import pytest_asyncio
+import pytest_asyncio
 
 import redis.asyncio as redis
 from redis.asyncio.connection import Connection, to_bool

tests/test_asyncio/test_encoding.py

@@ -1,13 +1,5 @@
-import sys
-
 import pytest
-
-if sys.version_info[0:2] == (3, 6):
-    import pytest as pytest_asyncio
-
-    pytestmark = pytest.mark.asyncio
-else:
-    import pytest_asyncio
+import pytest_asyncio
 
 import redis.asyncio as redis
 from redis.exceptions import DataError

tests/test_asyncio/test_lock.py

@@ -1,14 +1,7 @@
 import asyncio
-import sys
 
 import pytest
-
-if sys.version_info[0:2] == (3, 6):
-    import pytest as pytest_asyncio
-
-    pytestmark = pytest.mark.asyncio
-else:
-    import pytest_asyncio
+import pytest_asyncio
 
 from redis.asyncio.lock import Lock
 from redis.exceptions import LockError, LockNotOwnedError