clarifai 10.8.8__py3-none-any.whl → 10.9.0__py3-none-any.whl

clarifai/__init__.py

@@ -1 +1 @@
-__version__ = "10.8.8"
+__version__ = "10.9.0"

clarifai/client/deployment.py

@@ -39,6 +39,18 @@ class Deployment(Lister, BaseClient):
         root_certificates_path=root_certificates_path)
     Lister.__init__(self)
 
+  @staticmethod
+  def get_runner_selector(user_id: str, deployment_id: str) -> resources_pb2.RunnerSelector:
+    """Returns a RunnerSelector object for the given deployment_id.
+
+    Args:
+        deployment_id (str): The deployment ID for the deployment.
+
+    Returns:
+        resources_pb2.RunnerSelector: A RunnerSelector object for the given deployment_id.
+    """
+    return resources_pb2.RunnerSelector(deployment_id=deployment_id, user_id=user_id)
+
   def __getattr__(self, name):
     return getattr(self.deployment_info, name)
 

clarifai/client/model.py

@@ -7,7 +7,7 @@ import numpy as np
 import requests
 import yaml
 from clarifai_grpc.grpc.api import resources_pb2, service_pb2
-from clarifai_grpc.grpc.api.resources_pb2 import Input
+from clarifai_grpc.grpc.api.resources_pb2 import Input, RunnerSelector
 from clarifai_grpc.grpc.api.status import status_code_pb2
 from google.protobuf.json_format import MessageToDict
 from google.protobuf.struct_pb2 import Struct, Value
@@ -16,8 +16,10 @@ from tqdm import tqdm
 
 from clarifai.client.base import BaseClient
 from clarifai.client.dataset import Dataset
+from clarifai.client.deployment import Deployment
 from clarifai.client.input import Inputs
 from clarifai.client.lister import Lister
+from clarifai.client.nodepool import Nodepool
 from clarifai.constants.model import (CHUNK_SIZE, MAX_CHUNK_SIZE, MAX_MODEL_PREDICT_INPUTS,
                                       MAX_RANGE_SIZE, MIN_CHUNK_SIZE, MIN_RANGE_SIZE,
                                       MODEL_EXPORT_TIMEOUT, RANGE_SIZE, TRAINABLE_MODEL_TYPES)
@@ -404,11 +406,16 @@ class Model(Lister, BaseClient):
           model_id=self.id,
           **dict(self.kwargs, model_version=model_version_info))
 
-  def predict(self, inputs: List[Input], inference_params: Dict = {}, output_config: Dict = {}):
+  def predict(self,
+              inputs: List[Input],
+              runner_selector: RunnerSelector = None,
+              inference_params: Dict = {},
+              output_config: Dict = {}):
     """Predicts the model based on the given inputs.
 
     Args:
         inputs (list[Input]): The inputs to predict, must be less than 128.
+        runner_selector (RunnerSelector): The runner selector to use for the model.
     """
     if not isinstance(inputs, list):
       raise UserError('Invalid inputs, inputs must be a list of Input objects.')
@@ -422,6 +429,7 @@ class Model(Lister, BaseClient):
         model_id=self.id,
         version_id=self.model_version.id,
         inputs=inputs,
+        runner_selector=runner_selector,
         model=self.model_info)
 
     start_time = time.time()
@@ -445,6 +453,9 @@ class Model(Lister, BaseClient):
   def predict_by_filepath(self,
                           filepath: str,
                           input_type: str,
+                          compute_cluster_id: str = None,
+                          nodepool_id: str = None,
+                          deployment_id: str = None,
                           inference_params: Dict = {},
                           output_config: Dict = {}):
     """Predicts the model based on the given filepath.
@@ -452,6 +463,9 @@ class Model(Lister, BaseClient):
     Args:
         filepath (str): The filepath to predict.
         input_type (str): The type of input. Can be 'image', 'text', 'video' or 'audio.
+        compute_cluster_id (str): The compute cluster ID to use for the model.
+        nodepool_id (str): The nodepool ID to use for the model.
+        deployment_id (str): The deployment ID to use for the model.
         inference_params (dict): The inference params to override.
         output_config (dict): The output config to override.
           min_value (float): The minimum value of the prediction confidence to filter.
@@ -472,11 +486,15 @@ class Model(Lister, BaseClient):
     with open(filepath, "rb") as f:
       file_bytes = f.read()
 
-    return self.predict_by_bytes(file_bytes, input_type, inference_params, output_config)
+    return self.predict_by_bytes(file_bytes, input_type, compute_cluster_id, nodepool_id,
+                                 deployment_id, inference_params, output_config)
 
   def predict_by_bytes(self,
                        input_bytes: bytes,
                        input_type: str,
+                       compute_cluster_id: str = None,
+                       nodepool_id: str = None,
+                       deployment_id: str = None,
                        inference_params: Dict = {},
                        output_config: Dict = {}):
     """Predicts the model based on the given bytes.
@@ -484,6 +502,9 @@ class Model(Lister, BaseClient):
     Args:
         input_bytes (bytes): File Bytes to predict on.
         input_type (str): The type of input. Can be 'image', 'text', 'video' or 'audio.
+        compute_cluster_id (str): The compute cluster ID to use for the model.
+        nodepool_id (str): The nodepool ID to use for the model.
+        deployment_id (str): The deployment ID to use for the model.
         inference_params (dict): The inference params to override.
         output_config (dict): The output config to override.
           min_value (float): The minimum value of the prediction confidence to filter.
@@ -512,12 +533,30 @@ class Model(Lister, BaseClient):
     elif input_type == "audio":
       input_proto = Inputs.get_input_from_bytes("", audio_bytes=input_bytes)
 
+    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.")
+
+    runner_selector = None
+    if deployment_id:
+      runner_selector = Deployment.get_runner_selector(
+          user_id=self.user_id, deployment_id=deployment_id)
+    elif compute_cluster_id and nodepool_id:
+      runner_selector = Nodepool.get_runner_selector(
+          user_id=self.user_id, compute_cluster_id=compute_cluster_id, nodepool_id=nodepool_id)
+
     return self.predict(
-        inputs=[input_proto], inference_params=inference_params, output_config=output_config)
+        inputs=[input_proto],
+        runner_selector=runner_selector,
+        inference_params=inference_params,
+        output_config=output_config)
 
   def predict_by_url(self,
                      url: str,
                      input_type: str,
+                     compute_cluster_id: str = None,
+                     nodepool_id: str = None,
+                     deployment_id: str = None,
                      inference_params: Dict = {},
                      output_config: Dict = {}):
     """Predicts the model based on the given URL.
@@ -525,6 +564,9 @@ class Model(Lister, BaseClient):
     Args:
         url (str): The URL to predict.
         input_type (str): The type of input. Can be 'image', 'text', 'video' or 'audio.
+        compute_cluster_id (str): The compute cluster ID to use for the model.
+        nodepool_id (str): The nodepool ID to use for the model.
+        deployment_id (str): The deployment ID to use for the model.
         inference_params (dict): The inference params to override.
         output_config (dict): The output config to override.
           min_value (float): The minimum value of the prediction confidence to filter.
@@ -551,14 +593,43 @@ class Model(Lister, BaseClient):
     elif input_type == "audio":
       input_proto = Inputs.get_input_from_url("", audio_url=url)
 
-    return self.predict(
-        inputs=[input_proto], inference_params=inference_params, output_config=output_config)
+    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.")
+
+    runner_selector = None
+    if deployment_id:
+      runner_selector = Deployment.get_runner_selector(
+          user_id=self.user_id, deployment_id=deployment_id)
+    elif compute_cluster_id and nodepool_id:
+      runner_selector = Nodepool.get_runner_selector(
+          user_id=self.user_id, compute_cluster_id=compute_cluster_id, nodepool_id=nodepool_id)
 
-  def generate(self, inputs: List[Input], inference_params: Dict = {}, output_config: Dict = {}):
+    return self.predict(
+        inputs=[input_proto],
+        runner_selector=runner_selector,
+        inference_params=inference_params,
+        output_config=output_config)
+
+  def generate(self,
+               inputs: List[Input],
+               runner_selector: RunnerSelector = None,
+               inference_params: Dict = {},
+               output_config: Dict = {}):
     """Generate the stream output on model based on the given inputs.
 
     Args:
