Merge remote-tracking branch 'origin/master' into ck-explaincli

Author: chayim

.github/release-drafter-config.yml

@@ -15,7 +15,7 @@ autolabeler:
     branch:
       - '/feature-.+'
 categories:
-  - title: 'Breaking Changes'
+  - title: '🔥 Breaking Changes'
     labels:
       - 'breakingchange'
   - title: '🚀 New Features'

redis/client.py

@@ -703,7 +703,6 @@ class Redis(RedisModuleCommands, CoreCommands, object):
         'CLUSTER SET-CONFIG-EPOCH': bool_ok,
         'CLUSTER SETSLOT': bool_ok,
         'CLUSTER SLAVES': parse_cluster_nodes,
-        'COMMAND': int,
         'COMMAND COUNT': int,
         'CONFIG GET': parse_config_get,
         'CONFIG RESETSTAT': bool_ok,
@@ -891,19 +890,25 @@ def __init__(self, host='localhost', port=6379,
         self.response_callbacks = CaseInsensitiveDict(
             self.__class__.RESPONSE_CALLBACKS)
 
+        # preload our class with the available redis commands
+        try:
+            self.__redis_commands__()
+        except RedisError:
+            pass
+
     def __repr__(self):
         return "%s<%s>" % (type(self).__name__, repr(self.connection_pool))
 
     def set_response_callback(self, command, callback):
         "Set a custom Response Callback"
         self.response_callbacks[command] = callback
 
-    def load_external_module(self, modname, funcname, func):
+    def load_external_module(self, funcname, func,
+                             ):
         """
         This function can be used to add externally defined redis modules,
         and their namespaces to the redis client.
-        modname - A string containing the name of the redis module to look for
-                  in the redis info block.
+
         funcname - A string containing the name of the function to create
         func - The function, being added to this class.
 
@@ -914,31 +919,25 @@ def load_external_module(self, modname, funcname, func):
         from redis import Redis
         from foomodule import F
         r = Redis()
-        r.load_external_module("foomod", "foo", F)
+        r.load_external_module("foo", F)
         r.foo().dothing('your', 'arguments')
 
         For a concrete example see the reimport of the redisjson module in
         tests/test_connection.py::test_loading_external_modules
         """
-        mods = self.loaded_modules
-        if modname.lower() not in mods:
-            raise ModuleError("{} is not loaded in redis.".format(modname))
         setattr(self, funcname, func)
 
-    @property
-    def loaded_modules(self):
-        key = '__redis_modules__'
-        mods = getattr(self, key, None)
-        if mods is not None:
-            return mods
-
+    def __redis_commands__(self):
+        """Store the list of available commands, for our redis instance."""
+        cmds = getattr(self, '__commands__', None)
+        if cmds is not None:
+            return cmds
         try:
-            mods = {f.get('name').lower(): f.get('ver')
-                    for f in self.info().get('modules')}
-        except TypeError:
-            mods = []
-        setattr(self, key, mods)
-        return mods
+            cmds = [c[0].upper().decode() for c in self.command()]
+        except AttributeError:  # if encoded
+            cmds = [c[0].upper() for c in self.command()]
+        self.__commands__ = cmds
+        return cmds
 
     def pipeline(self, transaction=True, shard_hint=None):
         """

redis/commands/core.py

@@ -3315,6 +3315,9 @@ def command_info(self):
     def command_count(self):
         return self.execute_command('COMMAND COUNT')
 
+    def command(self):
+        return self.execute_command('COMMAND')
+
 
 class Script:
     "An executable Lua script object returned by ``register_script``"

redis/commands/redismodules.py

@@ -8,41 +8,41 @@ class RedisModuleCommands:
     """
 
     def json(self, encoder=JSONEncoder(), decoder=JSONDecoder()):
-        """Access the json namespace, providing support for redis json."""
-        try:
-            modversion = self.loaded_modules['rejson']
-        except IndexError:
-            raise ModuleError("rejson is not a loaded in the redis instance.")
+        """Access the json namespace, providing support for redis json.
+        """
+        if 'JSON.SET' not in self.__commands__:
+            raise ModuleError("redisjson is not loaded in redis. "
+                              "For more information visit "
+                              "https://redisjson.io/")
 
         from .json import JSON
         jj = JSON(
                 client=self,
-                version=modversion,
                 encoder=encoder,
                 decoder=decoder)
         return jj
 
     def ft(self, index_name="idx"):
-        """Access the search namespace, providing support for redis search."""
-        try:
-            modversion = self.loaded_modules['search']
-        except IndexError:
-            raise ModuleError("search is not a loaded in the redis instance.")
+        """Access the search namespace, providing support for redis search.
+        """
+        if 'FT.INFO' not in self.__commands__:
+            raise ModuleError("redisearch is not loaded in redis. "
+                              "For more information visit "
+                              "https://redisearch.io/")
 
         from .search import Search
-        s = Search(client=self, version=modversion, index_name=index_name)
+        s = Search(client=self, index_name=index_name)
         return s
 
-    def ts(self, index_name="idx"):
+    def ts(self):
         """Access the timeseries namespace, providing support for
         redis timeseries data.
         """
-        try:
-            modversion = self.loaded_modules['timeseries']
-        except IndexError:
-            raise ModuleError("timeseries is not a loaded in "
-                              "the redis instance.")
+        if 'TS.INFO' not in self.__commands__:
+            raise ModuleError("reditimeseries is not loaded in redis. "
+                              "For more information visit "
+                              "https://redistimeseries.io/")
 
         from .timeseries import TimeSeries
-        s = TimeSeries(client=self, version=modversion, index_name=index_name)
+        s = TimeSeries(client=self)
         return s

redis/commands/search/__init__.py

@@ -83,15 +83,14 @@ def commit(self):
             self.pipeline.execute()
             self.current_chunk = 0
 
-    def __init__(self, client, version=None, index_name="idx"):
+    def __init__(self, client, index_name="idx"):
         """
         Create a new Client for the given index_name.
         The default name is `idx`
 
         If conn is not None, we employ an already existing redis connection
         """
         self.client = client
-        self.MODULE_VERSION = version
         self.index_name = index_name
         self.execute_command = client.execute_command
         self.pipeline = client.pipeline

redis/commands/timeseries/__init__.py

@@ -34,7 +34,7 @@ class TimeSeries(TimeSeriesCommands):
     functionality.
     """
 
-    def __init__(self, client=None, version=None, **kwargs):
+    def __init__(self, client=None, **kwargs):
         """Create a new RedisTimeSeries client."""
         # Set the module commands' callbacks
         self.MODULE_CALLBACKS = {
@@ -55,7 +55,6 @@ def __init__(self, client=None, version=None, **kwargs):
 
         self.client = client
         self.execute_command = client.execute_command
-        self.MODULE_VERSION = version
 
         for key, value in self.MODULE_CALLBACKS.items():
             self.client.set_response_callback(key, value)

redis/lock.py

@@ -76,14 +76,14 @@ def __init__(self, redis, name, timeout=None, sleep=0.1,
         Create a new Lock instance named ``name`` using the Redis client
         supplied by ``redis``.
 
-        ``timeout`` indicates a maximum life for the lock.
+        ``timeout`` indicates a maximum life for the lock in seconds.
         By default, it will remain locked until release() is called.
         ``timeout`` can be specified as a float or integer, both representing
         the number of seconds to wait.
 
-        ``sleep`` indicates the amount of time to sleep per loop iteration
-        when the lock is in blocking mode and another client is currently
-        holding the lock.
+        ``sleep`` indicates the amount of time to sleep in seconds per loop
+        iteration when the lock is in blocking mode and another client is
+        currently holding the lock.
 
         ``blocking`` indicates whether calling ``acquire`` should block until
         the lock has been acquired or to fail immediately, causing ``acquire``

tests/conftest.py

@@ -31,12 +31,10 @@ def pytest_addoption(parser):
 def _get_info(redis_url):
     client = redis.Redis.from_url(redis_url)
     info = client.info()
-    try:
-        client.execute_command("CONFIG SET maxmemory 5555555")
-        client.execute_command("CONFIG SET maxmemory 0")
-        info["enterprise"] = False
-    except redis.exceptions.ResponseError:
+    if 'dping' in client.__commands__:
         info["enterprise"] = True
+    else:
+        info["enterprise"] = False
     client.connection_pool.disconnect()
     return info
 
@@ -57,6 +55,8 @@ def pytest_sessionstart(session):
         REDIS_INFO["modules"] = info["modules"]
     except redis.exceptions.ConnectionError:
         pass
+    except KeyError:
+        pass
 
 
 def skip_if_server_version_lt(min_version):

tests/test_commands.py

@@ -1208,6 +1208,12 @@ def test_stralgo_lcs(self, r):
         value1 = 'ohmytext'
         value2 = 'mynewtext'
         res = 'mytext'
+
+        if skip_if_redis_enterprise(None).args[0] is True:
+            with pytest.raises(redis.exceptions.ResponseError):
+                assert r.stralgo('LCS', value1, value2) == res
+            return
+
         # test LCS of strings
         assert r.stralgo('LCS', value1, value2) == res
         # test using keys
@@ -1250,6 +1256,12 @@ def test_strlen(self, r):
 
     def test_substr(self, r):
         r['a'] = '0123456789'
+
+        if skip_if_redis_enterprise(None).args[0] is True:
+            with pytest.raises(redis.exceptions.ResponseError):
+                assert r.substr('a', 0) == b'0123456789'
+            return
+
         assert r.substr('a', 0) == b'0123456789'
         assert r.substr('a', 2) == b'23456789'
         assert r.substr('a', 3, 5) == b'345'
@@ -3617,13 +3629,24 @@ def test_memory_doctor(self, r):
 
     @skip_if_server_version_lt('4.0.0')
     def test_memory_malloc_stats(self, r):
+        if skip_if_redis_enterprise(None).args[0] is True:
+            with pytest.raises(redis.exceptions.ResponseError):
+                assert r.memory_malloc_stats()
+            return
+
         assert r.memory_malloc_stats()
 
     @skip_if_server_version_lt('4.0.0')
     def test_memory_stats(self, r):
         # put a key into the current db to make sure that "db.<current-db>"
         # has data
         r.set('foo', 'bar')
+
+        if skip_if_redis_enterprise(None).args[0] is True:
+            with pytest.raises(redis.exceptions.ResponseError):
+                stats = r.memory_stats()
+            return
+
         stats = r.memory_stats()
         assert isinstance(stats, dict)
         for key, value in stats.items():
@@ -3648,6 +3671,14 @@ def test_command_count(self, r):
         assert isinstance(res, int)
         assert res >= 100
 
+    @skip_if_server_version_lt('2.8.13')
+    def test_command(self, r):
+        res = r.command()
+        assert len(res) >= 100
+        cmds = [c[0].decode() for c in res]
+        assert 'set' in cmds
+        assert 'get' in cmds
+
     @skip_if_server_version_lt('4.0.0')
     @skip_if_redis_enterprise
     def test_module(self, r):

tests/test_connection.py

@@ -2,7 +2,7 @@
 import types
 import pytest
 
-from redis.exceptions import InvalidResponse, ModuleError
+from redis.exceptions import InvalidResponse
 from redis.utils import HIREDIS_AVAILABLE
 from .conftest import skip_if_server_version_lt
 
@@ -19,30 +19,20 @@ def test_invalid_response(r):
 
 @skip_if_server_version_lt('4.0.0')
 @pytest.mark.redismod
-def test_loaded_modules(r, modclient):
-    assert r.loaded_modules == []
-    assert 'rejson' in modclient.loaded_modules.keys()
-
-
-@skip_if_server_version_lt('4.0.0')
-@pytest.mark.redismod
-def test_loading_external_modules(r, modclient):
+def test_loading_external_modules(modclient):
     def inner():
         pass
 
-    with pytest.raises(ModuleError):
-        r.load_external_module('rejson', 'myfuncname', inner)
-
-    modclient.load_external_module('rejson', 'myfuncname', inner)
+    modclient.load_external_module('myfuncname', inner)
     assert getattr(modclient, 'myfuncname') == inner
     assert isinstance(getattr(modclient, 'myfuncname'), types.FunctionType)
 
     # and call it
     from redis.commands import RedisModuleCommands
     j = RedisModuleCommands.json
-    modclient.load_external_module('rejson', 'sometestfuncname', j)
+    modclient.load_external_module('sometestfuncname', j)
 
-    d = {'hello': 'world!'}
-    mod = j(modclient)
-    mod.set("fookey", ".", d)
-    assert mod.get('fookey') == d
+    # d = {'hello': 'world!'}
+    # mod = j(modclient)
+    # mod.set("fookey", ".", d)
+    # assert mod.get('fookey') == d

tests/test_search.py

@@ -649,9 +649,6 @@ def test_alias():
     index1 = getClient()
     index2 = getClient()
 
-    index1.hset("index1:lonestar", mapping={"name": "lonestar"})
-    index2.hset("index2:yogurt", mapping={"name": "yogurt"})
-
     def1 = IndexDefinition(prefix=["index1:"])
     def2 = IndexDefinition(prefix=["index2:"])
 
@@ -660,6 +657,9 @@ def test_alias():
     ftindex1.create_index((TextField("name"),), definition=def1)
     ftindex2.create_index((TextField("name"),), definition=def2)
 
+    index1.hset("index1:lonestar", mapping={"name": "lonestar"})
+    index2.hset("index2:yogurt", mapping={"name": "yogurt"})
+
     res = ftindex1.search("*").docs[0]
     assert "index1:lonestar" == res.id