clarifai 11.1.7rc3__py3-none-any.whl → 11.2.0__py3-none-any.whl

clarifai/runners/__init__.py

@@ -1,9 +1,14 @@
+from .models.base_typed_model import AnyAnyModel, TextInputModel, VisualInputModel
 from .models.model_builder import ModelBuilder
-from .models.model_class import ModelClass
 from .models.model_runner import ModelRunner
+from .utils.data_handler import InputDataHandler, OutputDataHandler
 
 __all__ = [
     "ModelRunner",
     "ModelBuilder",
-    "ModelClass",
+    "InputDataHandler",
+    "OutputDataHandler",
+    "AnyAnyModel",
+    "TextInputModel",
+    "VisualInputModel",
 ]

clarifai/runners/models/model_builder.py

@@ -1,4 +1,3 @@
-import builtins
 import importlib
 import inspect
 import os
@@ -7,7 +6,6 @@ import sys
 import tarfile
 import time
 from string import Template
-from unittest.mock import MagicMock
 
 import yaml
 from clarifai_grpc.grpc.api import resources_pb2, service_pb2
@@ -16,14 +14,13 @@ from google.protobuf import json_format
 from rich import print
 from rich.markup import escape
 
-from clarifai.client.base import BaseClient
+from clarifai.client import BaseClient
 from clarifai.runners.models.model_class import ModelClass
 from clarifai.runners.utils.const import (
     AVAILABLE_PYTHON_IMAGES, AVAILABLE_TORCH_IMAGES, CONCEPTS_REQUIRED_MODEL_TYPE,
     DEFAULT_DOWNLOAD_CHECKPOINT_WHEN, DEFAULT_PYTHON_VERSION, DEFAULT_RUNTIME_DOWNLOAD_PATH,
     PYTHON_BASE_IMAGE, TORCH_BASE_IMAGE)
 from clarifai.runners.utils.loader import HuggingFaceLoader
-from clarifai.runners.utils.method_signatures import signatures_to_yaml
 from clarifai.urls.helper import ClarifaiUrlHelper
 from clarifai.utils.logging import logger
 from clarifai.versions import CLIENT_VERSION
@@ -72,18 +69,6 @@ class ModelBuilder:
     """
     Create an instance of the model class, as specified in the config file.
     """
-    model_class = self.load_model_class()
-
-    # initialize the model
-    model = model_class()
-    if load_model:
-      model.load_model()
-    return model
-
-  def load_model_class(self):
-    """
-    Import the model class from the model.py file, dynamically handling missing dependencies
-    """
     # look for default model.py file location
     for loc in ["model.py", "1/model.py"]:
       model_file = os.path.join(self.folder, loc)
@@ -97,29 +82,7 @@ class ModelBuilder:
     spec = importlib.util.spec_from_file_location(module_name, model_file)
     module = importlib.util.module_from_spec(spec)
     sys.modules[module_name] = module
-
-    original_import = builtins.__import__
-
-    def custom_import(name, globals=None, locals=None, fromlist=(), level=0):
-
-      # Allow standard libraries and clarifai
-      if self._is_standard_or_clarifai(name):
-        return original_import(name, globals, locals, fromlist, level)
-
-      # Mock all third-party imports to avoid ImportErrors or other issues
-      return MagicMock()
-
-    # Replace the built-in __import__ function with our custom one
-    builtins.__import__ = custom_import
-
-    try:
-      spec.loader.exec_module(module)
-    except Exception as e:
-      logger.error(f"Error loading model.py: {e}")
-      raise
-    finally:
-      # Restore the original __import__ function
-      builtins.__import__ = original_import
+    spec.loader.exec_module(module)
 
     # Find all classes in the model.py file that are subclasses of ModelClass
     classes = [
@@ -144,24 +107,12 @@ class ModelBuilder:
           "Could not determine model class. There should be exactly one model inheriting from ModelClass defined in the model.py"
       )
     model_class = classes[0]
-    return model_class
-
-  def _is_standard_or_clarifai(self, name):
-    """Check if import is from standard library or clarifai"""
-    if name.startswith("clarifai"):
-      return True
-
-    # Handle Python <3.10 compatibility
-    stdlib_names = getattr(sys, "stdlib_module_names", sys.builtin_module_names)
-    if name in stdlib_names:
-      return True
 