-        inputs (list[Input]): The inputs to predict, must be less than 128.
+        inputs (list[Input]): The inputs to generate, must be less than 128.
+        runner_selector (RunnerSelector): The runner selector to use for the model.
+        inference_params (dict): The inference params to override.
+
+    Example:
+        >>> from clarifai.client.model import Model
+        >>> model = Model("url") # Example URL: https://clarifai.com/clarifai/main/models/general-image-recognition
+                    or
+        >>> model = Model(model_id='model_id', user_id='user_id', app_id='app_id')
+        >>> stream_response = model.generate(inputs=[input1, input2], runner_selector=runner_selector)
+        >>> list_stream_response = [response for response in stream_response]
     """
     if not isinstance(inputs, list):
       raise UserError('Invalid inputs, inputs must be a list of Input objects.')
@@ -572,6 +643,7 @@ class Model(Lister, BaseClient):
         model_id=self.id,
         version_id=self.model_version.id,
         inputs=inputs,
+        runner_selector=runner_selector,
         model=self.model_info)
 
     start_time = time.time()
@@ -597,6 +669,9 @@ class Model(Lister, BaseClient):
   def generate_by_filepath(self,
                            filepath: str,
                            input_type: str,
+                           compute_cluster_id: str = None,
+                           nodepool_id: str = None,
+                           deployment_id: str = None,
                            inference_params: Dict = {},
                            output_config: Dict = {}):
     """Generate the stream output on model based on the given filepath.
@@ -604,6 +679,9 @@ class Model(Lister, BaseClient):
     Args:
         filepath (str): The filepath to predict.
         input_type (str): The type of input. Can be 'image', 'text', 'video' or 'audio.
+        compute_cluster_id (str): The compute cluster ID to use for the model.
+        nodepool_id (str): The nodepool ID to use for the model.
+        deployment_id (str): The deployment ID to use for the model.
         inference_params (dict): The inference params to override.
         output_config (dict): The output config to override.
           min_value (float): The minimum value of the prediction confidence to filter.
@@ -615,8 +693,7 @@ class Model(Lister, BaseClient):
         >>> model = Model("url") # Example URL: https://clarifai.com/clarifai/main/models/general-image-recognition
                     or
         >>> model = Model(model_id='model_id', user_id='user_id', app_id='app_id')
-        >>> stream_response = model.generate_by_filepath('/path/to/image.jpg', 'image')
-        >>> stream_response = model.generate_by_filepath('/path/to/text.txt', 'text')
+        >>> stream_response = model.generate_by_filepath('/path/to/image.jpg', 'image', deployment_id='deployment_id')
         >>> list_stream_response = [response for response in stream_response]
     """
     if not os.path.isfile(filepath):
@@ -625,11 +702,21 @@ class Model(Lister, BaseClient):
     with open(filepath, "rb") as f:
       file_bytes = f.read()
 
-    return self.generate_by_bytes(file_bytes, input_type, inference_params, output_config)
+    return self.generate_by_bytes(
+        filepath=file_bytes,
+        input_type=input_type,
+        compute_cluster_id=compute_cluster_id,
+        nodepool_id=nodepool_id,
+        deployment_id=deployment_id,
+        inference_params=inference_params,
+        output_config=output_config)
 
   def generate_by_bytes(self,
                         input_bytes: bytes,
                         input_type: str,
+                        compute_cluster_id: str = None,
+                        nodepool_id: str = None,
+                        deployment_id: str = None,
                         inference_params: Dict = {},
                         output_config: Dict = {}):
     """Generate the stream output on model based on the given bytes.
@@ -637,6 +724,9 @@ class Model(Lister, BaseClient):
     Args:
         input_bytes (bytes): File Bytes to predict on.
         input_type (str): The type of input. Can be 'image', 'text', 'video' or 'audio.
+        compute_cluster_id (str): The compute cluster ID to use for the model.
+        nodepool_id (str): The nodepool ID to use for the model.
+        deployment_id (str): The deployment ID to use for the model.
         inference_params (dict): The inference params to override.
         output_config (dict): The output config to override.
           min_value (float): The minimum value of the prediction confidence to filter.
@@ -648,6 +738,7 @@ class Model(Lister, BaseClient):
         >>> model = Model("https://clarifai.com/openai/chat-completion/models/GPT-4")
         >>> stream_response = model.generate_by_bytes(b'Write a tweet on future of AI',
                                                       input_type='text',
+                                                      deployment_id='deployment_id',
                                                       inference_params=dict(temperature=str(0.7), max_tokens=30)))
         >>> list_stream_response = [response for response in stream_response]
     """
@@ -666,12 +757,30 @@ class Model(Lister, BaseClient):
     elif input_type == "audio":
       input_proto = Inputs.get_input_from_bytes("", audio_bytes=input_bytes)
 
+    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.")
+
+    runner_selector = None
+    if deployment_id:
+      runner_selector = Deployment.get_runner_selector(
+          user_id=self.user_id, deployment_id=deployment_id)
+    elif compute_cluster_id and nodepool_id:
+      runner_selector = Nodepool.get_runner_selector(
+          user_id=self.user_id, compute_cluster_id=compute_cluster_id, nodepool_id=nodepool_id)
+
     return self.generate(
-        inputs=[input_proto], inference_params=inference_params, output_config=output_config)
+        inputs=[input_proto],
+        runner_selector=runner_selector,
+        inference_params=inference_params,
+        output_config=output_config)
 
   def generate_by_url(self,
                       url: str,
                       input_type: str,
+                      compute_cluster_id: str = None,
+                      nodepool_id: str = None,
+                      deployment_id: str = None,
                       inference_params: Dict = {},
                       output_config: Dict = {}):
     """Generate the stream output on model based on the given URL.
@@ -679,6 +788,9 @@ class Model(Lister, BaseClient):
     Args:
         url (str): The URL to predict.
         input_type (str): The type of input. Can be 'image', 'text', 'video' or 'audio.
+        compute_cluster_id (str): The compute cluster ID to use for the model.
+        nodepool_id (str): The nodepool ID to use for the model.
+        deployment_id (str): The deployment ID to use for the model.
         inference_params (dict): The inference params to override.
         output_config (dict): The output config to override.
           min_value (float): The minimum value of the prediction confidence to filter.
@@ -690,7 +802,7 @@ class Model(Lister, BaseClient):
         >>> model = Model("url") # Example URL: https://clarifai.com/clarifai/main/models/general-image-recognition
                     or
         >>> model = Model(model_id='model_id', user_id='user_id', app_id='app_id')
