clarifai 11.1.5rc1__tar.gz → 11.1.5rc2__tar.gz

{clarifai-11.1.5rc1/clarifai.egg-info → clarifai-11.1.5rc2}/PKG-INFO

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

clarifai-11.1.5rc2/clarifai/__init__.py

@@ -0,0 +1 @@
+__version__ = "11.1.5rc2"

{clarifai-11.1.5rc1 → clarifai-11.1.5rc2}/clarifai/client/model.py

@@ -494,8 +494,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-11.1.5rc1 → clarifai-11.1.5rc2}/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
 
 
@@ -56,12 +59,13 @@ 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.status!r}")
     self._method_signatures = signatures_from_json(response.outputs[0].data.string_value)
 
   def _define_functions(self):
@@ -105,26 +109,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 +215,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 +338,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-11.1.5rc1 → clarifai-11.1.5rc2}/clarifai/runners/models/model_class.py

@@ -3,39 +3,74 @@ 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:
 
-  def predict(self, **kwargs):
-    """Predict method for single or batched inputs."""
-    raise NotImplementedError("predict() not implemented")
+    from clarifai.runners.model_class import ModelClass, methods
+    from clarifai.runners.utils.data_types import Input, Stream
 
-  def generate(self, **kwargs) -> Iterator:
-    """Generate method for streaming outputs."""
-    raise NotImplementedError("generate() not implemented")
+    class MyModel(ModelClass):
 
-  def stream(self, **kwargs) -> Iterator:
-    """Stream method for streaming inputs and outputs."""
-    raise NotImplementedError("stream() not implemented")
+      @methods.predict
+      def predict(self, x: str, y: int) -> List[str]:
+        return [x] * y
+
+      @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."""
+    pass
 
   def _handle_get_signatures_request(self) -> service_pb2.MultiOutputResponse:
     methods = self._get_method_info()
@@ -63,7 +98,8 @@ class ModelClass(ABC):
     outputs = []
     try:
       # TODO add method name field to proto
-      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', '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-11.1.5rc1 → clarifai-11.1.5rc2}/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-11.1.5rc1/clarifai/runners/utils/data_handler.py → clarifai-11.1.5rc2/clarifai/runners/utils/data_types.py

@@ -60,7 +60,7 @@ class Text(MessageData):
     self.url = url
 
   def to_proto(self) -> TextProto:
-    return TextProto(raw=self.text or '', self_url=self.url or '')
+    return TextProto(raw=self.text or '', url=self.url or '')
 
   @classmethod
   def from_proto(cls, proto: TextProto) -> "Text":

{clarifai-11.1.5rc1 → clarifai-11.1.5rc2}/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-11.1.5rc1 → clarifai-11.1.5rc2}/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 → clarifai-11.1.5rc2/clarifai.egg-info}/PKG-INFO

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

{clarifai-11.1.5rc1 → clarifai-11.1.5rc2}/clarifai.egg-info/SOURCES.txt

@@ -161,7 +161,7 @@ clarifai/runners/models/__pycache__/model_servicer.cpython-310.pyc
 clarifai/runners/models/__pycache__/model_upload.cpython-310.pyc
 clarifai/runners/utils/__init__.py
 clarifai/runners/utils/const.py
-clarifai/runners/utils/data_handler.py
+clarifai/runners/utils/data_types.py
 clarifai/runners/utils/data_utils.py
 clarifai/runners/utils/loader.py
 clarifai/runners/utils/method_signatures.py
@@ -170,6 +170,7 @@ clarifai/runners/utils/url_fetcher.py
 clarifai/runners/utils/__pycache__/__init__.cpython-310.pyc
 clarifai/runners/utils/__pycache__/const.cpython-310.pyc
 clarifai/runners/utils/__pycache__/data_handler.cpython-310.pyc
+clarifai/runners/utils/__pycache__/data_types.cpython-310.pyc
 clarifai/runners/utils/__pycache__/data_utils.cpython-310.pyc
 clarifai/runners/utils/__pycache__/loader.cpython-310.pyc
 clarifai/runners/utils/__pycache__/logging.cpython-310.pyc

clarifai-11.1.5rc1/clarifai/__init__.py

@@ -1 +0,0 @@
-__version__ = "11.1.5rc1"