def create_predict_response()

in ts/protocol/otf_message_handler.py [0:0]

• 61 lines of code
• 14 McCabe index (conditional complexity)

def create_predict_response(ret, req_id_map, message, code, context=None):
    """
    Create inference response.

    :param context:
    :param ret:
    :param req_id_map:
    :param message:
    :param code:
    :return:
    """
    msg = bytearray()
    msg += struct.pack('!i', code)

    buf = message.encode("utf-8")
    msg += struct.pack('!i', len(buf))
    msg += buf

    for idx in req_id_map:
        req_id = req_id_map.get(idx).encode('utf-8')
        msg += struct.pack("!i", len(req_id))
        msg += req_id

        # Encoding Content-Type
        if context is None:
            msg += struct.pack('!i', 0)  # content_type
        else:
            content_type = context.get_response_content_type(idx)
            if content_type is None or len(content_type) == 0:
                msg += struct.pack('!i', 0)  # content_type
            else:
                msg += struct.pack('!i', len(content_type))
                msg += content_type.encode('utf-8')

        # Encoding the per prediction HTTP response code
        if context is None:
            # status code and reason phrase set to none
            msg += struct.pack('!i', code)
            msg += struct.pack('!i', 0)  # No code phrase is returned
            # Response headers none
            msg += struct.pack('!i', 0)
        else:
            sc, phrase = context.get_response_status(idx)
            http_code = sc if sc is not None else 200
            http_phrase = phrase if phrase is not None else ""

            msg += struct.pack('!i', http_code)
            msg += struct.pack("!i", len(http_phrase))
            msg += http_phrase.encode("utf-8")
            # Response headers
            msg += encode_response_headers(context.get_response_headers(idx))

        if ret is None:
            buf = b"error"
            msg += struct.pack('!i', len(buf))
            msg += buf
        else:
            val = ret[idx]
            # NOTE: Process bytes/bytearray case before processing the string case.
            if isinstance(val, (bytes, bytearray)):
                msg += struct.pack('!i', len(val))
                msg += val
            elif isinstance(val, str):
                buf = val.encode("utf-8")
                msg += struct.pack('!i', len(buf))
                msg += buf
            elif isinstance(val, torch.Tensor):
                buff = io.BytesIO()
                torch.save(val, buff)
                buff.seek(0)
                val_bytes = buff.read()
                msg += struct.pack('!i', len(val_bytes))
                msg += val_bytes
            else:
                try:
                    json_value = json.dumps(val, indent=2).encode("utf-8")
                    msg += struct.pack('!i', len(json_value))
                    msg += json_value
                except TypeError:
                    logging.warning("Unable to serialize model output.", exc_info=True)
                    return create_predict_response(None, req_id_map, "Unsupported model output data type.", 503)

    msg += struct.pack('!i', -1)  # End of list
    return msg