-        >>> stream_response = model.generate_by_url('url', 'image')
+        >>> stream_response = model.generate_by_url('url', 'image', deployment_id='deployment_id')
         >>> list_stream_response = [response for response in stream_response]
     """
     if input_type not in {'image', 'text', 'video', 'audio'}:
@@ -706,32 +818,58 @@ class Model(Lister, BaseClient):
     elif input_type == "audio":
       input_proto = Inputs.get_input_from_url("", audio_url=url)
 
+    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.")
+
+    runner_selector = None
+    if deployment_id:
+      runner_selector = Deployment.get_runner_selector(
+          user_id=self.user_id, deployment_id=deployment_id)
+    elif compute_cluster_id and nodepool_id:
+      runner_selector = Nodepool.get_runner_selector(
+          user_id=self.user_id, compute_cluster_id=compute_cluster_id, nodepool_id=nodepool_id)
+
     return self.generate(
-        inputs=[input_proto], inference_params=inference_params, output_config=output_config)
+        inputs=[input_proto],
+        runner_selector=runner_selector,
+        inference_params=inference_params,
+        output_config=output_config)
 
-  def _req_iterator(self, input_iterator: Iterator[List[Input]]):
+  def _req_iterator(self, input_iterator: Iterator[List[Input]], runner_selector: RunnerSelector):
     for inputs in input_iterator:
       yield service_pb2.PostModelOutputsRequest(
           user_app_id=self.user_app_id,
           model_id=self.id,
           version_id=self.model_version.id,
           inputs=inputs,
+          runner_selector=runner_selector,
           model=self.model_info)
 
   def stream(self,
              inputs: Iterator[List[Input]],
+             runner_selector: RunnerSelector = None,
              inference_params: Dict = {},
              output_config: Dict = {}):
     """Generate the stream output on model based on the given stream of inputs.
 
     Args:
         inputs (Iterator[list[Input]]): stream of inputs to predict, must be less than 128.
+        runner_selector (RunnerSelector): The runner selector to use for the model.
+
+    Example:
+        >>> from clarifai.client.model import Model
+        >>> model = Model("url") # Example URL: https://clarifai.com/clarifai/main/models/general-image-recognition
+                    or
+        >>> model = Model(model_id='model_id', user_id='user_id', app_id='app_id')
+        >>> stream_response = model.stream(inputs=inputs, runner_selector=runner_selector)
+        >>> list_stream_response = [response for response in stream_response]
     """
     # if not isinstance(inputs, Iterator[List[Input]]):
     #   raise UserError('Invalid inputs, inputs must be a iterator of list of Input objects.')
 
     self._override_model_version(inference_params, output_config)
-    request = self._req_iterator(inputs)
+    request = self._req_iterator(inputs, runner_selector)
 
     start_time = time.time()
     backoff_iterator = BackoffIterator(10)
@@ -756,6 +894,9 @@ class Model(Lister, BaseClient):
   def stream_by_filepath(self,
                          filepath: str,
                          input_type: str,
+                         compute_cluster_id: str = None,
+                         nodepool_id: str = None,
+                         deployment_id: str = None,
                          inference_params: Dict = {},
                          output_config: Dict = {}):
     """Stream the model output based on the given filepath.
@@ -763,6 +904,9 @@ class Model(Lister, BaseClient):
     Args:
         filepath (str): The filepath to predict.
         input_type (str): The type of input. Can be 'image', 'text', 'video' or 'audio.
+        compute_cluster_id (str): The compute cluster ID to use for the model.
+        nodepool_id (str): The nodepool ID to use for the model.
+        deployment_id (str): The deployment ID to use for the model.
         inference_params (dict): The inference params to override.
         output_config (dict): The output config to override.
           min_value (float): The minimum value of the prediction confidence to filter.
@@ -772,7 +916,7 @@ class Model(Lister, BaseClient):
     Example:
         >>> from clarifai.client.model import Model
         >>> model = Model("url")
-        >>> stream_response = model.stream_by_filepath('/path/to/image.jpg', 'image')
+        >>> stream_response = model.stream_by_filepath('/path/to/image.jpg', 'image', deployment_id='deployment_id')
         >>> list_stream_response = [response for response in stream_response]
     """
     if not os.path.isfile(filepath):
@@ -781,11 +925,21 @@ class Model(Lister, BaseClient):
     with open(filepath, "rb") as f:
       file_bytes = f.read()
 
-    return self.stream_by_bytes(iter([file_bytes]), input_type, inference_params, output_config)
+    return self.stream_by_bytes(
+        input_bytes_iterator=iter([file_bytes]),
+        input_type=input_type,
+        compute_cluster_id=compute_cluster_id,
+        nodepool_id=nodepool_id,
+        deployment_id=deployment_id,
+        inference_params=inference_params,
+        output_config=output_config)
 
   def stream_by_bytes(self,
                       input_bytes_iterator: Iterator[bytes],
                       input_type: str,
+                      compute_cluster_id: str = None,
+                      nodepool_id: str = None,
+                      deployment_id: str = None,
                       inference_params: Dict = {},
                       output_config: Dict = {}):
     """Stream the model output based on the given bytes.
@@ -793,6 +947,9 @@ class Model(Lister, BaseClient):
     Args:
         input_bytes_iterator (Iterator[bytes]): Iterator of file bytes to predict on.
         input_type (str): The type of input. Can be 'image', 'text', 'video' or 'audio.
+        compute_cluster_id (str): The compute cluster ID to use for the model.
+        nodepool_id (str): The nodepool ID to use for the model.
+        deployment_id (str): The deployment ID to use for the model.
         inference_params (dict): The inference params to override.
         output_config (dict): The output config to override.
           min_value (float): The minimum value of the prediction confidence to filter.
@@ -804,6 +961,7 @@ class Model(Lister, BaseClient):
         >>> model = Model("https://clarifai.com/openai/chat-completion/models/GPT-4")
         >>> stream_response = model.stream_by_bytes(iter([b'Write a tweet on future of AI']),
                                                     input_type='text',
+                                                    deployment_id='deployment_id',
                                                     inference_params=dict(temperature=str(0.7), max_tokens=30)))
         >>> list_stream_response = [response for response in stream_response]
     """
@@ -822,11 +980,30 @@ class Model(Lister, BaseClient):
         elif input_type == "audio":
           yield [Inputs.get_input_from_bytes("", audio_bytes=input_bytes)]
 
-    return self.stream(input_generator(), inference_params, output_config)
+    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.")
+
+    runner_selector = None
+    if deployment_id:
+      runner_selector = Deployment.get_runner_selector(
+          user_id=self.user_id, deployment_id=deployment_id)
+    elif compute_cluster_id and nodepool_id:
+      runner_selector = Nodepool.get_runner_selector(
+          user_id=self.user_id, compute_cluster_id=compute_cluster_id, nodepool_id=nodepool_id)
+
+    return self.stream(
+        inputs=input_generator(),
+        runner_selector=runner_selector,
+        inference_params=inference_params,
+        output_config=output_config)
 
   def stream_by_url(self,
                     url_iterator: Iterator[str],
                     input_type: str,
+                    compute_cluster_id: str = None,
+                    nodepool_id: str = None,
+                    deployment_id: str = None,
                     inference_params: Dict = {},
                     output_config: Dict = {}):
     """Stream the model output based on the given URL.
