SCRIPTEXECUTE support

redisai/__init__.py

@@ -1,3 +1,3 @@
-from .client import Client
+from .client import Client  # noqa
 
 __version__ = "1.0.2"

redisai/client.py

@@ -1,6 +1,6 @@
 import warnings
-from functools import partial, wraps
-from typing import Any, AnyStr, ByteString, List, Sequence, Union
+from functools import wraps
+from typing import AnyStr, ByteString, List, Sequence, Union
 
 import numpy as np
 from deprecated import deprecated
@@ -65,8 +65,8 @@ def pipeline(self, transaction: bool = True, shard_hint: bool = None) -> "Pipeli
             self.enable_postprocess,
             self.connection_pool,
             self.response_callbacks,
-            transaction=True,
-            shard_hint=None,
+            transaction=transaction,
+            shard_hint=shard_hint,
         )
 
     def dag(
@@ -622,6 +622,7 @@ def scriptdel(self, key: AnyStr) -> str:
         res = self.execute_command(*args)
         return res if not self.enable_postprocess else processor.scriptdel(res)
 
+    @deprecated(version="1.2.0", reason="Use scriptexecute instead")
     def scriptrun(
         self,
         key: AnyStr,
@@ -642,7 +643,7 @@ def scriptrun(
             Tensor(s) which is already saved in the RedisAI using a tensorset call. These
             tensors will be used as the input for the modelrun
         outputs : Union[AnyStr, List[AnyStr]]
-            keys on which the outputs to be saved. If those keys exist already, modelrun
+            keys on which the outputs to be saved. If those keys exist already, scriptrun
             will overwrite them with new values
 
         Returns
@@ -659,6 +660,61 @@ def scriptrun(
         res = self.execute_command(*args)
         return res if not self.enable_postprocess else processor.scriptrun(res)
 
+    def scriptexecute(
+        self,
+        key: AnyStr,
+        function: str,
+        keys: Union[AnyStr, Sequence[AnyStr]],
+        inputs: Union[AnyStr, Sequence[Union[AnyStr, Sequence[AnyStr]]]] = None,
+        outputs: Union[AnyStr, Sequence[AnyStr]] = None,
+        timeout: int = None,
+    ) -> str:
+        """
+        Run an already set script. Similar to modelexecute
+
+        Parameters
+        ----------
+        key : AnyStr
+            Script key
+        function : str
+            Name of the function in the ``script``
+        keys : Union[AnyStr, Sequence[AnyStr]]
+            Either a squence of key names that the script will access before, during and
+            after its execution, or a tag which all those keys share.
+        inputs : Union[AnyStr, Sequence[Union[AnyStr, Sequence[AnyStr]]]]
+            The inputs can be tensor key name, string , int or float.
+            These inputs will be used as the input for the scriptexecute function.
+            The order of the input should be aligned with the order of their respected
+            parameter at the function signature.
+            When one of the elements in the inputs list is a list (or a tuple), that element
+            will be treated as LIST_INPUTS in the command executaion.
+        outputs : Union[AnyStr, List[AnyStr]]
+            keys on which the outputs to be saved. If those keys exist already, scriptexecute
+            will overwrite them with new values.
+        timeout : int
+            The max number on milisecinds that may pass before the request is prossced
+            (meaning that the result will not be computed after that time and TIMEDOUT
+            is returned in that case).
+
+        Returns
+        -------
+        str
+            'OK' if success, raise an exception otherwise
+
+        Example
+        -------
+        >>> con.scriptexecute('ket', 'bar', keys=['a', 'b', 'c'], inputs=['a', 'b'], outputs=['c'])
+        'OK'
+        >>> con.scriptexecute('myscript{tag}', 'addn',
+        >>>                   keys=['{tag}'],
+        >>>                   inputs=['mytensor1{tag}', ['mytensor2{tag}', 'mytensor3{tag}']],
+        >>>                   outputs=['result{tag}'])
+        'OK'
+        """
+        args = builder.scriptexecute(key, function, keys, inputs, outputs, timeout)
+        res = self.execute_command(*args)
+        return res if not self.enable_postprocess else processor.scriptexecute(res)
+
     def scriptscan(self) -> List[List[AnyStr]]:
         """
         Returns the list of all the script in the RedisAI server. Scriptscan API is

redisai/command_builder.py

@@ -64,7 +64,7 @@ def modelstore(
             "Inputs and outputs keywords should not be specified for this backend"
         )
     chunk_size = 500 * 1024 * 1024  # TODO: this should be configurable.
-    data_chunks = [data[i : i + chunk_size] for i in range(0, len(data), chunk_size)]
+    data_chunks = [data[i: i + chunk_size] for i in range(0, len(data), chunk_size)]
     # TODO: need a test case for this
     args += ["BLOB", *data_chunks]
     return args
@@ -102,7 +102,7 @@ def modelset(
         args += ["INPUTS", *utils.listify(inputs)]
         args += ["OUTPUTS", *utils.listify(outputs)]
     chunk_size = 500 * 1024 * 1024
-    data_chunks = [data[i : i + chunk_size] for i in range(0, len(data), chunk_size)]
+    data_chunks = [data[i: i + chunk_size] for i in range(0, len(data), chunk_size)]
     # TODO: need a test case for this
     args += ["BLOB", *data_chunks]
     return args
@@ -228,10 +228,12 @@ def scriptdel(name: AnyStr) -> Sequence:
 
 def scriptrun(
     name: AnyStr,
-    function: AnyStr,
+    function: str,
     inputs: Union[AnyStr, Sequence[AnyStr]],
     outputs: Union[AnyStr, Sequence[AnyStr]],
 ) -> Sequence:
+    if name is None or function is None:
+        raise ValueError("Missing required arguments for script run command")
     args = (
         "AI.SCRIPTRUN",
         name,
@@ -243,6 +245,46 @@ def scriptrun(
     )
     return args
 
+def scriptexecute(
+    name: AnyStr,
+    function: str,
+    keys: Union[AnyStr, Sequence[AnyStr]],
+    inputs: Union[AnyStr, Sequence[Union[AnyStr, Sequence[AnyStr]]]],
+    outputs: Union[AnyStr, Sequence[AnyStr]],
+    timeout: int,
+) -> Sequence:
+    if name is None or function is None or keys is None:
+        raise ValueError("Missing required arguments for script execute command")
+    args = [
+        "AI.SCRIPTEXECUTE",
+        name,
+        function,
+        "KEYS",
+        len(utils.listify(keys)),
+        *utils.listify(keys),
+    ]
+
+    if inputs is not None:
+        temp_inputs = []
+        if not isinstance(inputs, (list, tuple)):
+            args += ["INPUTS", 1, inputs]
+        else:
+            for elem in inputs:
+                if isinstance(elem, (list, tuple)):
+                    if temp_inputs:
+                        args += ["INPUTS", len(temp_inputs), *temp_inputs]
+                        temp_inputs = []
+                    args += ["LIST_INPUTS", len(utils.listify(elem)), *utils.listify(elem)]
+                else:
+                    temp_inputs.append(elem)
+            if temp_inputs:
+                args += ["INPUTS", len(temp_inputs), *temp_inputs]
+    if outputs is not None:
+        args += ["OUTPUTS", len(utils.listify(outputs)), *utils.listify(outputs)]
+    if timeout is not None:
+        args += ["TIMEOUT", timeout]
+
+    return args
 
 def scriptscan() -> Sequence:
     return ("AI._SCRIPTSCAN",)

redisai/dag.py

@@ -1,10 +1,11 @@
 from functools import partial
-from typing import Any, AnyStr, List, Sequence, Union
+from typing import AnyStr, Union, Sequence, Any, List
 
 import numpy as np
 
-from redisai import command_builder as builder
 from redisai.postprocessor import Processor
+from redisai import command_builder as builder
+
 
 processor = Processor()
 

redisai/pipeline.py

@@ -1,13 +1,14 @@
 import warnings
 from functools import partial
-from typing import AnyStr, Sequence, Union
+from typing import AnyStr, Union, Sequence
 
 import numpy as np
-import redis
 
 from redisai import command_builder as builder
+import redis
 from redisai.postprocessor import Processor
 
+
 processor = Processor()
 
 

redisai/postprocessor.py

@@ -63,15 +63,14 @@ def infoget(res):
 decoder = staticmethod(decoder)
 decoding_functions = (
     "loadbackend",
-    "modelstore",
     "modelset",
     "modeldel",
-    "modelexecute",
     "modelrun",
     "tensorset",
     "scriptset",
     "scriptdel",
     "scriptrun",
+    "scriptexecute",
     "inforeset",
 )
 for fn in decoding_functions:

redisai/utils.py

@@ -1,7 +1,7 @@
-from typing import AnyStr, ByteString, Callable, List, Sequence, Union
-
+from typing import Union, ByteString, Sequence, List, AnyStr, Callable
 import numpy as np
 
+
 dtype_dict = {
     "float": "FLOAT",
     "double": "DOUBLE",