-    # Handle submodules (e.g., os.path)
-    parts = name.split(".")
-    for i in range(1, len(parts)):
-      if ".".join(parts[:i]) in stdlib_names:
-        return True
-    return False
+    # initialize the model
+    model = model_class()
+    if load_model:
+      model.load_model()
+    return model
 
   def _validate_folder(self, folder):
     if folder == ".":
@@ -281,7 +232,7 @@ class ModelBuilder:
           f"`num_threads` must be an integer greater than or equal to 1. Received type {type(num_threads)} with value {num_threads}."
       )
     else:
-      num_threads = int(os.environ.get("CLARIFAI_NUM_THREADS", 1))
+      num_threads = int(os.environ.get("CLARIFAI_NUM_THREADS", 16))
       self.config["num_threads"] = num_threads
 
   @staticmethod
@@ -302,24 +253,6 @@ class ModelBuilder:
           total_size += member.size
     return total_size
 
-  def method_signatures_yaml(self):
-    """
-    Returns the method signatures for the model class in YAML format.
-    """
-    model_class = self.load_model_class()
-    method_info = model_class._get_method_info()
-    signatures = {name: m.signature for name, m in method_info.values()}
-    return signatures_to_yaml(signatures)
-
-  def get_method_signatures(self):
-    """
-    Returns the method signatures for the model class.
-    """
-    model_class = self.load_model_class()
-    method_info = model_class._get_method_info()
-    signatures = [method.signature for method in method_info.values()]
-    return signatures
-
   @property
   def client(self):
     if self._client is None:
@@ -353,8 +286,9 @@ class ModelBuilder:
 
     assert "model_type_id" in model, "model_type_id not found in the config file"
     assert "id" in model, "model_id not found in the config file"
-    assert "user_id" in model, "user_id not found in the config file"
-    assert "app_id" in model, "app_id not found in the config file"
+    if not self.download_validation_only:
+      assert "user_id" in model, "user_id not found in the config file"
+      assert "app_id" in model, "app_id not found in the config file"
 
     model_proto = json_format.ParseDict(model, resources_pb2.Model())
 
@@ -598,11 +532,10 @@ class ModelBuilder:
     logger.info(f"Updated config.yaml with {len(concepts)} concepts.")
 
   def get_model_version_proto(self):
-    signatures = self.get_method_signatures()
+
     model_version_proto = resources_pb2.ModelVersion(
         pretrained_model_config=resources_pb2.PretrainedModelConfig(),
         inference_compute_info=self.inference_compute_info,
-        method_signatures=signatures,
     )
 
     model_type_id = self.config.get('model').get('model_type_id')
@@ -790,7 +723,6 @@ class ModelBuilder:
               model_id=self.model_proto.id,
               version_id=self.model_version_id,
           ))
-
       status_code = resp.model_version.status.code
       logs = self.get_model_build_logs()
       for log_entry in logs.log_entries:

clarifai/runners/models/model_class.py

@@ -1,292 +1,41 @@
-import inspect
-import itertools
-import logging
-import os
-import traceback
-from abc import ABC
-from typing import Any, Dict, Iterator, List
+from abc import ABC, abstractmethod
+from typing import Iterator
 
-from clarifai_grpc.grpc.api import resources_pb2, service_pb2
-from clarifai_grpc.grpc.api.status import status_code_pb2, status_pb2
-from google.protobuf import json_format
-
-from clarifai.runners.utils import data_types
-from clarifai.runners.utils.method_signatures import (build_function_signature, deserialize,
-                                                      get_stream_from_signature, serialize,
-                                                      signatures_to_json)
-
-_METHOD_INFO_ATTR = '_cf_method_info'
-
-_RAISE_EXCEPTIONS = os.getenv("RAISE_EXCEPTIONS", "false").lower() in ("true", "1")
+from clarifai_grpc.grpc.api import service_pb2
 
 
 class ModelClass(ABC):