@@ -834,6 +1011,9 @@ class Model(Lister, BaseClient):
     Args:
         url_iterator (Iterator[str]): Iterator of URLs to predict.
         input_type (str): The type of input. Can be 'image', 'text', 'video' or 'audio.
+        compute_cluster_id (str): The compute cluster ID to use for the model.
+        nodepool_id (str): The nodepool ID to use for the model.
+        deployment_id (str): The deployment ID to use for the model.
         inference_params (dict): The inference params to override.
         output_config (dict): The output config to override.
           min_value (float): The minimum value of the prediction confidence to filter.
@@ -843,7 +1023,7 @@ class Model(Lister, BaseClient):
     Example:
         >>> from clarifai.client.model import Model
         >>> model = Model("url")
-        >>> stream_response = model.stream_by_url(iter(['url']), 'image')
+        >>> stream_response = model.stream_by_url(iter(['url']), 'image', deployment_id='deployment_id')
         >>> list_stream_response = [response for response in stream_response]
     """
     if input_type not in {'image', 'text', 'video', 'audio'}:
@@ -861,7 +1041,23 @@ class Model(Lister, BaseClient):
         elif input_type == "audio":
           yield [Inputs.get_input_from_url("", audio_url=url)]
 
-    return self.stream(input_generator(), inference_params, output_config)
+    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.")
+
+    runner_selector = None
+    if deployment_id:
+      runner_selector = Deployment.get_runner_selector(
+          user_id=self.user_id, deployment_id=deployment_id)
+    elif compute_cluster_id and nodepool_id:
+      runner_selector = Nodepool.get_runner_selector(
+          user_id=self.user_id, compute_cluster_id=compute_cluster_id, nodepool_id=nodepool_id)
+
+    return self.stream(
+        inputs=input_generator(),
+        runner_selector=runner_selector,
+        inference_params=inference_params,
+        output_config=output_config)
 
   def _override_model_version(self, inference_params: Dict = {}, output_config: Dict = {}) -> None:
     """Overrides the model version.

clarifai/client/nodepool.py

@@ -114,6 +114,28 @@ class Nodepool(Lister, BaseClient):
       deployment["visibility"] = resources_pb2.Visibility(**deployment["visibility"])
     return deployment
 
