Merge remote-tracking branch 'redis/master'

Author: utkarshgupta137

redis/client.py

@@ -757,7 +757,6 @@ class AbstractRedis:
         "DEBUG OBJECT": parse_debug_object,
         "FUNCTION DELETE": bool_ok,
         "FUNCTION FLUSH": bool_ok,
-        "FUNCTION LOAD": bool_ok,
         "FUNCTION RESTORE": bool_ok,
         "GEOHASH": lambda r: list(map(str_if_bytes, r)),
         "GEOPOS": lambda r: list(

redis/commands/core.py

@@ -743,6 +743,14 @@ def command_info(self, **kwargs) -> None:
     def command_count(self, **kwargs) -> ResponseT:
         return self.execute_command("COMMAND COUNT", **kwargs)
 
+    def command_getkeysandflags(self, *args: List[str]) -> List[Union[str, List[str]]]:
+        """
+        Returns array of keys from a full Redis command and their usage flags.
+
+        For more information see https://redis.io/commands/command-getkeysandflags
+        """
+        return self.execute_command("COMMAND GETKEYSANDFLAGS", *args)
+
     def command_docs(self, *args):
         """
         This function throws a NotImplementedError since it is intentionally
@@ -752,20 +760,28 @@ def command_docs(self, *args):
             "COMMAND DOCS is intentionally not implemented in the client."
         )
 
-    def config_get(self, pattern: PatternT = "*", **kwargs) -> ResponseT:
+    def config_get(
+        self, pattern: PatternT = "*", *args: List[PatternT], **kwargs
+    ) -> ResponseT:
         """
         Return a dictionary of configuration based on the ``pattern``
 
         For more information see https://redis.io/commands/config-get
         """
-        return self.execute_command("CONFIG GET", pattern, **kwargs)
+        return self.execute_command("CONFIG GET", pattern, *args, **kwargs)
 
-    def config_set(self, name: KeyT, value: EncodableT, **kwargs) -> ResponseT:
+    def config_set(
+        self,
+        name: KeyT,
+        value: EncodableT,
+        *args: List[Union[KeyT, EncodableT]],
+        **kwargs,
+    ) -> ResponseT:
         """Set config item ``name`` with ``value``
 
         For more information see https://redis.io/commands/config-set
         """
-        return self.execute_command("CONFIG SET", name, value, **kwargs)
+        return self.execute_command("CONFIG SET", name, value, *args, **kwargs)
 
     def config_resetstat(self, **kwargs) -> ResponseT:
         """
@@ -884,7 +900,9 @@ def select(self, index: int, **kwargs) -> ResponseT:
         """
         return self.execute_command("SELECT", index, **kwargs)
 
-    def info(self, section: Union[str, None] = None, **kwargs) -> ResponseT:
+    def info(
+        self, section: Union[str, None] = None, *args: List[str], **kwargs
+    ) -> ResponseT:
         """
         Returns a dictionary containing information about the Redis server
 
@@ -899,7 +917,7 @@ def info(self, section: Union[str, None] = None, **kwargs) -> ResponseT:
         if section is None:
             return self.execute_command("INFO", **kwargs)
         else:
-            return self.execute_command("INFO", section, **kwargs)
+            return self.execute_command("INFO", section, *args, **kwargs)
 
     def lastsave(self, **kwargs) -> ResponseT:
         """
@@ -5574,6 +5592,27 @@ def module_load(self, path, *args) -> ResponseT:
         """
         return self.execute_command("MODULE LOAD", path, *args)
 
+    def module_loadex(
+        self,
+        path: str,
+        options: Optional[List[str]] = None,
+        args: Optional[List[str]] = None,
+    ) -> ResponseT:
+        """
+        Loads a module from a dynamic library at runtime with configuration directives.
+
+        For more information see https://redis.io/commands/module-loadex
+        """
+        pieces = []
+        if options is not None:
+            pieces.append("CONFIG")
+            pieces.extend(options)
+        if args is not None:
+            pieces.append("ARGS")
+            pieces.extend(args)
+
+        return self.execute_command("MODULE LOADEX", path, *pieces)
+
     def module_unload(self, name) -> ResponseT:
         """
         Unloads the module ``name``.
@@ -5703,28 +5742,20 @@ class FunctionCommands:
 
     def function_load(
         self,
-        engine: str,
-        library: str,
         code: str,
         replace: Optional[bool] = False,
-        description: Optional[str] = None,
     ) -> Union[Awaitable[str], str]:
         """
         Load a library to Redis.
-        :param engine: the name of the execution engine for the library
-        :param library: the unique name of the library
-        :param code: the source code
-        :param replace: changes the behavior to replace the library if a library called
-         ``library`` already exists
-        :param description: description to the library
+        :param code: the source code (must start with
+        Shebang statement that provides a metadata about the library)
+        :param replace: changes the behavior to overwrite the existing library
+        with the new contents.
+        Return the library name that was loaded.
 
         For more information see https://redis.io/commands/function-load
         """
-        pieces = [engine, library]
-        if replace:
-            pieces.append("REPLACE")
-        if description is not None:
-            pieces.append(description)
+        pieces = ["REPLACE"] if replace else []
         pieces.append(code)
         return self.execute_command("FUNCTION LOAD", *pieces)
 

redis/commands/search/field.py

@@ -105,11 +105,20 @@ class TagField(Field):
     """
 
     SEPARATOR = "SEPARATOR"
+    CASESENSITIVE = "CASESENSITIVE"
 
-    def __init__(self, name: str, separator: str = ",", **kwargs):
-        Field.__init__(
-            self, name, args=[Field.TAG, self.SEPARATOR, separator], **kwargs
-        )
+    def __init__(
+        self,
+        name: str,
+        separator: str = ",",
+        case_sensitive: bool = False,
+        **kwargs,
+    ):
+        args = [Field.TAG, self.SEPARATOR, separator]
+        if case_sensitive:
+            args.append(self.CASESENSITIVE)
+
+        Field.__init__(self, name, args=args, **kwargs)
 
 
 class VectorField(Field):

tests/test_commands.py

@@ -669,6 +669,12 @@ def test_config_get(self, r):
         # # assert 'maxmemory' in data
         # assert data['maxmemory'].isdigit()
 
+    @skip_if_server_version_lt("7.0.0")
+    def test_config_get_multi_params(self, r: redis.Redis):
+        res = r.config_get("*max-*-entries*", "maxmemory")
+        assert "maxmemory" in res
+        assert "hash-max-listpack-entries" in res
+
     @pytest.mark.onlynoncluster
     @skip_if_redis_enterprise()
     def test_config_resetstat(self, r):
@@ -686,6 +692,16 @@ def test_config_set(self, r):
         assert r.config_set("timeout", 0)
         assert r.config_get()["timeout"] == "0"
 
+    @skip_if_server_version_lt("7.0.0")
+    @skip_if_redis_enterprise()
+    def test_config_set_multi_params(self, r: redis.Redis):
+        r.config_set("timeout", 70, "maxmemory", 100)
+        assert r.config_get()["timeout"] == "70"
+        assert r.config_get()["maxmemory"] == "100"
+        assert r.config_set("timeout", 0, "maxmemory", 0)
+        assert r.config_get()["timeout"] == "0"
+        assert r.config_get()["maxmemory"] == "0"
+
     @skip_if_server_version_lt("6.0.0")
     @skip_if_redis_enterprise()
     def test_failover(self, r):
@@ -711,6 +727,14 @@ def test_info(self, r):
         assert "arch_bits" in info.keys()
         assert "redis_version" in info.keys()
 
+    @pytest.mark.onlynoncluster
+    @skip_if_server_version_lt("7.0.0")
+    def test_info_multi_sections(self, r):
+        res = r.info("clients", "server")
+        assert isinstance(res, dict)
+        assert "redis_version" in res
+        assert "connected_clients" in res
+
     @pytest.mark.onlynoncluster
     @skip_if_redis_enterprise()
     def test_lastsave(self, r):
@@ -4468,6 +4492,15 @@ def test_command(self, r):
         assert "set" in cmds
         assert "get" in cmds
 
+    @pytest.mark.onlynoncluster
+    @skip_if_server_version_lt("7.0.0")
+    @skip_if_redis_enterprise()
+    def test_command_getkeysandflags(self, r: redis.Redis):
+        res = [["mylist1", ["RW", "access", "delete"]], ["mylist2", ["RW", "insert"]]]
+        assert res == r.command_getkeysandflags(
+            "LMOVE", "mylist1", "mylist2", "left", "left"
+        )
+
     @pytest.mark.onlynoncluster
     @skip_if_server_version_lt("4.0.0")
     @skip_if_redis_enterprise()
@@ -4480,6 +4513,18 @@ def test_module(self, r):
             r.module_load("/some/fake/path", "arg1", "arg2", "arg3", "arg4")
             assert "Error loading the extension." in str(excinfo.value)
 
+    @pytest.mark.onlynoncluster
+    @skip_if_server_version_lt("7.0.0")
+    @skip_if_redis_enterprise()
+    def test_module_loadex(self, r: redis.Redis):
+        with pytest.raises(redis.exceptions.ModuleError) as excinfo:
+            r.module_loadex("/some/fake/path")
+            assert "Error loading the extension." in str(excinfo.value)
+
+        with pytest.raises(redis.exceptions.ModuleError) as excinfo:
+            r.module_loadex("/some/fake/path", ["name", "value"], ["arg1", "arg2"])
+            assert "Error loading the extension." in str(excinfo.value)
+
     @skip_if_server_version_lt("2.6.0")
     def test_restore(self, r):
 

tests/test_function.py

@@ -4,12 +4,16 @@
 
 from .conftest import skip_if_server_version_lt
 
-function = "redis.register_function('myfunc', function(keys, args) return args[1] end)"
+engine = "lua"
+lib = "mylib"
+lib2 = "mylib2"
+function = "redis.register_function{function_name='myfunc', callback=function(keys, \
+            args) return args[1] end, flags={ 'no-writes' }}"
 function2 = "redis.register_function('hello', function() return 'Hello World' end)"
-set_function = "redis.register_function('set', function(keys, args) \
-                return redis.call('SET', keys[1], args[1]) end)"
-get_function = "redis.register_function('get', function(keys, args) \
-                return redis.call('GET', keys[1]) end)"
+set_function = "redis.register_function('set', function(keys, args) return \
+                redis.call('SET', keys[1], args[1]) end)"
+get_function = "redis.register_function('get', function(keys, args) return \
+                redis.call('GET', keys[1]) end)"
 
 
 @skip_if_server_version_lt("7.0.0")
@@ -19,25 +23,28 @@ def reset_functions(self, r):
         r.function_flush()
 
     def test_function_load(self, r):
-        assert r.function_load("Lua", "mylib", function)
-        assert r.function_load("Lua", "mylib", function, replace=True)
+        print("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!")
+        assert lib == r.function_load(f"#!{engine} name={lib} \n {function}")
+        assert lib == r.function_load(
+            f"#!{engine} name={lib} \n {function}", replace=True
+        )
         with pytest.raises(ResponseError):
-            r.function_load("Lua", "mylib", function)
+            r.function_load(f"#!{engine} name={lib} \n {function}")
         with pytest.raises(ResponseError):
-            r.function_load("Lua", "mylib2", function)
+            r.function_load(f"#!{engine} name={lib2} \n {function}")
 
     def test_function_delete(self, r):
-        r.function_load("Lua", "mylib", set_function)
+        r.function_load(f"#!{engine} name={lib} \n {set_function}")
         with pytest.raises(ResponseError):
-            r.function_load("Lua", "mylib", set_function)
+            r.function_load(f"#!{engine} name={lib} \n {set_function}")
         assert r.fcall("set", 1, "foo", "bar") == "OK"
         assert r.function_delete("mylib")
         with pytest.raises(ResponseError):
             r.fcall("set", 1, "foo", "bar")
-        assert r.function_load("Lua", "mylib", set_function)
+        assert lib == r.function_load(f"#!{engine} name={lib} \n {set_function}")
 
     def test_function_flush(self, r):
-        r.function_load("Lua", "mylib", function)
+        r.function_load(f"#!{engine} name={lib} \n {function}")
         assert r.fcall("myfunc", 0, "hello") == "hello"
         assert r.function_flush()
         with pytest.raises(ResponseError):
@@ -47,36 +54,35 @@ def test_function_flush(self, r):
 
     @pytest.mark.onlynoncluster
     def test_function_list(self, r):
-        r.function_load("Lua", "mylib", function)
+        r.function_load(f"#!{engine} name={lib} \n {function}")
         res = [
             [
                 "library_name",
                 "mylib",
                 "engine",
                 "LUA",
-                "description",
-                None,
                 "functions",
-                [["name", "myfunc", "description", None]],
+                [["name", "myfunc", "description", None, "flags", ["no-writes"]]],
             ],
         ]
         assert r.function_list() == res
         assert r.function_list(library="*lib") == res
-        assert r.function_list(withcode=True)[0][9] == function
+        assert (
+            r.function_list(withcode=True)[0][7]
+            == f"#!{engine} name={lib} \n {function}"
+        )
 
     @pytest.mark.onlycluster
     def test_function_list_on_cluster(self, r):
-        r.function_load("Lua", "mylib", function)
+        r.function_load(f"#!{engine} name={lib} \n {function}")
         function_list = [
             [
                 "library_name",
                 "mylib",
                 "engine",
                 "LUA",
-                "description",
-                None,
                 "functions",
-                [["name", "myfunc", "description", None]],
+                [["name", "myfunc", "description", None, "flags", ["no-writes"]]],
             ],
         ]
         primaries = r.get_primaries()
@@ -86,33 +92,36 @@ def test_function_list_on_cluster(self, r):
         assert r.function_list() == res
         assert r.function_list(library="*lib") == res
         node = primaries[0].name
-        assert r.function_list(withcode=True)[node][0][9] == function
+        assert (
+            r.function_list(withcode=True)[node][0][7]
+            == f"#!{engine} name={lib} \n {function}"
+        )
 
     def test_fcall(self, r):
-        r.function_load("Lua", "mylib", set_function)
-        r.function_load("Lua", "mylib2", get_function)
+        r.function_load(f"#!{engine} name={lib} \n {set_function}")
+        r.function_load(f"#!{engine} name={lib2} \n {get_function}")
         assert r.fcall("set", 1, "foo", "bar") == "OK"
         assert r.fcall("get", 1, "foo") == "bar"
         with pytest.raises(ResponseError):
             r.fcall("myfunc", 0, "hello")
 
     def test_fcall_ro(self, r):
-        r.function_load("Lua", "mylib", function)
+        r.function_load(f"#!{engine} name={lib} \n {function}")
         assert r.fcall_ro("myfunc", 0, "hello") == "hello"
-        r.function_load("Lua", "mylib2", set_function)
+        r.function_load(f"#!{engine} name={lib2} \n {set_function}")
         with pytest.raises(ResponseError):
             r.fcall_ro("set", 1, "foo", "bar")
 
     def test_function_dump_restore(self, r):
-        r.function_load("Lua", "mylib", set_function)
+        r.function_load(f"#!{engine} name={lib} \n {set_function}")
         payload = r.function_dump()
         assert r.fcall("set", 1, "foo", "bar") == "OK"
         r.function_delete("mylib")
         with pytest.raises(ResponseError):
             r.fcall("set", 1, "foo", "bar")
         assert r.function_restore(payload)
         assert r.fcall("set", 1, "foo", "bar") == "OK"
-        r.function_load("Lua", "mylib2", get_function)
+        r.function_load(f"#!{engine} name={lib2} \n {get_function}")
         assert r.fcall("get", 1, "foo") == "bar"
         r.function_delete("mylib")
         assert r.function_restore(payload, "FLUSH")