Improve argument type checking (triton-inference-server#134)

* Improve argument type checking

* Review edit

Author: Tabrizian

src/infer_request.cc

@@ -41,10 +41,27 @@ InferRequest::InferRequest(
     const std::vector<std::string>& requested_output_names,
     const std::string& model_name, const int64_t model_version,
     const uint32_t flags)
-    : request_id_(request_id), correlation_id_(correlation_id), inputs_(inputs),
-      requested_output_names_(requested_output_names), model_name_(model_name),
-      model_version_(model_version), flags_(flags)
+    : request_id_(request_id), correlation_id_(correlation_id),
+      model_name_(model_name), model_version_(model_version), flags_(flags)
 {
+  for (auto& input : inputs) {
+    if (!input) {
+      throw PythonBackendException(
+          "Input tensor for request with id '" + request_id +
+          "' and model name '" + model_name + "' should not be empty.");
+    }
+  }
+
+  for (auto& requested_output_name : requested_output_names) {
+    if (requested_output_name == "") {
+      throw PythonBackendException(
+          "Requested output name for request with id '" + request_id +
+          "' and model name '" + model_name + "' should not be empty.");
+    }
+  }
+
+  inputs_ = inputs;
+  requested_output_names_ = requested_output_names;
 }
 
 const std::vector<std::shared_ptr<PbTensor>>&

src/infer_response.cc

@@ -36,8 +36,16 @@ namespace triton { namespace backend { namespace python {
 InferResponse::InferResponse(
     const std::vector<std::shared_ptr<PbTensor>>& output_tensors,
     std::shared_ptr<PbError> error)
-    : output_tensors_(std::move(output_tensors)), error_(error)
+    : error_(error)
 {
+  for (auto& output : output_tensors) {
+    if (!output) {
+      throw PythonBackendException(
+          "Output tensor for inference response should not be empty.");
+    }
+  }
+
+  output_tensors_ = output_tensors;
 }
 
 std::vector<std::shared_ptr<PbTensor>>&

src/pb_stub.cc

@@ -714,10 +714,13 @@ PYBIND11_EMBEDDED_MODULE(c_python_backend_utils, module)
               const std::vector<std::shared_ptr<PbTensor>>&,
               const std::vector<std::string>&, const std::string&,
               const int64_t, const uint32_t>(),
-          py::arg("request_id") = "", py::arg("correlation_id") = 0,
-          py::arg("inputs"), py::arg("requested_output_names"),
-          py::arg("model_name"), py::arg("model_version") = -1,
-          py::arg("flags") = 0)
+          py::arg("request_id").none(false) = "",
+          py::arg("correlation_id").none(false) = 0,
+          py::arg("inputs").none(false),
+          py::arg("requested_output_names").none(false),
+          py::arg("model_name").none(false),
+          py::arg("model_version").none(false) = -1,
+          py::arg("flags").none(false) = 0)
       .def(
           "inputs", &InferRequest::Inputs,
           py::return_value_policy::reference_internal)
@@ -757,7 +760,8 @@ PYBIND11_EMBEDDED_MODULE(c_python_backend_utils, module)
           py::init<
               const std::vector<std::shared_ptr<PbTensor>>&,
               std::shared_ptr<PbError>>(),
-          py::arg("output_tensors"), py::arg("error") = nullptr)
+          py::arg("output_tensors").none(false),
+          py::arg("error") = static_cast<std::shared_ptr<PbError>>(nullptr))
       .def(
           "output_tensors", &InferResponse::OutputTensors,
           py::return_value_policy::reference)

src/pb_tensor.cc

@@ -38,9 +38,13 @@ namespace py = pybind11;
 namespace triton { namespace backend { namespace python {
 
 #ifdef TRITON_PB_STUB
-PbTensor::PbTensor(const std::string& name, py::object numpy_array)
+PbTensor::PbTensor(const std::string& name, py::array& numpy_array)
     : name_(name)
 {
+  if (name == "") {
+    throw PythonBackendException("Tensor name cannot be an empty string.");
+  }
+
   dtype_ = numpy_to_triton_type(numpy_array.attr("dtype"));
   memory_type_ = TRITONSERVER_MEMORY_CPU;
   memory_type_id_ = 0;
@@ -76,10 +80,14 @@ PbTensor::PbTensor(const std::string& name, py::object numpy_array)
 }
 
 PbTensor::PbTensor(
-    const std::string& name, py::object numpy_array,
+    const std::string& name, py::array& numpy_array,
     TRITONSERVER_DataType dtype)
     : name_(name)
 {
+  if (name == "") {
+    throw PythonBackendException("Tensor name cannot be an empty string.");
+  }
+
   if (numpy_to_triton_type(numpy_array.attr("dtype")) != dtype) {
     numpy_array = numpy_array.attr("view")(triton_to_numpy_type(dtype));
   }
@@ -124,6 +132,10 @@ PbTensor::PbTensor(
     int64_t memory_type_id, void* memory_ptr, uint64_t byte_size,
     DLManagedTensor* dl_managed_tensor)
 {
+  if (name == "") {
+    throw PythonBackendException("Tensor name cannot be an empty string.");
+  }
+
   name_ = name;
   memory_ptr_ = memory_ptr;
   memory_type_ = memory_type;
@@ -214,7 +226,7 @@ delete_unused_dltensor(PyObject* dlp)
 }
 
 std::shared_ptr<PbTensor>
-PbTensor::FromNumpy(const std::string& name, py::object numpy_array)
+PbTensor::FromNumpy(const std::string& name, py::array& numpy_array)
 {
   return std::make_shared<PbTensor>(name, numpy_array);
 }
@@ -292,6 +304,10 @@ PbTensor::Memory()
 std::shared_ptr<PbTensor>
 PbTensor::FromDLPack(const std::string& name, const py::capsule& dlpack_tensor)
 {
+  if (name == "") {
+    throw PythonBackendException("Tensor name cannot be an empty string.");
+  }
+
   DLManagedTensor* dl_managed_tensor =
       static_cast<DLManagedTensor*>(dlpack_tensor.get_pointer());
 

src/pb_tensor.h

@@ -67,7 +67,7 @@ class PbTensor {
   /// Create a PbTensor using a numpy array
   /// \param name The name of the tensor
   /// \param numpy_array Numpy array to use for the initialization of the tensor
-  PbTensor(const std::string& name, py::object numpy_array);
+  PbTensor(const std::string& name, py::array& numpy_array);
 
   /// Create a PbTensor using a numpy array. This constructor is used for types
   /// that are not natively available in C++ such as float16. This constructor
@@ -76,7 +76,7 @@ class PbTensor {
   /// \param numpy_array Numpy array to use for the initialization of the tensor
   /// \param dtype The triton dtype
   PbTensor(
-      const std::string& name, py::object numpy_array,
+      const std::string& name, py::array& numpy_array,
       TRITONSERVER_DataType dtype);
 #endif
 
@@ -123,7 +123,7 @@ class PbTensor {
   /// \param numpy_array Numpy array
   /// \param name name of the tensor
   static std::shared_ptr<PbTensor> FromNumpy(
-      const std::string& name, py::object numpy_array);
+      const std::string& name, py::array& numpy_array);
 
   /// Get a PyCapsule object containing the DLPack representation of the tensor.
   /// \return Capsule object containing pointer to a DLPack object.