clarifai 11.1.5rc1__py3-none-any.whl → 11.1.5rc3__py3-none-any.whl

clarifai/__init__.py

@@ -1 +1 @@
-__version__ = "11.1.5rc1"
+__version__ = "11.1.5rc3"

clarifai/client/model.py

@@ -443,6 +443,15 @@ class Model(Lister, BaseClient):
         output_config=output_config,
     )
 
+  def predict2(self, inputs):
+    """Predicts the model based on the given inputs.
+
+    Args:
+        inputs (list[Input]): The inputs to predict, must be less than 128.
+    """
+
+    return self.model_client._predict(inputs=inputs,)
+
   def _check_predict_input_type(self, input_type: str) -> None:
     """Checks if the input type is valid for the model.
 
@@ -494,8 +503,7 @@ class Model(Lister, BaseClient):
                            nodepool_id: str = None,
                            deployment_id: str = None,
                            user_id: str = None):
-    runner_selector = resources_pb2.RunnerSelector()
-
+    runner_selector = None
     if deployment_id and (compute_cluster_id or nodepool_id):
       raise UserError(
           "You can only specify one of deployment_id or compute_cluster_id and nodepool_id.")

clarifai/client/model_client.py

@@ -1,3 +1,4 @@
+import inspect
 import time
 from typing import Any, Dict, Iterator, List
 
@@ -6,7 +7,9 @@ from clarifai_grpc.grpc.api.status import status_code_pb2
 
 from clarifai.constants.model import MAX_MODEL_PREDICT_INPUTS
 from clarifai.errors import UserError
-from clarifai.runners.utils.method_signatures import deserialize, serialize, signatures_from_json
+from clarifai.runners.utils.method_signatures import (deserialize, get_stream_from_signature,
+                                                      serialize, signatures_from_json,
+                                                      unflatten_nested_keys)
 from clarifai.utils.misc import BackoffIterator, status_is_retryable
 
 
@@ -45,8 +48,10 @@ class ModelClient:
 
     request = service_pb2.PostModelOutputsRequest()
     request.CopyFrom(self.request_template)
-    request.model.model_version.output_info.params['_method_name'] = '_GET_SIGNATURES'
-    request.inputs.add()  # empty input for this method
+    # request.model.model_version.output_info.params['_method_name'] = '_GET_SIGNATURES'
+    inp = request.inputs.add()  # empty input for this method
+    inp.data.parts.add()  # empty part for this input
+    inp.data.metadata['method_name'] = '_GET_SIGNATURES'
     start_time = time.time()
     backoff_iterator = BackoffIterator(10)
     while True:
@@ -56,13 +61,16 @@ class ModelClient:
         self.logger.info(f"Retrying model info fetch with response {response.status!r}")
         time.sleep(next(backoff_iterator))
         continue
-
-      if response.status.code != status_code_pb2.SUCCESS:
-        raise Exception(f"Model failed with response {response.status!r}")
       break
+    if response.status.code == status_code_pb2.INPUT_UNSUPPORTED_FORMAT:
+      # return code from older models that don't support _GET_SIGNATURES
+      self._method_signatures = {}
+      return
     if response.status.code != status_code_pb2.SUCCESS:
-      raise Exception(response.status)
+      raise Exception(f"Model failed with response {response!r}")
     self._method_signatures = signatures_from_json(response.outputs[0].data.string_value)
+    import pdb
+    pdb.set_trace()
 
   def _define_functions(self):
     '''
@@ -105,26 +113,47 @@ class ModelClient:
       # need to bind method_name to the value, not the mutating loop variable
       f = bind_f(method_name, method_argnames, call_func)
 
-      # set names and docstrings
-      # note we could also have used exec with strings from the signature to define the
-      # function, but this is safer (no xss), and docstrings with the signature is ok enough
+      # set names, annotations and docstrings
       f.__name__ = method_name
       f.__qualname__ = f'{self.__class__.__name__}.{method_name}'
-      input_spec = ', '.join(
-          f'{var.name}: {var.data_type}{" = " + str(var.default) if not var.required else ""}'
-          for var in method_signature.inputs)
-      output_vars = method_signature.outputs
-      if len(output_vars) == 1 and output_vars[0].name == 'return':
+      input_annos = {var.name: var.data_type for var in method_signature.inputs}
+      output_annos = {var.name: var.data_type for var in method_signature.outputs}
+      # unflatten nested keys to match the user function args for docs
+      input_annos = unflatten_nested_keys(input_annos, method_signature.inputs, is_output=False)
+      output_annos = unflatten_nested_keys(output_annos, method_signature.outputs, is_output=True)
+
+      # add Stream[] to the stream input annotations for docs
+      input_stream_argname, _ = get_stream_from_signature(method_signature.inputs)
+      if input_stream_argname:
+        input_annos[input_stream_argname] = 'Stream[' + str(
+            input_annos[input_stream_argname]) + ']'
+
+      # handle multiple outputs in the return annotation
+      return_annotation = output_annos
+      name = next(iter(output_annos.keys()))
+      if len(output_annos) == 1 and name == 'return':
         # single output
-        output_spec = output_vars[0].data_type
-      elif output_vars[0].name == 'return.0':
+        return_annotation = output_annos[name]
+      elif name.startswith('return.') and name.split('.', 1)[1].isnumeric():
         # tuple output
-        output_spec = '(' + ', '.join(var.data_type for var in output_vars) + ')'
+        return_annotation = '(' + ", ".join(output_annos[f'return.{i}']
+                                            for i in range(len(output_annos))) + ')'
       else:
         # named output
-        output_spec = f'Output({", ".join(f"{var.name}={var.data_type}" for var in output_vars)})'
-      f.__doc__ = f'''{method_name}(self, {input_spec}) -> {output_spec}\n'''
-      #f.__doc__ += method_signature.description  # TODO
+        return_annotation = f'Output({", ".join(f"{k}={t}" for k, t in output_annos.items())})'
+      if method_signature.method_type in ['generate', 'stream']:
+        return_annotation = f'Stream[{return_annotation}]'
+
+      # set annotations and docstrings
+      sig = inspect.signature(f).replace(
+          parameters=[
+              inspect.Parameter(k, inspect.Parameter.POSITIONAL_OR_KEYWORD, annotation=v)
+              for k, v in input_annos.items()
+          ],
+          return_annotation=return_annotation,
+      )
+      f.__signature__ = sig
+      f.__doc__ = method_signature.docstring
       setattr(self, method_name, f)
 
   def _predict(
@@ -190,7 +219,8 @@ class ModelClient:
     if inference_params:
       request.model.model_version.output_info.params.update(inference_params)
     if output_config:
-      request.model.model_version.output_info.output_config.MergeFromDict(output_config)
+      request.model.model_version.output_info.output_config.MergeFrom(
+          resources_pb2.OutputConfig(**output_config))
 
     start_time = time.time()
     backoff_iterator = BackoffIterator(10)
@@ -312,11 +342,7 @@ class ModelClient:
     kwargs = inputs
 
     # find the streaming vars in the input signature, and the streaming input python param
-    streaming_var_signatures = [var for var in input_signature if var.streaming]
-    stream_argname = set([var.name.split('.', 1)[0] for var in streaming_var_signatures])
-    assert len(
-        stream_argname) == 1, 'streaming methods must have exactly one streaming function arg'
-    stream_argname = stream_argname.pop()
+    stream_argname, streaming_var_signatures = get_stream_from_signature(input_signature)
 
     # get the streaming input generator from the user-provided function arg values
     user_inputs_generator = kwargs.pop(stream_argname)

clarifai/runners/dockerfile_template/Dockerfile.template

@@ -44,8 +44,8 @@ ENV PYTHONPATH=${PYTHONPATH}:/home/nonroot/main \
     CLARIFAI_COMPUTE_CLUSTER_ID=${CLARIFAI_COMPUTE_CLUSTER_ID} \
     CLARIFAI_API_BASE=${CLARIFAI_API_BASE:-https://api.clarifai.com}
 
-# Write out the model function signatures
-RUN ["python", "-m", "clarifai.cli", "model", "signatures", "--model_path", "/home/nonroot/main", "--out_path", "/home/nonroot/main/signatures.yaml"]
+# # Write out the model function signatures
+# RUN ["python", "-m", "clarifai.cli", "model", "signatures", "--model_path", "/home/nonroot/main", "--out_path", "/home/nonroot/main/signatures.yaml"]
 
 # Finally run the clarifai entrypoint to start the runner loop and local dev server.
 # Note(zeiler): we may want to make this a clarifai CLI call.

clarifai/runners/models/model_class.py

@@ -3,39 +3,73 @@ import itertools
 import logging
 import os
 import traceback
-import types
 from abc import ABC
 from typing import Any, Dict, Iterator, List
 
 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.utils import data_handler
+from clarifai.runners.utils import data_types
 from clarifai.runners.utils.method_signatures import (build_function_signature, deserialize,
-                                                      serialize, signatures_to_json)
+                                                      get_stream_from_signature, serialize,
+                                                      signatures_to_json)
 
 _METHOD_INFO_ATTR = '_cf_method_info'
 
 _RAISE_EXCEPTIONS = os.getenv("RAISE_EXCEPTIONS", "false").lower() == "true"
 
 
+class methods:
+  '''
+  Decorators to mark methods as predict, generate, or stream methods.
+  '''
+
+  @staticmethod
+  def predict(method):
+    setattr(method, _METHOD_INFO_ATTR, _MethodInfo(method, 'predict'))
+    return method
+
+  @staticmethod
+  def generate(method):
+    setattr(method, _METHOD_INFO_ATTR, _MethodInfo(method, 'generate'))
+    return method
+
+  @staticmethod
+  def stream(method):
+    setattr(method, _METHOD_INFO_ATTR, _MethodInfo(method, 'stream'))
+    return method
+
+
 class ModelClass(ABC):
+  '''
+  Base class for model classes that can be run as a service.
 
-  def load_model(self):
-    """Load the model."""
-    pass
+  Define methods as predict, generate, or stream methods using the @methods decorators.
+
+  Example:
+
+    from clarifai.runners.model_class import ModelClass, methods
+    from clarifai.runners.utils.data_types import Input, Stream
 
-  def predict(self, **kwargs):
-    """Predict method for single or batched inputs."""
-    raise NotImplementedError("predict() not implemented")
+    class MyModel(ModelClass):
 
-  def generate(self, **kwargs) -> Iterator:
-    """Generate method for streaming outputs."""
-    raise NotImplementedError("generate() not implemented")
+      @methods.predict
+      def predict(self, x: str, y: int) -> List[str]:
+        return [x] * y
 
-  def stream(self, **kwargs) -> Iterator:
-    """Stream method for streaming inputs and outputs."""
-    raise NotImplementedError("stream() not implemented")
+      @methods.generate
+      def generate(self, x: str, y: int) -> Stream[str]:
+        for i in range(y):
+          yield x + str(i)
+
+      @methods.stream
+      def stream(self, input_stream: Stream[Input(x=str, y=int)]) -> Stream[str]:
+        for item in input_stream:
+          yield item.x + ' ' + str(item.y)
+  '''
+
+  def load_model(self):
+    """Load the model."""
 
   def _handle_get_signatures_request(self) -> service_pb2.MultiOutputResponse:
     methods = self._get_method_info()
@@ -63,7 +97,9 @@ class ModelClass(ABC):
     outputs = []
     try:
       # TODO add method name field to proto
-      method_name = request.model.model_version.output_info.params['_method_name']
+      method_name = request.inputs[0].data.metadata['method_name']
+      # call_params = dict(request.model.model_version.output_info.params)
+      # method_name = call_params.get('_method_name', 'predict')
       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():
@@ -96,7 +132,8 @@ class ModelClass(ABC):
   def generate_wrapper(self, request: service_pb2.PostModelOutputsRequest
                       ) -> Iterator[service_pb2.MultiOutputResponse]:
     try:
-      method_name = request.model.model_version.output_info.params['_method_name']
+      call_params = dict(request.model.model_version.output_info.params)
+      method_name = call_params.get('_method_name', 'generate')
       method = getattr(self, method_name)
       method_info = method._cf_method_info
       signature = method_info.signature
@@ -133,18 +170,15 @@ class ModelClass(ABC):
       request = next(request_iterator)  # get first request to determine method
       assert len(request.inputs) == 1, "Streaming requires exactly one input"
 
-      method_name = request.model.model_version.output_info.params['_method_name']
+      call_params = dict(request.model.model_version.output_info.params)
+      method_name = call_params.get('_method_name', 'stream')
       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
-      streaming_var_signatures = [var for var in signature.inputs if var.streaming]
-      stream_argname = set([var.name.split('.', 1)[0] for var in streaming_var_signatures])
-      assert len(
-          stream_argname) == 1, 'streaming methods must have exactly one streaming function arg'
-      stream_argname = stream_argname.pop()
+      stream_argname, streaming_var_signatures = get_stream_from_signature(signature.inputs)
 
       # convert all inputs for the first request, including the first stream value
       inputs = self._convert_input_protos_to_python(request.inputs, signature.inputs,
@@ -190,7 +224,7 @@ class ModelClass(ABC):
       for k, v in kwargs.items():
         if k not in python_param_types:
           continue
-        kwargs[k] = data_handler.cast(v, python_param_types[k])
+        kwargs[k] = data_types.cast(v, python_param_types[k])
       result.append(kwargs)
     return result
 
@@ -203,6 +237,7 @@ class ModelClass(ABC):
     if not isinstance(output, dict):  # TODO Output type, not just dict
       output = {'return': output}
     serialize(output, variables_signature, proto.data, is_output=True)
+    proto.status.code = status_code_pb2.SUCCESS
     return proto
 
   @classmethod
@@ -245,21 +280,3 @@ class _MethodInfo:
         if p.annotation != inspect.Parameter.empty
     }
     self.python_param_types.pop('self', None)
-
-
-def predict(method):
-  setattr(method, _METHOD_INFO_ATTR, _MethodInfo(method, 'predict'))
-  return method
-
-
-def generate(method):
-  setattr(method, _METHOD_INFO_ATTR, _MethodInfo(method, 'generate'))
-  return method
-
-
-def stream(method):
-  setattr(method, _METHOD_INFO_ATTR, _MethodInfo(method, 'stream'))
-  return method
-
-
-methods = types.SimpleNamespace(predict=predict, generate=generate, stream=stream)

clarifai/runners/models/model_run_locally.py

@@ -7,14 +7,11 @@ 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
 
 
@@ -111,85 +108,13 @@ 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()
-    # send an inference.
-    self._run_model_inference(model)
+    # call its test method, if it has one
+    if hasattr(model, "test"):
+      model.test()
 
   def test_model(self):
     """Test the model by running it locally in the virtual environment."""

clarifai/runners/utils/data_types.py

@@ -0,0 +1,334 @@
+import io
+from typing import Iterable, List, get_args, get_origin
+
+import numpy as np
+from clarifai_grpc.grpc.api.resources_pb2 import Audio as AudioProto
+from clarifai_grpc.grpc.api.resources_pb2 import Concept as ConceptProto
+from clarifai_grpc.grpc.api.resources_pb2 import Frame as FrameProto
+from clarifai_grpc.grpc.api.resources_pb2 import Image as ImageProto
+from clarifai_grpc.grpc.api.resources_pb2 import Region as RegionProto
+from clarifai_grpc.grpc.api.resources_pb2 import Text as TextProto
+from clarifai_grpc.grpc.api.resources_pb2 import Video as VideoProto
+from PIL import Image as PILImage
+
+
+class MessageData:
+
+  def to_proto(self):
+    raise NotImplementedError
+
+  @classmethod
+  def from_proto(cls, proto):
+    raise NotImplementedError
+
+  def cast(self, python_type):
+    if python_type == self.__class__:
+      return self
+    raise TypeError(f'Incompatible type for {self.__class__.__name__}: {python_type}')
+
+
+class Output(dict):
+  __getattr__ = dict.__getitem__
+  __setattr__ = dict.__setitem__
+
+  def __origin__(self):
+    return self
+
+  def __args__(self):
+    return list(self.keys())
+
+
+class Input(dict):
+  __getattr__ = dict.__getitem__
+  __setattr__ = dict.__setitem__
+
+  def __origin__(self):
+    return self
+
+  def __args__(self):
+    return list(self.keys())
+
+
+class Stream(Iterable):
+  pass
+
+
+class Text(MessageData):
+
+  def __init__(self, text: str, url: str = None):
+    self.text = text
+    self.url = url
+
+  def to_proto(self) -> TextProto:
+    return TextProto(raw=self.text or '', url=self.url or '')
+
+  @classmethod
+  def from_proto(cls, proto: TextProto) -> "Text":
+    return cls(proto.raw, proto.url or None)
+
+  def cast(self, python_type):
+    if python_type == str:
+      return self.text
+    if python_type == Text:
+      return self
+    raise TypeError(f'Incompatible type for Text: {python_type}')
+
+
+class Concept(MessageData):
+
+  def __init__(self, name: str, value: float = 0):
+    self.name = name
+    self.value = value
+
+  def __repr__(self) -> str:
+    return f"Concept(name={self.name!r}, value={self.value})"
+
+  def to_proto(self):
+    return ConceptProto(name=self.name, value=self.value)
+
+  @classmethod
+  def from_proto(cls, proto: ConceptProto) -> "Concept":
+    return cls(proto.name, proto.value)
+
+
+class Region(MessageData):
+
+  def __init__(self, proto_region: RegionProto):
+    self.proto = proto_region
+
+  @property
+  def box(self) -> List[float]:
+    bbox = self.proto.region_info.bounding_box
+    return [bbox.left_col, bbox.top_row, bbox.right_col, bbox.bottom_row]  # x1, y1, x2, y2
+
+  @box.setter
+  def box(self, value: List[float]):
+    bbox = self.proto.region_info.bounding_box
+    bbox.left_col, bbox.top_row, bbox.right_col, bbox.bottom_row = value
+
+  @property
+  def concepts(self) -> List[Concept]:
+    return [Concept.from_proto(proto) for proto in self.proto.data.concepts]
+
+  @concepts.setter
+  def concepts(self, value: List[Concept]):
+    self.proto.data.concepts.extend([concept.to_proto() for concept in value])
+
+  def __repr__(self) -> str:
+    return f"Region(box={self.box}, concepts={self.concepts})"
+
+  def to_proto(self) -> RegionProto:
+    return self.proto
+
+  @classmethod
+  def from_proto(cls, proto: RegionProto) -> "Region":
+    return cls(proto)
+
+
+class Image(MessageData):
+
+  def __init__(self, proto_image: ImageProto = None, url: str = None, bytes: bytes = None):
+    if proto_image is None:
+      proto_image = ImageProto()
+    self.proto = proto_image
+    # use setters for init vals
+    if url:
+      self.url = url
+    if bytes:
+      self.bytes = bytes
+
+  @property
+  def url(self) -> str:
+    return self.proto.url
+
+  @url.setter
+  def url(self, value: str):
+    self.proto.url = value
+
+  @property
+  def bytes(self) -> bytes:
+    return self.proto.base64
+
+  @bytes.setter
+  def bytes(self, value: bytes):
+    self.proto.base64 = value
+
+  def __repr__(self) -> str:
+    attrs = []
+    if self.url:
+      attrs.append(f"url={self.url!r}")
+    if self.bytes:
+      attrs.append(f"bytes=<{len(self.bytes)} bytes>")
+    return f"Image({', '.join(attrs)})"
+
+  @classmethod
+  def from_url(cls, url: str) -> "Image":
+    proto_image = ImageProto(url=url)
+    return cls(proto_image)
+
+  @classmethod
+  def from_pil(cls, pil_image: PILImage.Image) -> "Image":
+    with io.BytesIO() as output:
+      pil_image.save(output, format="PNG")
+      image_bytes = output.getvalue()
+    proto_image = ImageProto(base64=image_bytes)
+    return cls(proto_image)
+
+  def to_pil(self) -> PILImage.Image:
+    if not self.proto.base64:
+      raise ValueError("Image has no bytes")
+    return PILImage.open(io.BytesIO(self.proto.base64))
+
+  def to_numpy(self) -> np.ndarray:
+    return np.asarray(self.to_pil())
+
+  def to_proto(self) -> ImageProto:
+    return self.proto
+
+  @classmethod
+  def from_proto(cls, proto: ImageProto) -> "Image":
+    return cls(proto)
+
+  def cast(self, python_type):
+    if python_type == Image:
+      return self
+    if python_type in (PILImage.Image, PILImage):
+      return self.to_pil()
+    if python_type == np.ndarray or get_origin(python_type) == np.ndarray:
+      return self.to_numpy()
+    raise TypeError(f'Incompatible type for Image: {python_type}')
+
+
+class Audio(MessageData):
+
+  def __init__(self, proto_audio: AudioProto):
+    self.proto = proto_audio
+
+  @property
+  def url(self) -> str:
+    return self.proto.url
+
+  @url.setter
+  def url(self, value: str):
+    self.proto.url = value
+
+  @property
+  def bytes(self) -> bytes:
+    return self.proto.base64
+
+  @bytes.setter
+  def bytes(self, value: bytes):
+    self.proto.base64 = value
+
+  @classmethod
+  def from_url(cls, url: str) -> "Audio":
+    proto_audio = AudioProto(url=url)
+    return cls(proto_audio)
+
+  def __repr__(self) -> str:
+    attrs = []
+    if self.url:
+      attrs.append(f"url={self.url!r}")
+    if self.bytes:
+      attrs.append(f"bytes=<{len(self.bytes)} bytes>")
+    return f"Audio({', '.join(attrs)})"
+
+  def to_proto(self) -> AudioProto:
+    return self.proto
+
+  @classmethod
+  def from_proto(cls, proto: AudioProto) -> "Audio":
+    return cls(proto)
+
+
+class Frame(MessageData):
+
+  def __init__(self, proto_frame: FrameProto):
+    self.proto = proto_frame
+
+  @property
+  def time(self) -> float:
+    # TODO: time is a uint32, so this will overflow at 49.7 days
+    # we should be using double or uint64 in the proto instead
+    return self.proto.frame_info.time / 1000.0
+
+  @time.setter
+  def time(self, value: float):
+    self.proto.frame_info.time = int(value * 1000)
+
+  @property
+  def image(self) -> Image:
+    return Image.from_proto(self.proto.data.image)
+
+  @image.setter
+  def image(self, value: Image):
+    self.proto.data.image.CopyFrom(value.to_proto())
+
+  @property
+  def regions(self) -> List[Region]:
+    return [Region(region) for region in self.proto.data.regions]
+
+  @regions.setter
+  def regions(self, value: List[Region]):
+    self.proto.data.regions.extend([region.proto for region in value])
+
+  def to_proto(self) -> FrameProto:
+    return self.proto
+
+  @classmethod
+  def from_proto(cls, proto: FrameProto) -> "Frame":
+    return cls(proto)
+
+
+class Video(MessageData):
+
+  def __init__(self, proto_video: VideoProto):
+    self.proto = proto_video
+
+  @property
+  def url(self) -> str:
+    return self.proto.url
+
+  @url.setter
+  def url(self, value: str):
+    self.proto.url = value
+
+  @property
+  def bytes(self) -> bytes:
+    return self.proto.base64
+
+  @bytes.setter
+  def bytes(self, value: bytes):
+    self.proto.base64 = value
+
+  @classmethod
+  def from_url(cls, url: str) -> "Video":
+    proto_video = VideoProto(url=url)
+    return cls(proto_video)
+
+  def __repr__(self) -> str:
+    attrs = []
+    if self.url:
+      attrs.append(f"url={self.url!r}")
+    if self.bytes:
+      attrs.append(f"bytes=<{len(self.bytes)} bytes>")
+    return f"Video({', '.join(attrs)})"
+
+  def to_proto(self) -> VideoProto:
+    return self.proto
+
+  @classmethod
+  def from_proto(cls, proto: VideoProto) -> "Video":
+    return cls(proto)
+
+
+def cast(value, python_type):
+  list_type = (get_origin(python_type) == list)
+  if isinstance(value, MessageData):
+    return value.cast(python_type)
+  if list_type and isinstance(value, np.ndarray):
+    return value.tolist()
+  if list_type and isinstance(value, list):
+    inner_type = get_args(python_type)[0]
+    return [cast(item, inner_type) for item in value]
+  return value

clarifai/runners/utils/method_signatures.py

@@ -2,7 +2,7 @@ import inspect
 import json
 import re
 import types
-from collections import namedtuple
+from collections import OrderedDict, namedtuple
 from typing import List, get_args, get_origin
 
 import numpy as np
@@ -11,7 +11,7 @@ import yaml
 from clarifai_grpc.grpc.api import resources_pb2
 from google.protobuf.message import Message as MessageProto
 
-from clarifai.runners.utils import data_handler
+from clarifai.runners.utils import data_types
 from clarifai.runners.utils.serializers import (AtomicFieldSerializer, ImageSerializer,
                                                 ListSerializer, MessageSerializer,
                                                 NDArraySerializer, NullValueSerializer, Serializer)
@@ -33,7 +33,7 @@ def build_function_signature(func, method_type: str):
     raise ValueError('Function must have a return annotation')
   # check for multiple return values and convert to dict for named values
   return_streaming = False
-  if get_origin(return_annotation) == data_handler.Stream:
+  if get_origin(return_annotation) == data_types.Stream:
     return_annotation = get_args(return_annotation)[0]
     return_streaming = True
   if get_origin(return_annotation) == tuple:
@@ -73,7 +73,7 @@ def build_function_signature(func, method_type: str):
     input_stream_vars = [var for var in input_vars if var.streaming]
     if len(input_stream_vars) == 0:
       raise TypeError('Stream methods must include a Stream input')
-    if len(output_vars) != 1 or not output_vars[0].streaming:
+    if not all(var.streaming for var in output_vars):
       raise TypeError('Stream methods must return a single Stream')
   else:
     raise TypeError('Invalid method type: %s' % method_type)
@@ -85,6 +85,7 @@ def build_function_signature(func, method_type: str):
   #method_signature.method_type = getattr(resources_pb2.RunnerMethodType, method_type)
   assert method_type in ('predict', 'generate', 'stream')
   method_signature.method_type = method_type
+  method_signature.docstring = func.__doc__
 
   #method_signature.inputs.extend(input_vars)
   #method_signature.outputs.extend(output_vars)
@@ -163,7 +164,7 @@ def serialize(kwargs, signatures, proto=None, is_output=False):
   if proto is None:
     proto = resources_pb2.Data()
   if not is_output:  # TODO: use this consistently for return keys also
-    flatten_nested_keys(kwargs, signatures, is_output)
+    kwargs = flatten_nested_keys(kwargs, signatures, is_output)
   unknown = set(kwargs.keys()) - set(sig.name for sig in signatures)
   if unknown:
     if unknown == {'return'} and len(signatures) > 1:
@@ -204,8 +205,8 @@ def deserialize(proto, signatures, is_output=False):
       return kwargs['return']
     if kwargs and 'return.0' in kwargs:  # case for tuple return values
       return tuple(kwargs[f'return.{i}'] for i in range(len(kwargs)))
-    return data_handler.Output(kwargs)
-  unflatten_nested_keys(kwargs, signatures, is_output)
+    return data_types.Output(kwargs)
+  kwargs = unflatten_nested_keys(kwargs, signatures, is_output)
   return kwargs
 
 
@@ -238,18 +239,32 @@ def unflatten_nested_keys(kwargs, signatures, is_output):
   Unflatten nested keys in kwargs into a dict, e.g. {'a.b': 1} -> {'a': {'b': 1}}
   Uses the signatures to determine which keys are nested.
   The dict subclass is Input or Output, depending on the is_output flag.
+  Preserves the order of args from the signatures.
   '''
+  unflattened = OrderedDict()
   for sig in signatures:
     if '.' not in sig.name:
+      if sig.name in kwargs:
+        unflattened[sig.name] = kwargs[sig.name]
       continue
     if sig.name not in kwargs:
       continue
     parts = sig.name.split('.')
     assert len(parts) == 2, 'Only one level of nested keys is supported'
-    if parts[0] not in kwargs:
-      kwargs[parts[0]] = data_handler.Output() if is_output else data_handler.Input()
-    kwargs[parts[0]][parts[1]] = kwargs.pop(sig.name)
-  return kwargs
+    if parts[0] not in unflattened:
+      unflattened[parts[0]] = data_types.Output() if is_output else data_types.Input()
+    unflattened[parts[0]][parts[1]] = kwargs[sig.name]
+  return unflattened
+
+
+def get_stream_from_signature(signatures):
+  streaming_signatures = [var for var in signatures if var.streaming]
+  if not streaming_signatures:
+    return None, []
+  stream_argname = set([var.name.split('.', 1)[0] for var in streaming_signatures])
+  assert len(stream_argname) == 1, 'streaming methods must have exactly one streaming function arg'
+  stream_argname = stream_argname.pop()
+  return stream_argname, streaming_signatures
 
 
 def _is_empty_proto_data(data):
@@ -314,20 +329,20 @@ def _normalize_types(param, is_output=False):
   tp = param.annotation
 
   # stream type indicates streaming, not part of the data itself
-  streaming = (get_origin(tp) == data_handler.Stream)
+  streaming = (get_origin(tp) == data_types.Stream)
   if streaming:
     tp = get_args(tp)[0]
 
   if is_output or streaming:  # named types can be used for outputs or streaming inputs
     # output type used for named return values, each with their own data type
-    if isinstance(tp, (dict, data_handler.Output, data_handler.Input)):
+    if isinstance(tp, (dict, data_types.Output, data_types.Input)):
       return {param.name + '.' + name: _normalize_data_type(val)
               for name, val in tp.items()}, streaming
-    if tp == data_handler.Output:  # check for Output type without values
+    if tp == data_types.Output:  # check for Output type without values
       if not is_output:
         raise TypeError('Output types can only be used for output values')
       raise TypeError('Output types must be instantiated with inner type values for each key')
-    if tp == data_handler.Input:  # check for Output type without values
+    if tp == data_types.Input:  # check for Output type without values
       if is_output:
         raise TypeError('Input types can only be used for input values')
       raise TypeError(
@@ -349,7 +364,7 @@ def _normalize_data_type(tp):
   # check for PIL images (sometimes types use the module, sometimes the class)
   # set these to use the Image data handler
   if tp in (PIL.Image, PIL.Image.Image):
-    tp = data_handler.Image
+    tp = data_types.Image
 
   # put back list
   if is_list:
@@ -388,20 +403,20 @@ _DATA_TYPES = {
         _DataType('None', '', NullValueSerializer()),
     np.ndarray:
         _DataType('ndarray', 'ndarray', NDArraySerializer()),
-    data_handler.Text:
-        _DataType('Text', 'text', MessageSerializer(data_handler.Text)),
-    data_handler.Image:
+    data_types.Text:
+        _DataType('Text', 'text', MessageSerializer(data_types.Text)),
+    data_types.Image:
         _DataType('Image', 'image', ImageSerializer()),
-    data_handler.Concept:
-        _DataType('Concept', 'concepts', MessageSerializer(data_handler.Concept)),
-    data_handler.Region:
-        _DataType('Region', 'regions', MessageSerializer(data_handler.Region)),
-    data_handler.Frame:
-        _DataType('Frame', 'frames', MessageSerializer(data_handler.Frame)),
-    data_handler.Audio:
-        _DataType('Audio', 'audio', MessageSerializer(data_handler.Audio)),
-    data_handler.Video:
-        _DataType('Video', 'video', MessageSerializer(data_handler.Video)),
+    data_types.Concept:
+        _DataType('Concept', 'concepts', MessageSerializer(data_types.Concept)),
+    data_types.Region:
+        _DataType('Region', 'regions', MessageSerializer(data_types.Region)),
+    data_types.Frame:
+        _DataType('Frame', 'frames', MessageSerializer(data_types.Frame)),
+    data_types.Audio:
+        _DataType('Audio', 'audio', MessageSerializer(data_types.Audio)),
+    data_types.Video:
+        _DataType('Video', 'video', MessageSerializer(data_types.Video)),
 
     # lists handled specially, not as generic lists using parts
     List[int]:

clarifai/runners/utils/serializers.py

@@ -4,7 +4,7 @@ import numpy as np
 from clarifai_grpc.grpc.api import resources_pb2
 from PIL import Image as PILImage
 
-from clarifai.runners.utils.data_handler import Image, MessageData
+from clarifai.runners.utils.data_types import Image, MessageData
 
 
 class Serializer:

{clarifai-11.1.5rc1.dist-info → clarifai-11.1.5rc3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: clarifai
-Version: 11.1.5rc1
+Version: 11.1.5rc3
 Summary: Clarifai Python SDK
 Home-page: https://github.com/Clarifai/clarifai-python
 Author: Clarifai

{clarifai-11.1.5rc1.dist-info → clarifai-11.1.5rc3.dist-info}/RECORD

@@ -1,4 +1,4 @@
-clarifai/__init__.py,sha256=5B7b93t2VQEf7mnj6P0kUJcGZiWQD7DaL9EA8x7K2I4,26
+clarifai/__init__.py,sha256=cQU5SXsYznf1FLV9LeeLMrjUc1vlOnCbQLM5_Z--QKI,26
 clarifai/cli.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 clarifai/errors.py,sha256=RwzTajwds51wLD0MVlMC5kcpBnzRpreDLlazPSBZxrg,2605
 clarifai/versions.py,sha256=jctnczzfGk_S3EnVqb2FjRKfSREkNmvNEwAAa_VoKiQ,222
@@ -19,7 +19,7 @@ clarifai/cli/__pycache__/__main__.cpython-310.pyc,sha256=CM9FOqcSyt-DLnck7FovGDx
 clarifai/cli/__pycache__/base.cpython-310.pyc,sha256=a7mN_r511p_Ao8aXrWU9KPSe8wkDZJW4p8UhlD6EoB8,3151
 clarifai/cli/__pycache__/compute_cluster.cpython-310.pyc,sha256=NHLAcVEwqUhci0KB5DpnPWUqXcCttpWrA3F5zld4qN8,1985
 clarifai/cli/__pycache__/deployment.cpython-310.pyc,sha256=AhfbPlwjjj_TmC2UayjuRbNr00dOukDl6NfLhm2rIng,2278
-clarifai/cli/__pycache__/model.cpython-310.pyc,sha256=Rory2IgsnFWkAiHMM3XkA-zShxX_zHwEWTKFP1V1Weo,8542
+clarifai/cli/__pycache__/model.cpython-310.pyc,sha256=1boWk53FmE7FjNVWSH-azhFxPqzoDbDmtu30eHUxFYY,9075
 clarifai/cli/__pycache__/nodepool.cpython-310.pyc,sha256=nEmM-s1HFg7xM5x-bpnqHFWAVLWj0J0ZskYtd6NSq20,2473
 clarifai/client/__init__.py,sha256=xI1U0l5AZdRThvQAXCLsd9axxyFzXXJ22m8LHqVjQRU,662
 clarifai/client/app.py,sha256=6pckYme1urV2YJjLIYfeZ-vH0Z5YSQa51jzIMcEfwug,38342
@@ -29,8 +29,8 @@ clarifai/client/dataset.py,sha256=y3zKT_VhP1gyN3OO-b3cPeW21ZXyKbQ7ZJkEG06bsTU,32
 clarifai/client/deployment.py,sha256=w7Y6pA1rYG4KRK1SwusRZc2sQRXlG8wezuVdzSWpCo0,2586
 clarifai/client/input.py,sha256=obMAHMDU1OwfXZ8KraOnGFlWzlW-3F7Ob_2lcOQMlhY,46339
 clarifai/client/lister.py,sha256=03KGMvs5RVyYqxLsSrWhNc34I8kiF1Ph0NeyEwu7nMU,2082
-clarifai/client/model.py,sha256=aZFeU4rjTIjC9IlWmJ-Gg9lHLrHDVKXWv80AFYdPEhc,75127
-clarifai/client/model_client.py,sha256=OfJvOvP-n61WrB-ZdtJVYkeM8HtM1T388V4yhP8OVJc,15494
+clarifai/client/model.py,sha256=Z4cz-qXznbttETnH3W_LyyscGawvtBkRfaSCsdOgAvs,75334
+clarifai/client/model_client.py,sha256=vPdNZbLV8IaTDhyi6dUV_WoPx6we-EFq5gX4MufAAD4,16653
 clarifai/client/module.py,sha256=FTkm8s9m-EaTKN7g9MnLhGJ9eETUfKG7aWZ3o1RshYs,4204
 clarifai/client/nodepool.py,sha256=la3vTFrO4LX8zm2eQ5jqf2L0-kQ63Dano8FibadoZbk,10152
 clarifai/client/search.py,sha256=GaPWN6JmTQGZaCHr6U1yv0zqR6wKFl7i9IVLg2ul1CI,14254
@@ -128,41 +128,43 @@ clarifai/rag/__pycache__/rag.cpython-310.pyc,sha256=_xylc1DvMu1KYcDr-dtfUU2uzUjL
 clarifai/rag/__pycache__/utils.cpython-310.pyc,sha256=IDUXR7Iv4KfHSY3sbx_bgPdJQn2ozyRCuz01EUTmCUw,3694
 clarifai/runners/__init__.py,sha256=cDJ31l41dDsqW4Xn6sFMkKxxdIMTnGH9IW6sVkq0TNw,207
 clarifai/runners/server.py,sha256=xHDLdhQApCgYG19QOKXqJNCGNyw1Vsvobq3UdryDrVc,4132
-clarifai/runners/__pycache__/__init__.cpython-310.pyc,sha256=VGSCzJUpHYJvSUMVIKhz3kmq0X5Kt8KFC6RnngonzDc,530
+clarifai/runners/__pycache__/__init__.cpython-310.pyc,sha256=jVTodJyP53yeIEk2sPufcafNVxxCWiHOD50my0nwFcw,365
 clarifai/runners/__pycache__/server.cpython-310.pyc,sha256=HfZ6_Vrr5q78nznFqP_aWhPENplHIol_qPaf8lLlotE,3229
 clarifai/runners/dockerfile_template/Dockerfile.debug,sha256=sRlfRmSLE_TiLORcVRx-3-B0vvSNeUYgm0CCrWmLvAA,667
 clarifai/runners/dockerfile_template/Dockerfile.debug~,sha256=7YOVg3adIaiudfSkfLGeyxt-FfIBbD3UIIYccrIVJTs,426
-clarifai/runners/dockerfile_template/Dockerfile.template,sha256=cibinDDE4uRGt2d2ho2T7CduSeDF6R2n7U4_4MAouPw,2521
+clarifai/runners/dockerfile_template/Dockerfile.template,sha256=MWGjj0My6d18v-nyhWuNbSXUzCzR6KWkohRB1yInb7Q,2525
 clarifai/runners/models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 clarifai/runners/models/model_builder.py,sha256=UCAeJiP_fRFfIuVI1sOge7LMwe-psgvdBuZ0LsJQMpM,33062
-clarifai/runners/models/model_class.py,sha256=S-Bgs9c5SKzbg20ZaBFZ5XMLfgGahdgkhSli-b3wlN8,10658
-clarifai/runners/models/model_run_locally.py,sha256=V770O-7yQQQlh80u48NZTEHkX3gj1HyclHbu1tjvaQ8,20864
+clarifai/runners/models/model_class.py,sha256=7pZ8ci4M8Qh91OW-C6yuWAhl3psLDfyvGypaGyFRkLs,11122
+clarifai/runners/models/model_run_locally.py,sha256=VZetm9Mko8MBjcjwr6PCnTU9gF3glgD5qvpbj-8tW2s,17962
 clarifai/runners/models/model_runner.py,sha256=qyc73pe4xc9BsUKHwnOyC9g-RNCARiFis4GTh-yg0vg,6219
 clarifai/runners/models/model_servicer.py,sha256=A--b1P71PBCAMJCpy_-fpNDkfCVdvdMh1LleW15dSas,3037
 clarifai/runners/models/__pycache__/__init__.cpython-310.pyc,sha256=GTFjzypyx5wnDGqxYeY01iya1CELKb5fOFBFLV031yU,171
-clarifai/runners/models/__pycache__/base_typed_model.cpython-310.pyc,sha256=7yG3KnWmyOBjHF6eTXPO-P8nKZXf8pOXozFu1eCL0ws,8271
-clarifai/runners/models/__pycache__/model_builder.cpython-310.pyc,sha256=0i6pT3F86bi6XX3TlkxoKPKvSs5dDnEpXWmnKselYZo,26683
-clarifai/runners/models/__pycache__/model_class.cpython-310.pyc,sha256=beH4ssWg-EX2xO9yB2H-UzwvfN87TZIoxRpX7D1Rpaw,1889
+clarifai/runners/models/__pycache__/base_typed_model.cpython-310.pyc,sha256=rr_Pxrq9MaT1keVVxBHF59pKv8-dX53B2uLscDXfbfY,8271
+clarifai/runners/models/__pycache__/model_builder.cpython-310.pyc,sha256=0C76O8ZOXrT3y6CVs53h_9cg7XkZKbSxyd6zp0UoAug,27487
+clarifai/runners/models/__pycache__/model_class.cpython-310.pyc,sha256=0pXfvIxFEOhPMscFYUT3Up6KuVOy9Hw_Aj3B2rx-q0k,9498
 clarifai/runners/models/__pycache__/model_run_locally.cpython-310.pyc,sha256=maLshBrvhTy0C6grT26JPAA14P-nD9WDWN25E2BErsE,16976
-clarifai/runners/models/__pycache__/model_runner.cpython-310.pyc,sha256=FkdOM1ZovcqILVO1Hqbus2QtlvEbC3L_Ams3UhTHHFA,4964
+clarifai/runners/models/__pycache__/model_runner.cpython-310.pyc,sha256=u4ZYB_TJJgvqkQ-7_yPUoKU0tT2ycwzBXuqfORwUF3Y,4999
 clarifai/runners/models/__pycache__/model_servicer.cpython-310.pyc,sha256=9QTYk4zVHBUtlTfkH3WaE6frNdN6ba57EVj4bKe18YA,2501
 clarifai/runners/models/__pycache__/model_upload.cpython-310.pyc,sha256=erkIUHtJv1ohMOFT8EAJuVfBsEY4o0GxpeXrZqjrfGk,21046
 clarifai/runners/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 clarifai/runners/utils/const.py,sha256=bwj-Pcw558-pasdIFbNhnkn-9oiCdojYH1fNTTUG2gU,1048
 clarifai/runners/utils/data_handler.py,sha256=zCA_C3mbxgMroqrygMa5xsyuMF476mgd697MUPlOR0E,8327
+clarifai/runners/utils/data_types.py,sha256=5_1S0tJEqhW8BY0ohREVyfsyObPMLkN7H78n7mQ_4Rs,8322
 clarifai/runners/utils/data_utils.py,sha256=R1iQ82TuQ9JwxCJk8yEB1Lyb0BYVhVbWJI9YDi1zGOs,318
 clarifai/runners/utils/loader.py,sha256=SgNHMwRmCCymFQm8aDp73NmIUHhM-N60CBlTKbPzmVc,7470
-clarifai/runners/utils/method_signatures.py,sha256=BmljuTasajCFeEhwGjYqe5O6G2p3zLU1dGVC95_N9uw,16778
-clarifai/runners/utils/serializers.py,sha256=ZtI32AI2Vcjri54KNwBZ0CmTpaJOTfJ5I5mSI5nTQLY,3928
+clarifai/runners/utils/method_signatures.py,sha256=HHaU_KYxtZxwGD_1tAU1K6dYsTtOEcfl892ApovcGmw,17408
+clarifai/runners/utils/serializers.py,sha256=NLLR3E40qbw2vJ1psKyo9vUL56jKIJMwDM3C6JRGvaI,3926
 clarifai/runners/utils/url_fetcher.py,sha256=v_8JOWmkyFAzsBulsieKX7Nfjy1Yg7wGSZeqfEvw2cg,1640
 clarifai/runners/utils/__pycache__/__init__.cpython-310.pyc,sha256=PRPZOzUV5Z8grWizu5RKOkki0iLYxZDJBgsLfmCcieE,170
 clarifai/runners/utils/__pycache__/const.cpython-310.pyc,sha256=EBpjmzlqWBxRGqu_KXeVx80uDslhufrErs57SbLr3DE,953
-clarifai/runners/utils/__pycache__/data_handler.cpython-310.pyc,sha256=REXKSnzTcwbRu09ygCQ_41EdpJa-lmTkc5oMx8nL07U,7961
+clarifai/runners/utils/__pycache__/data_handler.cpython-310.pyc,sha256=0rmmZ0AKL0z2ahf90g0xnqRy2GvgbSRkNYE9lSzSn_Q,7961
+clarifai/runners/utils/__pycache__/data_types.cpython-310.pyc,sha256=RdIGmYmmh0LmmiLMgSQRT7K6A8BKvVb9O4F3RJ9AE_4,12385
 clarifai/runners/utils/__pycache__/data_utils.cpython-310.pyc,sha256=1e6NiK6bnJiiAo2KPsDmm91BSlbI3mVkQZKbDfh5hBI,642
 clarifai/runners/utils/__pycache__/loader.cpython-310.pyc,sha256=X1MwgLanVXLs-QLot1X145A36W29ONXZRZe5q6_jARo,7319
 clarifai/runners/utils/__pycache__/logging.cpython-310.pyc,sha256=VV0KFcnuYpFFtaG4EeDIgg7c4QEsBLo-eX_NnsyFEhA,331
-clarifai/runners/utils/__pycache__/method_signatures.cpython-310.pyc,sha256=YQwROEZupQao2V6oNRiXi4IeWyk1iZRs07jsKsxtzO0,12882
-clarifai/runners/utils/__pycache__/serializers.cpython-310.pyc,sha256=9chtKBxIfQmUrJo284HV4307Ltul8fqfuoPzzPU_NGs,5277
+clarifai/runners/utils/__pycache__/method_signatures.cpython-310.pyc,sha256=CLfkuYN95CQXad8D9lrb1ZOZ340uWfVZ2_-CgHs_WTQ,13678
+clarifai/runners/utils/__pycache__/serializers.cpython-310.pyc,sha256=5D-aRO-GTdkAF-6gRFHE_fPyxOZRH4aE6wq9FZeEP0M,5275
 clarifai/runners/utils/__pycache__/url_fetcher.cpython-310.pyc,sha256=jFxVdOmm7DCkgatv1GwIXeefHthpvlkg4ybBlMnmxss,1739
 clarifai/schema/search.py,sha256=JjTi8ammJgZZ2OGl4K6tIA4zEJ1Fr2ASZARXavI1j5c,2448
 clarifai/schema/__pycache__/search.cpython-310.pyc,sha256=aYuMHmn0ovwmeOhTDj7QAURrQAjlyLm1CwKaz6xktZU,2484
@@ -193,9 +195,9 @@ clarifai/workflows/__pycache__/__init__.cpython-310.pyc,sha256=oRKg6B7Z-wWQy0EW2
 clarifai/workflows/__pycache__/export.cpython-310.pyc,sha256=cNmGLnww7xVpm4htd1vRhQJoEZ1dhpN1oD8iLLAtVzM,2418
 clarifai/workflows/__pycache__/utils.cpython-310.pyc,sha256=rm2kWk4a3GOKWoerXpEAEeRvGhEe7wPd0ZZ6jHtEGqY,1925
 clarifai/workflows/__pycache__/validate.cpython-310.pyc,sha256=QA1i6YdDpY824cqtQvkEaFPpaCa2iqfOwFouqwZfAKY,2139
-clarifai-11.1.5rc1.dist-info/LICENSE,sha256=mUqF_d12-qE2n41g7C5_sq-BMLOcj6CNN-jevr15YHU,555
-clarifai-11.1.5rc1.dist-info/METADATA,sha256=0gulnBxVFgowYwuRa_TxiyNRYZ5X1pXIi5q02DRz4_k,22229
-clarifai-11.1.5rc1.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
-clarifai-11.1.5rc1.dist-info/entry_points.txt,sha256=X9FZ4Z-i_r2Ud1RpZ9sNIFYuu_-9fogzCMCRUD9hyX0,51
-clarifai-11.1.5rc1.dist-info/top_level.txt,sha256=wUMdCQGjkxaynZ6nZ9FAnvBUCgp5RJUVFSy2j-KYo0s,9
-clarifai-11.1.5rc1.dist-info/RECORD,,
+clarifai-11.1.5rc3.dist-info/LICENSE,sha256=mUqF_d12-qE2n41g7C5_sq-BMLOcj6CNN-jevr15YHU,555
+clarifai-11.1.5rc3.dist-info/METADATA,sha256=Zl3cY8_BDZ33bV5M1VWnPiAMUGT4EIwE3ZqFHWaW0EY,22229
+clarifai-11.1.5rc3.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
+clarifai-11.1.5rc3.dist-info/entry_points.txt,sha256=X9FZ4Z-i_r2Ud1RpZ9sNIFYuu_-9fogzCMCRUD9hyX0,51
+clarifai-11.1.5rc3.dist-info/top_level.txt,sha256=wUMdCQGjkxaynZ6nZ9FAnvBUCgp5RJUVFSy2j-KYo0s,9
+clarifai-11.1.5rc3.dist-info/RECORD,,