class_docstr: Your Python model must use the same class name. Every Python model
  that is created must have "TritonPythonModel" as the class name.
docstr: `execute` must be implemented in every Python model. `execute`
  function receives a list of pb_utils.InferenceRequest as the only
  argument. This function is called when an inference is requested
  for this model. Depending on the batching configuration (e.g. Dynamic
  Batching) used, `requests` may contain multiple requests. Every
  Python model, must create one pb_utils.InferenceResponse for every
  pb_utils.InferenceRequest in `requests`. If there is an error, you can
  set the error argument when creating a pb_utils.InferenceResponse.
  Parameters
  ----------
  requests : list
    A list of pb_utils.InferenceRequest
  Returns
  -------
  list
    A list of pb_utils.InferenceResponse. The length of this list must
    be the same as `requests`
code: def execute(self, requests):
      """`execute` must be implemented in every Python model. `execute`
      function receives a list of pb_utils.InferenceRequest as the only
      argument. This function is called when an inference is requested
      for this model. Depending on the batching configuration (e.g. Dynamic
      Batching) used, `requests` may contain multiple requests. Every
      Python model, must create one pb_utils.InferenceResponse for every
      pb_utils.InferenceRequest in `requests`. If there is an error, you can
      set the error argument when creating a pb_utils.InferenceResponse.
      Parameters
      ----------
      requests : list
        A list of pb_utils.InferenceRequest
      Returns
      -------
      list
        A list of pb_utils.InferenceResponse. The length of this list must
        be the same as `requests`
      """
      responses = []
      for request in requests:
          infer_outputs = pb_utils.get_input_tensor_by_name(
              request, self.input_names[0]
          )
          im_infos = pb_utils.get_input_tensor_by_name(
              request, self.input_names[1]
          )
          ori_imgs = pb_utils.get_input_tensor_by_name(
              request, self.input_names[2]
          )
  
          infer_outputs = infer_outputs.as_numpy()
          im_infos = im_infos.as_numpy()
          ori_imgs = ori_imgs.as_numpy()
  
          results = self.postprocessor.run([infer_outputs], im_infos)
          batch_rec_texts = []
          batch_rec_scores = []
          batch_box_list = []
          for i_batch in range(len(results)):
              cls_labels = []
              cls_scores = []
              rec_texts = []
              rec_scores = []
  
              box_list = fd.vision.ocr.sort_boxes(results[i_batch])
              image_list = []
              if len(box_list) == 0:
                  image_list.append(ori_imgs[i_batch])
              else:
                  for box in box_list:
                      crop_img = get_rotate_crop_image(
                          ori_imgs[i_batch], box
                      )
                      image_list.append(crop_img)
  
              batch_box_list.append(box_list)
  
              cls_pre_tensors = self.cls_preprocessor.run(image_list)
              cls_dlpack_tensor = cls_pre_tensors[0].to_dlpack()
              cls_input_tensor = pb_utils.Tensor.from_dlpack(
                  "x", cls_dlpack_tensor
              )
  
              inference_request = pb_utils.InferenceRequest(
                  model_name="cls_pp",
                  requested_output_names=["cls_labels", "cls_scores"],
                  inputs=[cls_input_tensor],
              )
              inference_response = inference_request.exec()
              if inference_response.has_error():
                  raise pb_utils.TritonModelException(
                      inference_response.error().message()
                  )
              else:
                  # Extract the output tensors from the inference response.
                  cls_labels = pb_utils.get_output_tensor_by_name(
                      inference_response, "cls_labels"
                  )
                  cls_labels = cls_labels.as_numpy()
  
                  cls_scores = pb_utils.get_output_tensor_by_name(
                      inference_response, "cls_scores"
                  )
                  cls_scores = cls_scores.as_numpy()
  
              for index in range(len(image_list)):
                  if (
                      cls_labels[index] == 1
                      and cls_scores[index] > self.cls_threshold
                  ):
                      image_list[index] = cv2.rotate(
                          image_list[index].astype(np.float32), 1
                      )
                      image_list[index] = np.astype(np.uint8)
  
              rec_pre_tensors = self.rec_preprocessor.run(image_list)
              rec_dlpack_tensor = rec_pre_tensors[0].to_dlpack()
              rec_input_tensor = pb_utils.Tensor.from_dlpack(
                  "x", rec_dlpack_tensor
              )
  
              inference_request = pb_utils.InferenceRequest(
                  model_name="rec_pp",
                  requested_output_names=["rec_texts", "rec_scores"],
                  inputs=[rec_input_tensor],
              )
              inference_response = inference_request.exec()
              if inference_response.has_error():
                  raise pb_utils.TritonModelException(
                      inference_response.error().message()
                  )
              else:
                  # Extract the output tensors from the inference response.
                  rec_texts = pb_utils.get_output_tensor_by_name(
                      inference_response, "rec_texts"
                  )
                  rec_texts = rec_texts.as_numpy()
  
                  rec_scores = pb_utils.get_output_tensor_by_name(
                      inference_response, "rec_scores"
                  )
                  rec_scores = rec_scores.as_numpy()
  
                  batch_rec_texts.append(rec_texts)
                  batch_rec_scores.append(rec_scores)
  
          out_tensor_0 = pb_utils.Tensor(
              self.output_names[0],
              np.array(batch_rec_texts, dtype=np.object_),
          )
          out_tensor_1 = pb_utils.Tensor(
              self.output_names[1], np.array(batch_rec_scores)
          )
          out_tensor_2 = pb_utils.Tensor(
              self.output_names[2], np.array(batch_box_list)
          )
          inference_response = pb_utils.InferenceResponse(
              output_tensors=[out_tensor_0, out_tensor_1, out_tensor_2]
          )
          responses.append(inference_response)
      return responses
  
file_path: PaddleOCR/deploy/fastdeploy/serving/fastdeploy_serving/models/det_postprocess/1/model.py
imports: import json
  import numpy
  import time
  import math
  import cv2
  import fastdeploy
  import triton_python_backend_utils
label_desc: Use image node_id 2 for calling the TritonPythonModel obj's underlying member method code with example usage: obj.execute(requests) and returns: responses