+  @staticmethod
+  def get_runner_selector(user_id: str, compute_cluster_id: str,
+                          nodepool_id: str) -> resources_pb2.RunnerSelector:
+    """Returns a RunnerSelector object for the specified compute cluster and nodepool.
+
+    Args:
+        user_id (str): The user ID of the user.
+        compute_cluster_id (str): The compute cluster ID for the compute cluster.
+        nodepool_id (str): The nodepool ID for the nodepool.
+
+    Returns:
+        resources_pb2.RunnerSelector: A RunnerSelector object for the specified compute cluster and nodepool.
+
+    Example:
+        >>> from clarifai.client.nodepool import Nodepool
+        >>> nodepool = Nodepool(nodepool_id="nodepool_id", user_id="user_id")
+        >>> runner_selector = Nodepool.get_runner_selector(user_id="user_id", compute_cluster_id="compute_cluster_id", nodepool_id="nodepool_id")
+    """
+    compute_cluster = resources_pb2.ComputeCluster(id=compute_cluster_id, user_id=user_id)
+    nodepool = resources_pb2.Nodepool(id=nodepool_id, compute_cluster=compute_cluster)
+    return resources_pb2.RunnerSelector(nodepool=nodepool)
+
   def create_deployment(self, deployment_id: str, config_filepath: str) -> Deployment:
     """Creates a deployment for the nodepool.
 

clarifai/datasets/upload/loaders/imagenet_classification.py

@@ -24,6 +24,10 @@ class ImageNetDataLoader(ClarifaiDataLoader):
 
     self.load_data()
 
+  @property
+  def task(self):
+    return "visual_classification"
+
   def load_data(self):
     #Creating label map
     with open(os.path.join(self.data_dir, "LOC_synset_mapping.txt")) as _file:
@@ -54,5 +58,5 @@ class ImageNetDataLoader(ClarifaiDataLoader):
   def __getitem__(self, idx):
     return VisualClassificationFeatures(
         image_path=self.image_paths[idx],
-        label=self.concepts[idx],
+        labels=self.concepts[idx],
         id=self.image_paths[idx].split('.')[0].split('/')[-1])

clarifai/runners/dockerfile_template/Dockerfile.cpu.template

@@ -1,5 +1,5 @@
 ARG PYTHON_VERSION=${PYTHON_VERSION}
-FROM public.ecr.aws/docker/library/python:${PYTHON_VERSION}-slim as build
+FROM public.ecr.aws/docker/library/python:${PYTHON_VERSION}-slim-bookworm as build
 
 # Set the working directory to /app
 WORKDIR /app

clarifai/runners/dockerfile_template/Dockerfile.cuda.template

@@ -6,37 +6,18 @@
 # * Export environment variables to use the virtualenv by default
 # * Create a non-root user with minimal privileges and use it
 ARG TARGET_PLATFORM=linux/amd64
-ARG CUDA_VERSION=12.4.0
-FROM --platform=$TARGET_PLATFORM nvidia/cuda:${CUDA_VERSION}-base-ubuntu22.04 AS build
-
-ARG DRIVER_VERSION=535
-ARG PYTHON_VERSION=${PYTHON_VERSION}
+FROM --platform=$TARGET_PLATFORM public.ecr.aws/docker/library/python:${PYTHON_VERSION}-slim-bookworm as build
 
 ENV DEBIAN_FRONTEND=noninteractive
 RUN apt-get update && \
     apt-get install --no-install-suggests --no-install-recommends --yes \
-    software-properties-common \
-    gpg-agent && \
-    add-apt-repository ppa:graphics-drivers/ppa && \
-    add-apt-repository ppa:deadsnakes/ppa && \
-    apt-get update && \
-    apt-get install --no-install-suggests --no-install-recommends --yes \
-    python${PYTHON_VERSION} \
-    python${PYTHON_VERSION}-venv \
-    python${PYTHON_VERSION}-dev \
+    software-properties-common  \
     gcc \
-    libpython3-dev \
-    # drivers and nvidia-smi
-    nvidia-utils-${DRIVER_VERSION} \
-    nvidia-driver-${DRIVER_VERSION} \
-    libcap2-bin && \
+    libpython3-dev && \
     python${PYTHON_VERSION} -m venv /venv && \
     /venv/bin/pip install --disable-pip-version-check --upgrade pip setuptools wheel && \
-    # Create a non-root user with minimal privileges and set file permissions
-    ln -sf /usr/bin/python${PYTHON_VERSION} /usr/bin/python3 && \
     apt-get clean && rm -rf /var/lib/apt/lists/*
 
-
 # Set environment variables to use virtualenv by default
 ENV VIRTUAL_ENV=/venv
 ENV PATH="$VIRTUAL_ENV/bin:$PATH"
@@ -57,54 +38,24 @@ RUN python -m pip install clarifai
 # Finally copy everything we built into a distroless image for runtime.
 ######################>#######
 ARG TARGET_PLATFORM=linux/amd64
-# FROM --platform=$TARGET_PLATFORM gcr.io/distroless/python3-debian12:latest
-FROM --platform=$TARGET_PLATFORM gcr.io/distroless/python3-debian12:debug
+FROM --platform=$TARGET_PLATFORM gcr.io/distroless/python3-debian12:latest
+# FROM --platform=$TARGET_PLATFORM gcr.io/distroless/python3-debian12:debug
 ARG PYTHON_VERSION=${PYTHON_VERSION}
 # needed to call pip directly
 COPY --from=build /bin/sh /bin/sh
 
-# Copy driver libraries based on architecture
-# Set FOLDER_NAME based on TARGET_PLATFORM
-ENV TARGET_PLATFORM=${TARGET_PLATFORM}
-ENV FOLDER_NAME="x86_64-linux-gnu"
-# RUN if [ "${TARGET_PLATFORM}" = "linux/arm64" ]; then \
-#         export FOLDER_NAME="aarch64-linux-gnu"; \
-#     fi && \
-#     echo "FOLDER_NAME=${FOLDER_NAME}"
-
-
 # virtual env
 COPY --from=build /venv /venv
 
-# cuda
-COPY --from=build --chmod=755 /usr/local/cuda /usr/local/cuda
-
 # We have to overwrite the python3 binary that the distroless image uses
-COPY --from=build /usr/bin/python${PYTHON_VERSION} /usr/bin/python3
+COPY --from=build /usr/local/bin/python${PYTHON_VERSION} /usr/bin/python3
 # And also copy in all the lib files for it.
-COPY --from=build /usr/lib/python${PYTHON_VERSION} /usr/lib/python${PYTHON_VERSION}
-# Note that distroless comes with a fixed python version, so we may need to overwrite that specific
-# version.
-
-# for debugging
-COPY --from=build /usr/bin/nvidia-smi /usr/bin/nvidia-smi
-# Copy driver libraries based on architecture
-COPY --from=build /usr/lib/${FOLDER_NAME}/libcuda.so* /usr/lib/${FOLDER_NAME}/
-COPY --from=build /usr/lib/${FOLDER_NAME}/libnvidia-ml.so* /usr/lib/${FOLDER_NAME}/
-
-# Set environment variables for CUDA
-ENV PATH=/usr/local/cuda/bin:${PATH}
-ENV LD_LIBRARY_PATH=/usr/local/cuda/lib64:/usr/lib/${FOLDER_NAME}:$LD_LIBRARY_PATH
-ENV CUDA_HOME=/usr/local/cuda
+COPY --from=build /usr/local/lib/ /usr/lib/
 
 # Set environment variables to use virtualenv by default
 ENV VIRTUAL_ENV=/venv
-# ENV PATH=${VIRTUAL_ENV}/bin:${PATH}
 ENV PYTHONPATH=${PYTHONPATH}:${VIRTUAL_ENV}/lib/python${PYTHON_VERSION}/site-packages
 
-# ENTRYPOINT ["${VIRTUAL_ENV}/bin/python"]
-
-
 # These will be set by the templaing system.
 ENV CLARIFAI_PAT=${CLARIFAI_PAT}
 ENV CLARIFAI_USER_ID=${CLARIFAI_USER_ID}
@@ -123,7 +74,6 @@ COPY . /app/model_dir/${name}
 # Add the model directory to the python path.
 ENV PYTHONPATH=${PYTHONPATH}:/app/model_dir/${name}
 
-
 # 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.
 CMD ["-m", "clarifai.runners.server", "--model_path", "/app/model_dir/${name}"]

clarifai/runners/models/model_upload.py

@@ -11,6 +11,7 @@ from rich import print
 
 from clarifai.client import BaseClient
 from clarifai.runners.utils.loader import HuggingFaceLoarder
+from clarifai.urls.helper import ClarifaiUrlHelper
 from clarifai.utils.logging import logger
 
 
@@ -33,6 +34,7 @@ class ModelUploader:
     self.config = self._load_config(os.path.join(self.folder, 'config.yaml'))
     self.model_proto = self._get_model_proto()
     self.model_id = self.model_proto.id
+    self.model_version_id = None
     self.inference_compute_info = self._get_inference_compute_info()
     self.is_v3 = True  # Do model build for v3
 
@@ -64,15 +66,27 @@ class ModelUploader:
       model = self.config.get('model')
       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"
+      # The owner of the model and the app.
       user_id = model.get('user_id')
       app_id = model.get('app_id')
 
       base = os.environ.get('CLARIFAI_API_BASE', 'https://api-dev.clarifai.com')
 
       self._client = BaseClient(user_id=user_id, app_id=app_id, base=base)
-      logger.info(f"Client initialized for user {user_id} and app {app_id}")
+
     return self._client
 
+  @property
+  def model_url(self):
+    url_helper = ClarifaiUrlHelper(self._client.auth_helper)
+    if self.model_version_id is not None:
+      return url_helper.clarifai_url(self.client.user_app_id.user_id,
+                                     self.client.user_app_id.app_id, "models", self.model_id)
+    else:
+      return url_helper.clarifai_url(self.client.user_app_id.user_id,
+                                     self.client.user_app_id.app_id, "models", self.model_id,
+                                     self.model_version_id)
+
   def _get_model_proto(self):
     assert "model" in self.config, "model info not found in the config file"
     model = self.config.get('model')
@@ -83,9 +97,6 @@ class ModelUploader:
     assert "app_id" in model, "app_id not found in the config file"
 
     model_proto = json_format.ParseDict(model, resources_pb2.Model())
-    assert model_proto.id == model_proto.id.lower(), "Model ID must be lowercase"
-    assert model_proto.user_id == model_proto.user_id.lower(), "User ID must be lowercase"
-    assert model_proto.app_id == model_proto.app_id.lower(), "App ID must be lowercase"
 
     return model_proto
 
@@ -95,15 +106,20 @@ class ModelUploader:
     inference_compute_info = self.config.get('inference_compute_info')
     return json_format.ParseDict(inference_compute_info, resources_pb2.ComputeInfo())
 
-  def maybe_create_model(self):
+  def check_model_exists(self):
     resp = self.client.STUB.GetModel(
         service_pb2.GetModelRequest(
             user_app_id=self.client.user_app_id, model_id=self.model_proto.id))
     if resp.status.code == status_code_pb2.SUCCESS:
+      return True
+    return False
+
+  def maybe_create_model(self):
+    if self.check_model_exists():
       logger.info(
           f"Model '{self.client.user_app_id.user_id}/{self.client.user_app_id.app_id}/models/{self.model_proto.id}' already exists, "
           f"will create a new version for it.")
-      return resp
+      return
 
     request = service_pb2.PostModelsRequest(
         user_app_id=self.client.user_app_id,
@@ -151,6 +167,18 @@ class ModelUploader:
     with open(os.path.join(self.folder, 'Dockerfile'), 'w') as dockerfile:
       dockerfile.write(dockerfile_content)
 
+  @property
+  def checkpoint_path(self):
+    return os.path.join(self.folder, self.checkpoint_suffix)
+
+  @property
+  def checkpoint_suffix(self):
+    return '1/checkpoints'
+
+  @property
+  def tar_file(self):
+    return f"{self.folder}.tar.gz"
+
   def download_checkpoints(self):
     if not self.config.get("checkpoints"):
       logger.info("No checkpoints specified in the config file")
@@ -173,8 +201,7 @@ class ModelUploader:
         assert hf_token != 'hf_token', "The default 'hf_token' is not valid. Please provide a valid token or leave that field out of config.yaml if not needed."
       loader = HuggingFaceLoarder(repo_id=repo_id, token=hf_token)
 
-      checkpoint_path = os.path.join(self.folder, '1', 'checkpoints')
-      success = loader.download_checkpoints(checkpoint_path)
+      success = loader.download_checkpoints(self.checkpoint_path)
 
       if not success:
         logger.error(f"Failed to download checkpoints for model {repo_id}")
@@ -207,7 +234,7 @@ class ModelUploader:
 
   def _get_model_version_proto(self):
 
-    model_version = resources_pb2.ModelVersion(
+    model_version_proto = resources_pb2.ModelVersion(
         pretrained_model_config=resources_pb2.PretrainedModelConfig(),
         inference_compute_info=self.inference_compute_info,
     )
@@ -216,31 +243,40 @@ class ModelUploader:
     if model_type_id in self.CONCEPTS_REQUIRED_MODEL_TYPE:
 
       loader = HuggingFaceLoarder()
-      checkpoint_path = os.path.join(self.folder, '1', 'checkpoints')
-      labels = loader.fetch_labels(checkpoint_path)
+      labels = loader.fetch_labels(self.checkpoint_path)
       # sort the concepts by id and then update the config file
       labels = sorted(labels.items(), key=lambda x: int(x[0]))
 
       config_file = os.path.join(self.folder, 'config.yaml')
       self.hf_labels_to_config(labels, config_file)
 
-      model_version.output_info.data.concepts.extend(self._concepts_protos_from_concepts(labels))
-    return model_version
+      model_version_proto.output_info.data.concepts.extend(
+          self._concepts_protos_from_concepts(labels))
+    return model_version_proto
 
-  def upload_model_version(self):
+  def upload_model_version(self, download_checkpoints):
     file_path = f"{self.folder}.tar.gz"
     logger.info(f"Will tar it into file: {file_path}")
 
+    if download_checkpoints:
+      tar_cmd = f"tar --exclude=*~ -czvf {self.tar_file} -C {self.folder} ."
+    else:  # we don't want to send the checkpoints up even if they are in the folder.
+      logger.info(f"Skipping {self.checkpoint_path} in the tar file that is uploaded.")
+      tar_cmd = f"tar --exclude={self.checkpoint_suffix} --exclude=*~ -czvf {self.tar_file} -C {self.folder} ."
     # Tar the folder
-    os.system(f"tar --exclude=*~ -czvf {self.folder}.tar.gz -C {self.folder} .")
+    logger.debug(tar_cmd)
+    os.system(tar_cmd)
     logger.info("Tarring complete, about to start upload.")
 
-    model_version = self._get_model_version_proto()
+    model_version_proto = self._get_model_version_proto()
+
+    file_size = os.path.getsize(self.tar_file)
+    logger.info(f"Size of the tar is: {file_size} bytes")
 
-    response = self.maybe_create_model()
+    self.maybe_create_model()
 
     for response in self.client.STUB.PostModelVersionsUpload(
-        self.model_version_stream_upload_iterator(model_version, file_path),):
+        self.model_version_stream_upload_iterator(model_version_proto, file_path),):
       percent_completed = 0
       if response.status.code == status_code_pb2.UPLOAD_IN_PROGRESS:
         percent_completed = response.status.percent_completed
@@ -257,13 +293,18 @@ class ModelUploader:
     if response.status.code != status_code_pb2.MODEL_BUILDING:
       logger.error(f"Failed to upload model version: {response}")
       return
-    model_version_id = response.model_version_id
-    logger.info(f"Created Model Version ID: {model_version_id}")
-
-    self.monitor_model_build(model_version_id)
-
-  def model_version_stream_upload_iterator(self, model_version, file_path):
-    yield self.init_upload_model_version(model_version, file_path)
+    self.model_version_id = response.model_version_id
+    logger.info(f"Created Model Version ID: {self.model_version_id}")
+    logger.info(f"Full url to that version is: {self.model_url}")
+
+    success = self.monitor_model_build()
+    if success:  # cleanup the tar_file if it exists
+      if os.path.exists(self.tar_file):
+        logger.info(f"Cleaning up upload file: {self.tar_file}")
+        os.remove(self.tar_file)
+
+  def model_version_stream_upload_iterator(self, model_version_proto, file_path):
+    yield self.init_upload_model_version(model_version_proto, file_path)
     with open(file_path, "rb") as f:
       file_size = os.path.getsize(file_path)
       chunk_size = int(127 * 1024 * 1024)  # 127MB chunk size
@@ -293,51 +334,58 @@ class ModelUploader:
     if read_so_far == file_size:
       logger.info("\nUpload complete!, waiting for model build...")
 
-  def init_upload_model_version(self, model_version, file_path):
+  def init_upload_model_version(self, model_version_proto, file_path):
     file_size = os.path.getsize(file_path)
-    logger.info(f"Uploading model version '{model_version.id}' of model {self.model_proto.id}")
+    logger.info(f"Uploading model version of model {self.model_proto.id}")
     logger.info(f"Using file '{os.path.basename(file_path)}' of size: {file_size} bytes")
     return service_pb2.PostModelVersionsUploadRequest(
         upload_config=service_pb2.PostModelVersionsUploadConfig(
             user_app_id=self.client.user_app_id,
             model_id=self.model_proto.id,
-            model_version=model_version,
+            model_version=model_version_proto,
             total_size=file_size,
             is_v3=self.is_v3,
         ))
 
-  def monitor_model_build(self, model_version_id):
+  def monitor_model_build(self):
     st = time.time()
     while True:
       resp = self.client.STUB.GetModelVersion(
           service_pb2.GetModelVersionRequest(
               user_app_id=self.client.user_app_id,
               model_id=self.model_proto.id,
-              version_id=model_version_id,
+              version_id=self.model_version_id,
           ))
       status_code = resp.model_version.status.code
       if status_code == status_code_pb2.MODEL_BUILDING:
         print(f"Model is building... (elapsed {time.time() - st:.1f}s)", end='\r', flush=True)
         time.sleep(1)
       elif status_code == status_code_pb2.MODEL_TRAINED:
-        logger.info("\nModel build complete!")
-        logger.info(
-            f"Check out the model at https://clarifai.com/{self.client.user_app_id.user_id}/apps/{self.client.user_app_id.app_id}/models/{self.model_id}/versions/{model_version_id}"
-        )
-        break
+        logger.info(f"\nModel build complete! (elapsed {time.time() - st:.1f}s)")
+        logger.info(f"Check out the model at {self.model_url}")
+        return True
       else:
         logger.info(
             f"\nModel build failed with status: {resp.model_version.status} and response {resp}")
-        break
+        return False
 
 
 def main(folder, download_checkpoints):
   uploader = ModelUploader(folder)
   if download_checkpoints:
     uploader.download_checkpoints()
-  uploader.create_dockerfile()
+  if not args.skip_dockerfile:
+    uploader.create_dockerfile()
+  exists = uploader.check_model_exists()
+  if exists:
+    logger.info(
+        f"Model already exists at {uploader.model_url}, this upload will create a new version for it."
+    )
+  else:
+    logger.info(f"New model will be created at {uploader.model_url} with it's first version.")
+
   input("Press Enter to continue...")
-  uploader.upload_model_version()
+  uploader.upload_model_version(download_checkpoints)
 
 
 if __name__ == "__main__":
@@ -351,6 +399,12 @@ if __name__ == "__main__":
       help=
       'Flag to download checkpoints before uploading and including them in the tar file that is uploaded. Defaults to False, which will attempt to download them at docker build time.',
   )
+  parser.add_argument(
+      '--skip_dockerfile',
+      action='store_true',
+      help=
+      'Flag to skip generating a dockerfile so that you can manually edit an already created dockerfile.',
+  )
   args = parser.parse_args()
 
   main(args.model_path, args.download_checkpoints)

clarifai/utils/evaluation/helpers.py

@@ -58,13 +58,16 @@ class _BaseEvalResultHandler:
   model: Model
   eval_data: List[resources_pb2.EvalMetrics] = field(default_factory=list)
 
-  def evaluate_and_wait(self, dataset: Dataset):
+  def evaluate_and_wait(self, dataset: Dataset, eval_info: dict = None):
     from tqdm import tqdm
     dataset_id = dataset.id
     dataset_app_id = dataset.app_id
     dataset_user_id = dataset.user_id
     _ = self.model.evaluate(
-        dataset_id=dataset_id, dataset_app_id=dataset_app_id, dataset_user_id=dataset_user_id)
+        dataset_id=dataset_id,
+        dataset_app_id=dataset_app_id,
+        dataset_user_id=dataset_user_id,
+        eval_info=eval_info)
     latest_eval = self.model.list_evaluations()[0]
     excepted = 10
     desc = f"Please wait for the evaluation process between model {self.get_model_name()} and dataset {dataset_user_id}/{dataset_app_id}/{dataset_id} to complete."
@@ -83,7 +86,10 @@ class _BaseEvalResultHandler:
           f"Model has failed to evaluate \n {latest_eval.status}.\nPlease check your dataset inputs!"
       )
 
-  def find_eval_id(self, datasets: List[Dataset] = [], attempt_evaluate: bool = False):
+  def find_eval_id(self,
+                   datasets: List[Dataset] = [],
+                   attempt_evaluate: bool = False,
+                   eval_info: dict = None):
     list_eval_outputs = self.model.list_evaluations()
     self.eval_data = []
     for dataset in datasets:
@@ -117,7 +123,7 @@ class _BaseEvalResultHandler:
       # if not evaluated, but user wants to proceed it
       if not _is_found:
         if attempt_evaluate:
-          self.eval_data.append(self.evaluate_and_wait(dataset))
+          self.eval_data.append(self.evaluate_and_wait(dataset, eval_info=eval_info))
         # otherwise raise error
         else:
           raise Exception(

clarifai/utils/evaluation/main.py

@@ -53,6 +53,7 @@ class EvalResultCompare:
                models: Union[List[Model], List[str]],
                datasets: Union[Dataset, List[Dataset], str, List[str]],
                attempt_evaluate: bool = False,
+               eval_info: dict = None,
                auth_kwargs: dict = {}):
     assert isinstance(models, list), ValueError("Expected list")
 
@@ -97,7 +98,7 @@ class EvalResultCompare:
         assert self.model_type == model_type, f"Can not compare when model types are different, {self.model_type} != {model_type}"
       m = make_handler_by_type(model_type)(model=model)
       logger.info(f"* {m.get_model_name(pretify=True)}")
-      m.find_eval_id(datasets=datasets, attempt_evaluate=attempt_evaluate)
+      m.find_eval_id(datasets=datasets, attempt_evaluate=attempt_evaluate, eval_info=eval_info)
       self._eval_handlers.append(m)
 
   @property

{clarifai-10.8.8.dist-info → clarifai-10.9.0.dist-info}/METADATA

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

{clarifai-10.8.8.dist-info → clarifai-10.9.0.dist-info}/RECORD

@@ -1,4 +1,4 @@
-clarifai/__init__.py,sha256=R5TlZkVSY_3KONgwTjYGkLjWDowTwpSZI-Sd8aiRjAU,23
+clarifai/__init__.py,sha256=Nt0sCLO5SfzhmX3Z2TYY4ZxvmbALrHAzZ1S3yAjDwgQ,23
 clarifai/cli.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 clarifai/errors.py,sha256=RwzTajwds51wLD0MVlMC5kcpBnzRpreDLlazPSBZxrg,2605
 clarifai/versions.py,sha256=jctnczzfGk_S3EnVqb2FjRKfSREkNmvNEwAAa_VoKiQ,222
@@ -7,12 +7,12 @@ clarifai/client/app.py,sha256=6pckYme1urV2YJjLIYfeZ-vH0Z5YSQa51jzIMcEfwug,38342
 clarifai/client/base.py,sha256=hSHOqkXbSKyaRDeylMMnkhUHCAHhEqno4KI0CXGziBA,7536
 clarifai/client/compute_cluster.py,sha256=lntZDLVDhS71Yj7mZrgq5uhnAuNPUnj48i3zMSuoUpk,8693
 clarifai/client/dataset.py,sha256=oqp6ryg7IyxCZcItzownadYJKK0s1DtghHwITN71_6E,30160
-clarifai/client/deployment.py,sha256=3V-kqXYAZabtxHHgmy_QAGOG5Idt8iJvc8NlUIbNHg8,2096
+clarifai/client/deployment.py,sha256=4gfvUvQY9adFS98B0vP9C5fR9OnDRV2JbUIdAkMymT8,2551
 clarifai/client/input.py,sha256=cEVRytrMF1gCgwHLbXlSbPSEQN8uHpUAoKcCdyHO1pc,44406
 clarifai/client/lister.py,sha256=03KGMvs5RVyYqxLsSrWhNc34I8kiF1Ph0NeyEwu7nMU,2082
-clarifai/client/model.py,sha256=_9kr__KP74v6PtSBtK1RrJjhrxzunXFVqyVn3xL78U0,74372
+clarifai/client/model.py,sha256=jNTyCxrME4vbU3Qw9nMSFwg4Ud8AuJrsmVYOMLBtbLI,83846
 clarifai/client/module.py,sha256=FTkm8s9m-EaTKN7g9MnLhGJ9eETUfKG7aWZ3o1RshYs,4204
-clarifai/client/nodepool.py,sha256=J9pnxQGO_HfScaUahccmEvJ4EOBib6k2nQR3gBdMoNs,9029
+clarifai/client/nodepool.py,sha256=DK8oqswjjrP6TqCqbw7Ge51Z7PxK3XmWZGLeUM3fd_A,10142
 clarifai/client/search.py,sha256=GaPWN6JmTQGZaCHr6U1yv0zqR6wKFl7i9IVLg2ul1CI,14254
 clarifai/client/user.py,sha256=0tcOk8_Yd1_ANj9E6sy9mz6s01V3qkmJS7pZVn_zUYo,17637
 clarifai/client/workflow.py,sha256=Wm4Fry6lGx8T43sBUqRI7v7sAmuvq_4Jft3vSW8UUJU,10516
@@ -41,7 +41,7 @@ clarifai/datasets/upload/loaders/README.md,sha256=aNRutSCTzLp2ruIZx74ZkN5AxpzwKO
 clarifai/datasets/upload/loaders/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 clarifai/datasets/upload/loaders/coco_captions.py,sha256=YfuNXplbdoH8N9ph7RyN9MfJTtOcJBG4ie1ow6-mELA,1516
 clarifai/datasets/upload/loaders/coco_detection.py,sha256=_I_yThw435KS9SH7zheBbJDK3zFgjTImBsES__ijjMk,2831
-clarifai/datasets/upload/loaders/imagenet_classification.py,sha256=LuylazxpI5V8fAPGCUxDirGpYMfxzRxix-MEWaCvwxI,1895
+clarifai/datasets/upload/loaders/imagenet_classification.py,sha256=i7W5F6FTB3LwLmhPgjZHmbCbS3l4LmjsuBFKtjxl1pU,1962
 clarifai/datasets/upload/loaders/xview_detection.py,sha256=hk8cZdYZimm4KOaZvBjYcC6ikURZMn51xmn7pXZT3HE,6052
 clarifai/models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 clarifai/models/api.py,sha256=d3FQQlG0mNDLrfEvchqaVcq4Tgb_TqryNnJtwp3c7sE,10961
@@ -55,14 +55,14 @@ clarifai/rag/rag.py,sha256=L10TcV9E0PF1aJ2Nn1z1x6WVoUoGxbKt20lQXg8ksqo,12594
 clarifai/rag/utils.py,sha256=yr1jAcbpws4vFGBqlAwPPE7v1DRba48g8gixLFw8OhQ,4070
 clarifai/runners/__init__.py,sha256=3vr4RVvN1IRy2SxJpyycAAvrUBbH-mXR7pqUmu4w36A,412
 clarifai/runners/server.py,sha256=CVLrv2DjzCvKVXcJ4SWvcFWUZq0bdlBmyEpfVlfgT2A,4902
-clarifai/runners/dockerfile_template/Dockerfile.cpu.template,sha256=lJw28GwMHEGO1uaDmEk2xb-Xx4y5pr_YY2Ipg25SLqo,1213
-clarifai/runners/dockerfile_template/Dockerfile.cuda.template,sha256=lwDwfeb9vtW3zVLBtlJYo44j02Am7FH2FABthwY47kY,4971
+clarifai/runners/dockerfile_template/Dockerfile.cpu.template,sha256=B35jcpqWBP3ALa2WRtbtBg8uvDyqP_PWZnJtIeAnjT0,1222
+clarifai/runners/dockerfile_template/Dockerfile.cuda.template,sha256=TMqTZBN1exMYzjLotn17DO4Je0rg9pBapIuwdohwht8,3228
 clarifai/runners/models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 clarifai/runners/models/base_typed_model.py,sha256=OnAk08Lo2Y1fGiBc6JJ6UvJ8P435cTsikTNYDkStDpI,7790
 clarifai/runners/models/model_class.py,sha256=9JSPAr4U4K7xI0kSl-q0mHB06zknm2OR-8XIgBCto94,1611
 clarifai/runners/models/model_runner.py,sha256=3vzoastQxkGRDK8T9aojDsLNBb9A3IiKm6YmbFrE9S0,6241
 clarifai/runners/models/model_servicer.py,sha256=L5AuqKDZrsKOnv_Fz1Ld4-nzqehltLTsYAS7NIclm1g,2880
-clarifai/runners/models/model_upload.py,sha256=vd9S_Oq33DO2RyWBcnjIaoll965VkkIYWwceKHaPAxk,14241
+clarifai/runners/models/model_upload.py,sha256=or1yUlBLOFM9gD3Jjg6Vc9zhpK9uqnRrp4B1bV5VCKM,15985
 clarifai/runners/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 clarifai/runners/utils/data_handler.py,sha256=sxy9zlAgI6ETuxCQhUgEXAn2GCsaW1GxpK6GTaMne0g,6966
 clarifai/runners/utils/data_utils.py,sha256=R1iQ82TuQ9JwxCJk8yEB1Lyb0BYVhVbWJI9YDi1zGOs,318
@@ -76,16 +76,16 @@ clarifai/utils/logging.py,sha256=rhutBRQJLtkNRz8IErNCgbIpvtl2fQ3D2otYcGqd3-Q,115
 clarifai/utils/misc.py,sha256=ptjt1NtteDT0EhrPoyQ7mgWtvoAQ-XNncQaZvNHb0KI,2253
 clarifai/utils/model_train.py,sha256=Mndqy5GNu7kjQHjDyNVyamL0hQFLGSHcWhOuPyOvr1w,8005
 clarifai/utils/evaluation/__init__.py,sha256=PYkurUrXrGevByj7RFb6CoU1iC7fllyQSfnnlo9WnY8,69
-clarifai/utils/evaluation/helpers.py,sha256=Fl3QzrtlvhtaLc8kD3As2hJGpnf7yHcQ6hA0sDstnnI,18378
-clarifai/utils/evaluation/main.py,sha256=u8j_ZcY2vKfhJhNJRvf6Ww1OsHfKg8gR-5HnXHF4aEY,15719
+clarifai/utils/evaluation/helpers.py,sha256=aZeHLI7oSmU5YDWQp5GdkYW5qbHx37nV9xwunKTAwWM,18549
+clarifai/utils/evaluation/main.py,sha256=sQAuMk0lPclXCYvy_rS7rYteo2xh9Ju13VNvbyGt_VM,15779
 clarifai/utils/evaluation/testset_annotation_parser.py,sha256=iZfLw6oR1qgJ3MHMbOZXcGBLu7btSDn0VqdiAzpIm4g,5002
 clarifai/workflows/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 clarifai/workflows/export.py,sha256=vICRhIreqDSShxLKjHNM2JwzKsf1B4fdXB0ciMcA70k,1945
 clarifai/workflows/utils.py,sha256=nGeB_yjVgUO9kOeKTg4OBBaBz-AwXI3m-huSVj-9W18,1924
 clarifai/workflows/validate.py,sha256=yJq03MaJqi5AK3alKGJJBR89xmmjAQ31sVufJUiOqY8,2556
-clarifai-10.8.8.dist-info/LICENSE,sha256=mUqF_d12-qE2n41g7C5_sq-BMLOcj6CNN-jevr15YHU,555
-clarifai-10.8.8.dist-info/METADATA,sha256=CjYP3nvJUa7UVUi8r5LAvzeMqaypddsVn6eGZ0nFSFA,19479
-clarifai-10.8.8.dist-info/WHEEL,sha256=GV9aMThwP_4oNCtvEC2ec3qUYutgWeAzklro_0m4WJQ,91
-clarifai-10.8.8.dist-info/entry_points.txt,sha256=qZOr_MIPG0dBBE1zringDJS_wXNGTAA_SQ-zcbmDHOw,82
-clarifai-10.8.8.dist-info/top_level.txt,sha256=wUMdCQGjkxaynZ6nZ9FAnvBUCgp5RJUVFSy2j-KYo0s,9
-clarifai-10.8.8.dist-info/RECORD,,
+clarifai-10.9.0.dist-info/LICENSE,sha256=mUqF_d12-qE2n41g7C5_sq-BMLOcj6CNN-jevr15YHU,555
+clarifai-10.9.0.dist-info/METADATA,sha256=oP8QYgz6MkknQDIQ9ky3lWJS_NwvSVp4nK4o8VIcH20,19479
+clarifai-10.9.0.dist-info/WHEEL,sha256=GV9aMThwP_4oNCtvEC2ec3qUYutgWeAzklro_0m4WJQ,91
+clarifai-10.9.0.dist-info/entry_points.txt,sha256=qZOr_MIPG0dBBE1zringDJS_wXNGTAA_SQ-zcbmDHOw,82
+clarifai-10.9.0.dist-info/top_level.txt,sha256=wUMdCQGjkxaynZ6nZ9FAnvBUCgp5RJUVFSy2j-KYo0s,9
+clarifai-10.9.0.dist-info/RECORD,,