def test_class_names_method(caplog):
caplog.set_level(logging.INFO)
user_object = UserObjectClassMethod()
predictions = np.array([[1, 2], [3, 4]])
names = client_class_names(user_object, predictions)
assert names == ["x", "y"]
assert not "class_names attribute is deprecated. Please define a class_names method" in caplog.text
def construct_response(user_model: SeldonComponent, is_request: bool, client_request: prediction_pb2.SeldonMessage,
client_raw_response: Union[np.ndarray, str, bytes, dict]) -> prediction_pb2.SeldonMessage:
"""
Parameters
----------
user_model
Client user class
is_request
Whether this is part of the request flow as opposed to the response flow
client_request
The request received
client_raw_response
The raw client response from their model
Returns
-------
A SeldonMessage proto response
"""
data_type = client_request.WhichOneof("data_oneof")
meta = prediction_pb2.Meta()
meta_json: Dict = {}
tags = client_custom_tags(user_model)
if tags:
meta_json["tags"] = tags
metrics = client_custom_metrics(user_model)
if metrics:
meta_json["metrics"] = metrics
if client_request.meta:
if client_request.meta.puid:
meta_json["puid"] = client_request.meta.puid
json_format.ParseDict(meta_json, meta)
if isinstance(client_raw_response, np.ndarray) or isinstance(client_raw_response, list):
client_raw_response = np.array(client_raw_response)
if is_request:
names = client_feature_names(user_model, client_request.data.names)
else:
names = client_class_names(user_model, client_raw_response)
if data_type == "data": # If request is using defaultdata then return what was sent if is numeric response else ndarray
if np.issubdtype(client_raw_response.dtype, np.number):
default_data_type = client_request.data.WhichOneof("data_oneof")
else:
default_data_type = "ndarray"
else: # If numeric response return as tensor else return as ndarray
if np.issubdtype(client_raw_response.dtype, np.number):
default_data_type = "tensor"
else:
default_data_type = "ndarray"
data = array_to_grpc_datadef(default_data_type, client_raw_response, names)
return prediction_pb2.SeldonMessage(data=data, meta=meta)
elif isinstance(client_raw_response, str):
return prediction_pb2.SeldonMessage(strData=client_raw_response, meta=meta)
elif isinstance(client_raw_response, dict):
jsonDataResponse = ParseDict(client_raw_response, prediction_pb2.SeldonMessage().jsonData)
return prediction_pb2.SeldonMessage(jsonData=jsonDataResponse, meta=meta)
elif isinstance(client_raw_response, (bytes, bytearray)):
return prediction_pb2.SeldonMessage(binData=client_raw_response, meta=meta)
else:
raise SeldonMicroserviceException("Unknown data type returned as payload:" + client_raw_response)
def test_no_class_names(caplog):
caplog.set_level(logging.INFO)
class X:
pass
user_object = X()
predictions = np.array([[1, 2], [3, 4]])
names = client_class_names(user_object, predictions)
def construct_response_json(
user_model: SeldonComponent,
is_request: bool,
client_request_raw: Union[List, Dict],
client_raw_response: Union[np.ndarray, str, bytes, dict],
meta: dict = None,
custom_metrics: List[Dict] = None,
) -> Union[List, Dict]:
"""
This class converts a raw REST response into a JSON object that has the same structure as
the SeldonMessage proto. This is necessary as the conversion using the SeldonMessage proto
changes the Numeric types of all ints in a JSON into Floats.
Parameters
----------
user_model
Client user class
is_request
Whether this is part of the request flow as opposed to the response flow
client_request_raw
The request received in JSON format
client_raw_response
The raw client response from their model
Returns
-------
A SeldonMessage JSON response
"""
response = {}
if isinstance(client_raw_response, dict):
response["jsonData"] = client_raw_response
elif isinstance(client_raw_response, (bytes, bytearray)):
base64_data = base64.b64encode(client_raw_response)
response["binData"] = base64_data.decode("utf-8")
elif isinstance(client_raw_response, str):
response["strData"] = client_raw_response
else:
is_np = isinstance(client_raw_response, np.ndarray)
is_list = isinstance(client_raw_response, list)
if not (is_np or is_list):
raise SeldonMicroserviceException(
"Unknown data type returned as payload (must be list or np array):"
+ str(client_raw_response))
if is_np:
np_client_raw_response = client_raw_response
list_client_raw_response = client_raw_response.tolist()
else:
np_client_raw_response = np.array(client_raw_response)
list_client_raw_response = client_raw_response
response["data"] = {}
if "data" in client_request_raw:
if np.issubdtype(np_client_raw_response.dtype, np.number):
if "tensor" in client_request_raw["data"]:
default_data_type = "tensor"
result_client_response = {
"values": np_client_raw_response.ravel().tolist(),
"shape": np_client_raw_response.shape,
}
elif "tftensor" in client_request_raw["data"]:
default_data_type = "tftensor"
tf_json_str = json_format.MessageToJson(
tf.make_tensor_proto(np_client_raw_response))
result_client_response = json.loads(tf_json_str)
else:
default_data_type = "ndarray"
result_client_response = list_client_raw_response
else:
default_data_type = "ndarray"
result_client_response = list_client_raw_response
else:
if np.issubdtype(np_client_raw_response.dtype, np.number):
default_data_type = "tensor"
result_client_response = {
"values": np_client_raw_response.ravel().tolist(),
"shape": np_client_raw_response.shape,
}
else:
default_data_type = "ndarray"
result_client_response = list_client_raw_response
response["data"][default_data_type] = result_client_response
if is_request:
req_names = client_request_raw.get("data", {}).get("names", [])
names = client_feature_names(user_model, req_names)
else:
names = client_class_names(user_model, np_client_raw_response)
response["data"]["names"] = names
response["meta"] = {}
if meta:
tags = meta.get("tags", {})
metrics = meta.get("metrics", [])
else:
tags = {}
metrics = []
custom_tags = client_custom_tags(user_model)
if custom_tags:
tags.update(custom_tags)
if custom_metrics:
metrics.extend(custom_metrics)
if tags:
response["meta"]["tags"] = tags
if metrics:
response["meta"]["metrics"] = metrics
puid = client_request_raw.get("meta", {}).get("puid", None)
if puid:
response["meta"]["puid"] = puid
return response
def test_no_class_names_on_seldon_component(caplog):
caplog.set_level(logging.INFO)
user_object = SeldonComponent()
predictions = np.array([[1, 2], [3, 4]])
names = client_class_names(user_object, predictions)
assert names == ["t:0", "t:1"]