-  '''
-  Base class for model classes that can be run as a service.
-
-  Define predict, generate, or stream methods using the @ModelClass.method decorator.
-
-  Example:
-
-    from clarifai.runners.model_class import ModelClass
-    from clarifai.runners.utils.data_types import NamedFields, Stream
-
-    class MyModel(ModelClass):
-
-      @ModelClass.method
-      def predict(self, x: str, y: int) -> List[str]:
-        return [x] * y
-
-      @ModelClass.method
-      def generate(self, x: str, y: int) -> Stream[str]:
-        for i in range(y):
-          yield x + str(i)
-
-      @ModelClass.method
-      def stream(self, input_stream: Stream[NamedFields(x=str, y=int)]) -> Stream[str]:
-        for item in input_stream:
-          yield item.x + ' ' + str(item.y)
-  '''
-
-  @staticmethod
-  def method(func):
-    setattr(func, _METHOD_INFO_ATTR, _MethodInfo(func))
-    return func
-
-  def load_model(self):
-    """Load the model."""
-
-  def _handle_get_signatures_request(self) -> service_pb2.MultiOutputResponse:
-    methods = self._get_method_info()
-    signatures = {method.name: method.signature for method in methods.values()}
-    resp = service_pb2.MultiOutputResponse(status=status_pb2.Status(code=status_code_pb2.SUCCESS))
-    output = resp.outputs.add()
-    output.status.code = status_code_pb2.SUCCESS
-    output.data.text.raw = signatures_to_json(signatures)
-    return resp
-
-  def _batch_predict(self, method, inputs: List[Dict[str, Any]]) -> List[Any]:
-    """Batch predict method for multiple inputs."""
-    outputs = []
-    for input in inputs:
-      output = method(**input)
-      outputs.append(output)
-    return outputs
-
-  def _batch_generate(self, method, inputs: List[Dict[str, Any]]) -> Iterator[List[Any]]:
-    """Batch generate method for multiple inputs."""
-    generators = [method(**input) for input in inputs]
-    for outputs in itertools.zip_longest(*generators):
-      yield outputs
 
   def predict_wrapper(
       self, request: service_pb2.PostModelOutputsRequest) -> service_pb2.MultiOutputResponse:
-    outputs = []
-    try:
-      # TODO add method name field to proto
-      method_name = 'predict'
-      inference_params = get_inference_params(request)
-      if len(request.inputs) > 0 and '_method_name' in request.inputs[0].data.metadata:
-        method_name = request.inputs[0].data.metadata['_method_name']
-      if method_name == '_GET_SIGNATURES':  # special case to fetch signatures, TODO add endpoint for this
-        return self._handle_get_signatures_request()
-      if method_name not in self._get_method_info():
-        raise ValueError(f"Method {method_name} not found in model class")
-      method = getattr(self, method_name)
-      method_info = method._cf_method_info
-      signature = method_info.signature
-      python_param_types = method_info.python_param_types
-      inputs = self._convert_input_protos_to_python(request.inputs, inference_params,
-                                                    signature.input_fields, python_param_types)
-      if len(inputs) == 1:
-        inputs = inputs[0]
-        output = method(**inputs)
-        outputs.append(self._convert_output_to_proto(output, signature.output_fields))
-      else:
-        outputs = self._batch_predict(method, inputs)
-        outputs = [
-            self._convert_output_to_proto(output, signature.output_fields) for output in outputs
-        ]
-
-      return service_pb2.MultiOutputResponse(
-          outputs=outputs, status=status_pb2.Status(code=status_code_pb2.SUCCESS))
-    except Exception as e:
-      if _RAISE_EXCEPTIONS:
-        raise
-      logging.exception("Error in predict")
-      return service_pb2.MultiOutputResponse(status=status_pb2.Status(
-          code=status_code_pb2.FAILURE,
-          details=str(e),
-          stack_trace=traceback.format_exc().split('\n')))
+    """This method is used for input/output proto data conversion"""
+    return self.predict(request)
 
   def generate_wrapper(self, request: service_pb2.PostModelOutputsRequest
                       ) -> Iterator[service_pb2.MultiOutputResponse]:
-    try:
-      method_name = 'generate'
-      inference_params = get_inference_params(request)
-      if len(request.inputs) > 0 and '_method_name' in request.inputs[0].data.metadata:
-        method_name = request.inputs[0].data.metadata['_method_name']
-      method = getattr(self, method_name)
-      method_info = method._cf_method_info
-      signature = method_info.signature
-      python_param_types = method_info.python_param_types
+    """This method is used for input/output proto data conversion and yield outcome"""
+    return self.generate(request)
 
