Added support for MODELGET, MODELDEL, SCRIPTGEL, SCRIPTDEL (#15)

* [add] support for MODELGET, MODELDEL, SCRIPTGEL, SCRIPTDEL

* [add] added test for setTensor variations

* [add] extended negative testing

* [fix] following lowerCamelCase per review

* [fix] fixing Variable script may be null here because of assignement on Model and Script.

* [add] moving from ArrayList<byte[]>... signature to generic List<byte[]>... one

* [add] Support for BATCHSIZE, MINBATCHSIZE, INPUTS and OUTPUTS on AI.MODELGET. [fix] fixes per PR review

* [fix] fixed long dim to int dim per PR review

* [add] added a Model constructor that accepts batchsize and minbatchsize as parameters

* [add] Added script constructor given the device string and the Path containing the script. ensuring same behaviour across different command method wrappers for the same redisai command

* [add] throwing an error on model/tensor/script creation if reply does not contain all elements. Added negative testing for resp parsing

* [fix] per PR review

Author: filipecosta90

src/main/java/com/redislabs/redisai/Backend.java

@@ -5,7 +5,9 @@
 
 public enum Backend implements ProtocolCommand {
   TF,
-  TORCH;
+  TORCH,
+  TFLITE,
+  ONNX;
 
   private final byte[] raw;
 

src/main/java/com/redislabs/redisai/Command.java

@@ -8,10 +8,16 @@ public enum Command implements ProtocolCommand {
   TENSOR_SET("AI.TENSORSET"),
   MODEL_GET("AI.MODELGET"),
   MODEL_SET("AI.MODELSET"),
+  MODEL_DEL("AI.MODELDEL"),
   MODEL_RUN("AI.MODELRUN"),
-  SCRIPT_GET("AI.SCRIPTGET"),
   SCRIPT_SET("AI.SCRIPTSET"),
+  SCRIPT_GET("AI.SCRIPTGET"),
+  SCRIPT_DEL("AI.SCRIPTDEL"),
   SCRIPT_RUN("AI.SCRIPTRUN"),
+  // TODO: support AI.DAGRUN
+  DAGRUN("AI.DAGRUN"),
+  // TODO: support AI.DAGRUN_RO
+  DAGRUN_RO("AI.DAGRUN_RO"),
   INFO("AI.INFO"),
   CONFIG("AI.CONFIG");
 

src/main/java/com/redislabs/redisai/DataType.java

@@ -88,43 +88,8 @@ protected Object toObject(List<byte[]> data) {
       }
       return values;
     }
-  },
-  STRING {
-    @Override
-    public List<byte[]> toByteArray(Object obj) {
-      byte[] values = (byte[]) obj;
-      List<byte[]> res = new ArrayList<>(values.length);
-      for (byte value : values) {
-        res.add(Protocol.toByteArray(value));
-      }
-      return res;
-    }
-
-    @Override
-    protected Object toObject(List<byte[]> data) {
-      return data;
-    }
-  },
-  BOOL {
-    @Override
-    public List<byte[]> toByteArray(Object obj) {
-      boolean[] values = (boolean[]) obj;
-      List<byte[]> res = new ArrayList<>(values.length);
-      for (boolean value : values) {
-        res.add(Protocol.toByteArray(value));
-      }
-      return res;
-    }
-
-    @Override
-    protected Object toObject(List<byte[]> data) {
-      // TODO Auto-generated method stub
-      return null;
-    }
   };
 
-  private final byte[] raw;
-
   private static final HashMap<Class<?>, DataType> classDataTypes = new HashMap<>();
 
   static {
@@ -136,12 +101,10 @@ protected Object toObject(List<byte[]> data) {
     classDataTypes.put(Float.class, DataType.FLOAT);
     classDataTypes.put(double.class, DataType.DOUBLE);
     classDataTypes.put(Double.class, DataType.DOUBLE);
-    classDataTypes.put(byte.class, DataType.STRING);
-    classDataTypes.put(Byte.class, DataType.STRING);
-    classDataTypes.put(boolean.class, DataType.BOOL);
-    classDataTypes.put(Boolean.class, DataType.BOOL);
   }
 
+  private final byte[] raw;
+
   DataType() {
     raw = SafeEncoder.encode(this.name());
   }
@@ -163,18 +126,6 @@ static DataType getDataTypefromString(String dtypeRaw) {
     return dt;
   }
 
-  protected abstract List<byte[]> toByteArray(Object obj);
-
-  protected abstract Object toObject(List<byte[]> data);
-
-  public byte[] getRaw() {
-    return raw;
-  }
-
-  public List<byte[]> toByteArray(Object obj, int[] dimensions) {
-    return toByteArray(obj, dimensions, 0, this);
-  }
-
   /** The class for the data type to which Java object o corresponds. */
   public static DataType baseObjType(Object o) {
     Class<?> c = o.getClass();
@@ -188,10 +139,10 @@ public static DataType baseObjType(Object o) {
     throw new IllegalArgumentException("cannot create Tensors of type " + c.getName());
   }
 
-  private static List<byte[]> toByteArray(Object obj, int[] dimensions, int dim, DataType type) {
+  private static List<byte[]> toByteArray(Object obj, long[] dimensions, int dim, DataType type) {
     ArrayList<byte[]> res = new ArrayList<>();
-    if (dimensions.length > dim + 1) {
-      int dimension = dimensions[dim++];
+    if (dimensions.length - 1 > dim) {
+      long dimension = dimensions[dim++];
       for (int i = 0; i < dimension; ++i) {
         Object value = Array.get(obj, i);
         res.addAll(toByteArray(value, dimensions, dim, type));
@@ -201,4 +152,16 @@ private static List<byte[]> toByteArray(Object obj, int[] dimensions, int dim, D
     }
     return res;
   }
+
+  protected abstract List<byte[]> toByteArray(Object obj);
+
+  protected abstract Object toObject(List<byte[]> data);
+
+  public byte[] getRaw() {
+    return raw;
+  }
+
+  public List<byte[]> toByteArray(Object obj, long[] dimensions) {
+    return toByteArray(obj, dimensions, 0, this);
+  }
 }

src/main/java/com/redislabs/redisai/Keyword.java

@@ -12,6 +12,9 @@ public enum Keyword implements ProtocolCommand {
   BLOB,
   SOURCE,
   RESETSTAT,
+  TAG,
+  BATCHSIZE,
+  MINBATCHSIZE,
   BACKENDSPATH,
   LOADBACKEND;
 

src/main/java/com/redislabs/redisai/Model.java

@@ -0,0 +1,236 @@
+package com.redislabs.redisai;
+
+import com.redislabs.redisai.exceptions.JRedisAIRunTimeException;
+import java.util.ArrayList;
+import java.util.List;
+import redis.clients.jedis.Protocol;
+import redis.clients.jedis.util.SafeEncoder;
+
+/** Direct mapping to RedisAI Model */
+public class Model {
+  private Backend backend;
+  private Device device;
+  private String[] inputs;
+  private String[] outputs;
+  private byte[] blob;
+  private String tag;
+  private long batchSize;
+  private long minBatchSize;
+
+  /**
+   * @param backend - the backend for the model. can be one of TF, TFLITE, TORCH or ONNX
+   * @param device - the device that will execute the model. can be of CPU or GPU
+   * @param inputs - one or more names of the model's input nodes (applicable only for TensorFlow
+   *     models)
+   * @param outputs - one or more names of the model's output nodes (applicable only for TensorFlow
+   *     models)
+   * @param blob - the Protobuf-serialized model
+   */
+  public Model(Backend backend, Device device, String[] inputs, String[] outputs, byte[] blob) {
+    this(backend, device, inputs, outputs, blob, 0, 0);
+  }
+
+  /**
+   * @param backend - the backend for the model. can be one of TF, TFLITE, TORCH or ONNX
+   * @param device - the device that will execute the model. can be of CPU or GPU
+   * @param inputs - one or more names of the model's input nodes (applicable only for TensorFlow
+   *     models)
+   * @param outputs - one or more names of the model's output nodes (applicable only for TensorFlow
+   *     models)
+   * @param blob - the Protobuf-serialized model
+   * @param batchSize - when provided with an batchsize that is greater than 0, the engine will
+   *     batch incoming requests from multiple clients that use the model with input tensors of the
+   *     same shape.
+   * @param minBatchSize - when provided with an minbatchsize that is greater than 0, the engine
+   *     will postpone calls to AI.MODELRUN until the batch's size had reached minbatchsize
+   */
+  public Model(
+      Backend backend,
+      Device device,
+      String[] inputs,
+      String[] outputs,
+      byte[] blob,
+      long batchSize,
+      long minBatchSize) {
+    this.backend = backend;
+    this.device = device;
+    this.inputs = inputs;
+    this.outputs = outputs;
+    this.blob = blob;
+    this.tag = null;
+    this.batchSize = batchSize;
+    this.minBatchSize = minBatchSize;
+  }
+
+  public static Model createModelFromRespReply(List<?> reply) {
+    Model model = null;
+    Backend backend = null;
+    Device device = null;
+    String tag = null;
+    byte[] blob = null;
+    long batchsize = 0;
+    long minbatchsize = 0;
+    String[] inputs = new String[0];
+    String[] outputs = new String[0];
+    for (int i = 0; i < reply.size(); i += 2) {
+      String arrayKey = SafeEncoder.encode((byte[]) reply.get(i));
+      switch (arrayKey) {
+        case "backend":
+          String backendString = SafeEncoder.encode((byte[]) reply.get(i + 1));
+          backend = Backend.valueOf(backendString);
+          if (backend == null) {
+            throw new JRedisAIRunTimeException("Unrecognized backend: " + backendString);
+          }
+          break;
+        case "device":
+          String deviceString = SafeEncoder.encode((byte[]) reply.get(i + 1));
+          device = Device.valueOf(deviceString);
+          if (device == null) {
+            throw new JRedisAIRunTimeException("Unrecognized device: " + deviceString);
+          }
+          break;
+        case "tag":
+          tag = SafeEncoder.encode((byte[]) reply.get(i + 1));
+          break;
+        case "blob":
+          blob = (byte[]) reply.get(i + 1);
+          break;
+        case "batchsize":
+          batchsize = (Long) reply.get(i + 1);
+          break;
+        case "minbatchsize":
+          minbatchsize = (Long) reply.get(i + 1);
+          break;
+        case "inputs":
+          List<byte[]> inputsEncoded = (List<byte[]>) reply.get(i + 1);
+          if (inputsEncoded.size() > 0) {
+            inputs = new String[inputsEncoded.size()];
+            for (int j = 0; j < inputsEncoded.size(); j++) {
+              inputs[j] = SafeEncoder.encode(inputsEncoded.get(j));
+            }
+          }
+          break;
+        case "outputs":
+          List<byte[]> outputsEncoded = (List<byte[]>) reply.get(i + 1);
+          if (outputsEncoded.size() > 0) {
+            outputs = new String[outputsEncoded.size()];
+            for (int j = 0; j < outputsEncoded.size(); j++) {
+              outputs[j] = SafeEncoder.encode(outputsEncoded.get(j));
+            }
+          }
+          break;
+        default:
+          break;
+      }
+    }
+    if (backend == null || device == null || blob == null) {
+      throw new JRedisAIRunTimeException(
+          "AI.MODELGET reply did not contained all elements to build the model");
+    }
+    model = new Model(backend, device, inputs, outputs, blob, batchsize, minbatchsize);
+    if (tag != null) {
+      model.setTag(tag);
+    }
+    return model;
+  }
+
+  public String getTag() {
+    return tag;
+  }
+
+  public void setTag(String tag) {
+    this.tag = tag;
+  }
+
+  public byte[] getBlob() {
+    return blob;
+  }
+
+  public void setBlob(byte[] blob) {
+    this.blob = blob;
+  }
+
+  public String[] getOutputs() {
+    return outputs;
+  }
+
+  public void setOutputs(String[] outputs) {
+    this.outputs = outputs;
+  }
+
+  public String[] getInputs() {
+    return inputs;
+  }
+
+  public void setInputs(String[] inputs) {
+    this.inputs = inputs;
+  }
+
+  public Device getDevice() {
+    return device;
+  }
+
+  public void setDevice(Device device) {
+    this.device = device;
+  }
+
+  public Backend getBackend() {
+    return backend;
+  }
+
+  public void setBackend(Backend backend) {
+    this.backend = backend;
+  }
+
+  public long getBatchSize() {
+    return batchSize;
+  }
+
+  public void setBatchSize(long batchsize) {
+    this.batchSize = batchsize;
+  }
+
+  public long getMinBatchSize() {
+    return minBatchSize;
+  }
+
+  public void setMinBatchSize(long minbatchsize) {
+    this.minBatchSize = minbatchsize;
+  }
+
+  /**
+   * Encodes the current model properties into an AI.MODELSET command to be store in RedisAI Server
+   *
+   * @param key name of key to store the Model
+   * @return
+   */
+  protected List<byte[]> getModelSetCommandBytes(String key) {
+    List<byte[]> args = new ArrayList<>();
+    args.add(SafeEncoder.encode(key));
+    args.add(backend.getRaw());
+    args.add(device.getRaw());
+    if (tag != null) {
+      args.add(Keyword.TAG.getRaw());
+      args.add(SafeEncoder.encode(tag));
+    }
+    if (batchSize > 0) {
+      args.add(Keyword.BATCHSIZE.getRaw());
+      args.add(Protocol.toByteArray(batchSize));
+      if (minBatchSize > 0) {
+        args.add(Keyword.MINBATCHSIZE.getRaw());
+        args.add(Protocol.toByteArray(minBatchSize));
+      }
+    }
+    args.add(Keyword.INPUTS.getRaw());
+    for (String input : inputs) {
+      args.add(SafeEncoder.encode(input));
+    }
+    args.add(Keyword.OUTPUTS.getRaw());
+    for (String output : outputs) {
+      args.add(SafeEncoder.encode(output));
+    }
+    args.add(Keyword.BLOB.getRaw());
+    args.add(blob);
+    return args;
+  }
+}