-      inputs = self._convert_input_protos_to_python(request.inputs, inference_params,
-                                                    signature.input_fields, python_param_types)
-      if len(inputs) == 1:
-        inputs = inputs[0]
-        for output in method(**inputs):
-          resp = service_pb2.MultiOutputResponse()
-          self._convert_output_to_proto(output, signature.output_fields, proto=resp.outputs.add())
-          resp.status.code = status_code_pb2.SUCCESS
-          yield resp
-      else:
-        for outputs in self._batch_generate(method, inputs):
-          resp = service_pb2.MultiOutputResponse()
-          for output in outputs:
-            self._convert_output_to_proto(
-                output, signature.output_fields, proto=resp.outputs.add())
-          resp.status.code = status_code_pb2.SUCCESS
-          yield resp
-    except Exception as e:
-      if _RAISE_EXCEPTIONS:
-        raise
-      logging.exception("Error in generate")
-      yield service_pb2.MultiOutputResponse(status=status_pb2.Status(
-          code=status_code_pb2.FAILURE,
-          details=str(e),
-          stack_trace=traceback.format_exc().split('\n')))
-
-  def stream_wrapper(self, request_iterator: Iterator[service_pb2.PostModelOutputsRequest]
+  def stream_wrapper(self, request: service_pb2.PostModelOutputsRequest
                     ) -> Iterator[service_pb2.MultiOutputResponse]:
-    try:
-      request = next(request_iterator)  # get first request to determine method
-      assert len(request.inputs) == 1, "Streaming requires exactly one input"
-
-      method_name = 'generate'
-      inference_params = get_inference_params(request)
-      if len(request.inputs) > 0 and '_method_name' in request.inputs[0].data.metadata:
-        method_name = request.inputs[0].data.metadata['_method_name']
-      method = getattr(self, method_name)
-      method_info = method._cf_method_info
-      signature = method_info.signature
-      python_param_types = method_info.python_param_types
-
-      # find the streaming vars in the signature
-      stream_sig = get_stream_from_signature(signature.input_fields)
-      if stream_sig is None:
-        raise ValueError("Streaming method must have a Stream input")
-      stream_argname = stream_sig.name
-
-      # convert all inputs for the first request, including the first stream value
-      inputs = self._convert_input_protos_to_python(request.inputs, inference_params,
-                                                    signature.input_fields, python_param_types)
-      kwargs = inputs[0]
-
-      # first streaming item
-      first_item = kwargs.pop(stream_argname)
-
-      # streaming generator
-      def InputStream():
-        yield first_item
-        # subsequent streaming items contain only the streaming input
-        for request in request_iterator:
-          item = self._convert_input_protos_to_python(request.inputs, inference_params,
-                                                      [stream_sig], python_param_types)
-          item = item[0][stream_argname]
-          yield item
-
-      # add stream generator back to the input kwargs
-      kwargs[stream_argname] = InputStream()
-
-      for output in method(**kwargs):
-        resp = service_pb2.MultiOutputResponse()
-        self._convert_output_to_proto(output, signature.output_fields, proto=resp.outputs.add())
-        resp.status.code = status_code_pb2.SUCCESS
-        yield resp
-    except Exception as e:
-      if _RAISE_EXCEPTIONS:
-        raise
-      logging.exception("Error in stream")
-      yield service_pb2.MultiOutputResponse(status=status_pb2.Status(
-          code=status_code_pb2.FAILURE,
-          details=str(e),
-          stack_trace=traceback.format_exc().split('\n')))
-
-  def _convert_input_protos_to_python(self, inputs: List[resources_pb2.Input],
-                                      inference_params: dict,
-                                      variables_signature: List[resources_pb2.ModelTypeField],
-                                      python_param_types) -> List[Dict[str, Any]]:
-    result = []
-    for input in inputs:
-      kwargs = deserialize(input.data, variables_signature, inference_params)
-      # dynamic cast to annotated types
-      for k, v in kwargs.items():
-        if k not in python_param_types:
-          continue
-        kwargs[k] = data_types.cast(v, python_param_types[k])
-      result.append(kwargs)
-    return result
+    """This method is used for input/output proto data conversion and yield outcome"""
+    return self.stream(request)
 
-  def _convert_output_to_proto(self,
-                               output: Any,
-                               variables_signature: List[resources_pb2.ModelTypeField],
-                               proto=None) -> resources_pb2.Output:
-    if proto is None:
-      proto = resources_pb2.Output()
-    serialize({'return': output}, variables_signature, proto.data, is_output=True)
-    proto.status.code = status_code_pb2.SUCCESS
-    return proto
-
-  @classmethod
-  def _register_model_methods(cls):
-    # go up the class hierarchy to find all decorated methods, and add to registry of current class
-    methods = {}
-    for base in reversed(cls.__mro__):
-      for name, method in base.__dict__.items():
-        method_info = getattr(method, _METHOD_INFO_ATTR, None)
-        if not method_info:  # regular function, not a model method
-          continue
-        methods[name] = method_info
-    # check for generic predict(request) -> response, etc. methods
-    #for name in ('predict', 'generate', 'stream'):
-    #  if hasattr(cls, name):
-    #    method = getattr(cls, name)
-    #    if not hasattr(method, _METHOD_INFO_ATTR):  # not already put in registry
-    #      methods[name] = _MethodInfo(method)
-    # set method table for this class in the registry
-    return methods
-
-  @classmethod
-  def _get_method_info(cls, func_name=None):
-    if not hasattr(cls, _METHOD_INFO_ATTR):
-      setattr(cls, _METHOD_INFO_ATTR, cls._register_model_methods())
-    method_info = getattr(cls, _METHOD_INFO_ATTR)
-    if func_name:
-      return method_info[func_name]
-    return method_info
-
-
-# Helper function to get the inference params
-def get_inference_params(request) -> dict:
-  """Get the inference params from the request."""
-  inference_params = {}
-  if request.model.model_version.id != "":
-    output_info = request.model.model_version.output_info
-    output_info = json_format.MessageToDict(output_info, preserving_proto_field_name=True)
-    if "params" in output_info:
-      inference_params = output_info["params"]
-  return inference_params
-
-
-class _MethodInfo:
-
-  def __init__(self, method):
-    self.name = method.__name__
-    self.signature = build_function_signature(method)
-    self.python_param_types = {
-        p.name: p.annotation
-        for p in inspect.signature(method).parameters.values()
-        if p.annotation != inspect.Parameter.empty
-    }
-    self.python_param_types.pop('self', None)
+  @abstractmethod
+  def load_model(self):
+    raise NotImplementedError("load_model() not implemented")
+
+  @abstractmethod
+  def predict(self,
+              request: service_pb2.PostModelOutputsRequest) -> service_pb2.MultiOutputResponse:
+    raise NotImplementedError("run_input() not implemented")
+
+  @abstractmethod
+  def generate(self, request: service_pb2.PostModelOutputsRequest
+              ) -> Iterator[service_pb2.MultiOutputResponse]:
+    raise NotImplementedError("generate() not implemented")
+
+  @abstractmethod
+  def stream(self, request_iterator: Iterator[service_pb2.PostModelOutputsRequest]
+            ) -> Iterator[service_pb2.MultiOutputResponse]:
+    raise NotImplementedError("stream() not implemented")

clarifai/runners/models/model_run_locally.py

@@ -7,11 +7,14 @@ import subprocess
 import sys
 import tempfile
 import time
+import traceback
 import venv
 
 from clarifai_grpc.grpc.api import resources_pb2, service_pb2
+from clarifai_grpc.grpc.api.status import status_code_pb2, status_pb2
 
 from clarifai.runners.models.model_builder import ModelBuilder
+from clarifai.runners.utils.url_fetcher import ensure_urls_downloaded
 from clarifai.utils.logging import logger
 
 
@@ -108,13 +111,85 @@ class ModelRunLocally:
     for i in range(1):
       yield request
 
+  def _run_model_inference(self, model):
+    """Perform inference using the model."""
+    request = self._build_request()
+    stream_request = self._build_stream_request()
+
+    ensure_urls_downloaded(request)
+    predict_response = None
+    generate_response = None
+    stream_response = None
+    try:
+      predict_response = model.predict(request)
+    except NotImplementedError:
+      logger.info("Model does not implement predict() method.")
+    except Exception as e:
+      logger.error(f"Model Prediction failed: {e}")
+      traceback.print_exc()
+      predict_response = service_pb2.MultiOutputResponse(status=status_pb2.Status(
+          code=status_code_pb2.MODEL_PREDICTION_FAILED,
+          description="Prediction failed",
+          details="",
+          internal_details=str(e),
+      ))
+
+    if predict_response:
+      if predict_response.outputs[0].status.code != status_code_pb2.SUCCESS:
+        logger.error(f"Moddel Prediction failed: {predict_response}")
+      else:
+        logger.info(f"Model Prediction succeeded: {predict_response}")
+
+    try:
+      generate_response = model.generate(request)
+    except NotImplementedError:
+      logger.info("Model does not implement generate() method.")
+    except Exception as e:
+      logger.error(f"Model Generation failed: {e}")
+      traceback.print_exc()
+      generate_response = service_pb2.MultiOutputResponse(status=status_pb2.Status(
+          code=status_code_pb2.MODEL_GENERATION_FAILED,
+          description="Generation failed",
+          details="",
+          internal_details=str(e),
+      ))
+
+    if generate_response:
+      generate_first_res = next(generate_response)
+      if generate_first_res.outputs[0].status.code != status_code_pb2.SUCCESS:
+        logger.error(f"Moddel Prediction failed: {generate_first_res}")
+      else:
+        logger.info(
+            f"Model Prediction succeeded for generate and first response: {generate_first_res}")
+
+    try:
+      stream_response = model.stream(stream_request)
+    except NotImplementedError:
+      logger.info("Model does not implement stream() method.")
+    except Exception as e:
+      logger.error(f"Model Stream failed: {e}")
+      traceback.print_exc()
+      stream_response = service_pb2.MultiOutputResponse(status=status_pb2.Status(
+          code=status_code_pb2.MODEL_STREAM_FAILED,
+          description="Stream failed",
+          details="",
+          internal_details=str(e),
+      ))
+
+    if stream_response:
+      stream_first_res = next(stream_response)
+      if stream_first_res.outputs[0].status.code != status_code_pb2.SUCCESS:
+        logger.error(f"Moddel Prediction failed: {stream_first_res}")
+      else:
+        logger.info(
+            f"Model Prediction succeeded for stream and first response: {stream_first_res}")
+
   def _run_test(self):
     """Test the model locally by making a prediction."""
     # Create the model
     model = self.builder.create_model_instance()
-    # call its test method, if it has one
-    if hasattr(model, "test"):
-      model.test()
+    # send an inference.
+    self._run_model_inference(model)
 
   def test_model(self):
     """Test the model by running it locally in the virtual environment."""
@@ -400,11 +475,6 @@ def main(model_path,
          keep_env=False,
          keep_image=False):
 
-  if not os.environ.get("CLARIFAI_PAT", None):
-    logger.error(
-        "CLARIFAI_PAT environment variable is not set! Please set your PAT in the 'CLARIFAI_PAT' environment variable."
-    )
-    sys.exit(1)
   manager = ModelRunLocally(model_path)
   # get whatever stage is in config.yaml to force download now
   # also always write to where upload/build wants to, not the /tmp folder that runtime stage uses
@@ -421,16 +491,11 @@ def main(model_path,
     if not manager.docker_image_exists(image_name):
       manager.build_docker_image(image_name=image_name)
     try:
-      envs = {
-          'CLARIFAI_PAT': os.environ['CLARIFAI_PAT'],
-          'CLARIFAI_API_BASE': os.environ.get('CLARIFAI_API_BASE', 'https://api.clarifai.com')
-      }
       if run_model_server:
         manager.run_docker_container(
-            image_name=image_name, container_name=container_name, port=port, env_vars=envs)
+            image_name=image_name, container_name=container_name, port=port)
       else:
-        manager.test_model_container(
-            image_name=image_name, container_name=container_name, env_vars=envs)
+        manager.test_model_container(image_name=image_name, container_name=container_name)
     finally:
       if manager.container_exists(container_name):
         manager.stop_docker_container(container_name)

clarifai/runners/models/model_runner.py

@@ -82,8 +82,6 @@ class ModelRunner(BaseRunner, HealthProbeRequestHandler):
     ensure_urls_downloaded(request)
 
     resp = self.model.predict_wrapper(request)
-    if resp.status.code != status_code_pb2.SUCCESS:
-      return service_pb2.RunnerItemOutput(multi_output_response=resp)
     successes = [o.status.code == status_code_pb2.SUCCESS for o in resp.outputs]
     if all(successes):
       status = status_pb2.Status(