clarifai 10.8.7__py3-none-any.whl → 10.8.9__py3-none-any.whl

clarifai/__init__.py

@@ -1 +1 @@
-__version__ = "10.8.7"
+__version__ = "10.8.9"

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/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_servicer.py

@@ -13,6 +13,11 @@ class ModelServicer(service_pb2_grpc.V2Servicer):
   """
 
   def __init__(self, model_class):
+    """
+    Args:
+        model_class: The class that will handle the model logic. Must implement predict(),
+    generate(), stream().
+    """
     self.model_class = model_class
 
   def PostModelOutputs(self, request: service_pb2.PostModelOutputsRequest,

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
@@ -255,23 +291,28 @@ class ModelUploader:
           flush=True)
     print()
     if response.status.code != status_code_pb2.MODEL_BUILDING:
-      logger.error(f"Failed to upload model version: {response.status.description}")
+      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
       num_chunks = (file_size // chunk_size) + 1
       logger.info("Uploading file...")
-      logger.info("File size: ", file_size)
-      logger.info("Chunk size: ", chunk_size)
-      logger.info("Number of chunks: ", num_chunks)
+      logger.info(f"File size: {file_size}")
+      logger.info(f"Chunk size: {chunk_size}")
+      logger.info(f"Number of chunks: {num_chunks}")
       read_so_far = 0
       for part_id in range(num_chunks):
         try:
@@ -293,52 +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:
-        logger.info(
-            f"Model is building... (elapsed {time.time() - st:.1f}s)", end='\r', flush=True)
+        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__":
@@ -352,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/runners/server.py

@@ -15,6 +15,7 @@ from clarifai_protocol import BaseRunner
 from clarifai_protocol.utils.grpc_server import GRPCServer
 
 from clarifai.runners.models.model_servicer import ModelServicer
+from clarifai.runners.models.model_upload import ModelUploader
 from clarifai.utils.logging import logger
 
 
@@ -93,21 +94,26 @@ def main():
 
   MyRunner = classes[0]
 
-  # initialize the Runner class. This is what the user implements.
-  # (Note) do we want to set runner_id, nodepool_id, compute_cluster_id, base_url, num_parallel_polls as env vars? or as args?
-  runner = MyRunner(
-      runner_id=os.environ["CLARIFAI_RUNNER_ID"],
-      nodepool_id=os.environ["CLARIFAI_NODEPOOL_ID"],
-      compute_cluster_id=os.environ["CLARIFAI_COMPUTE_CLUSTER_ID"],
-      base_url=os.environ["CLARIFAI_API_BASE"],
-      num_parallel_polls=int(os.environ.get("CLARIFAI_NUM_THREADS", 1)),
-  )
-
-  # initialize the servicer
-  servicer = ModelServicer(runner)
-
   # Setup the grpc server for local development.
   if parsed_args.start_dev_server:
+
+    # We validate that we have checkpoints downloaded before constructing MyRunner which
+    # will call load_model()
+    uploader = ModelUploader(parsed_args.model_path)
+    uploader.download_checkpoints()
+
+    # initialize the Runner class. This is what the user implements.
+    # we aren't going to call runner.start() to engage with the API so IDs are not necessary.
+    runner = MyRunner(
+        runner_id="n/a",
+        nodepool_id="n/a",
+        compute_cluster_id="n/a",
+        health_check_port=None,  # not needed when running local server
+    )
+
+    # initialize the servicer with the runner so that it gets the predict(), generate(), stream() classes.
+    servicer = ModelServicer(runner)
+
     server = GRPCServer(
         futures.ThreadPoolExecutor(
             max_workers=parsed_args.pool_size,
@@ -121,9 +127,18 @@ def main():
     service_pb2_grpc.add_V2Servicer_to_server(servicer, server)
     server.start()
     logger.info("Started server on port %s", parsed_args.port)
-    # server.wait_for_termination() # won't get here currently.
-
-  runner.start()  # start the runner loop to fetch work from the API.
+    server.wait_for_termination()
+  else:  # start the runner with the proper env variables and as a runner protocol.
+
+    # initialize the Runner class. This is what the user implements.
+    runner = MyRunner(
+        runner_id=os.environ["CLARIFAI_RUNNER_ID"],
+        nodepool_id=os.environ["CLARIFAI_NODEPOOL_ID"],
+        compute_cluster_id=os.environ["CLARIFAI_COMPUTE_CLUSTER_ID"],
+        base_url=os.environ["CLARIFAI_API_BASE"],
+        num_parallel_polls=int(os.environ.get("CLARIFAI_NUM_THREADS", 1)),
+    )
+    runner.start()  # start the runner to fetch work from the API.
 
 
 if __name__ == '__main__':

{clarifai-10.8.7.dist-info → clarifai-10.8.9.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: clarifai
-Version: 10.8.7
+Version: 10.8.9
 Summary: Clarifai Python SDK
 Home-page: https://github.com/Clarifai/clarifai-python
 Author: Clarifai
@@ -21,7 +21,7 @@ Requires-Python: >=3.8
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: clarifai-grpc >=10.8.7
-Requires-Dist: clarifai-protocol >=0.0.4
+Requires-Dist: clarifai-protocol >=0.0.6
 Requires-Dist: numpy >=1.22.0
 Requires-Dist: tqdm >=4.65.0
 Requires-Dist: tritonclient >=2.34.0

{clarifai-10.8.7.dist-info → clarifai-10.8.9.dist-info}/RECORD

@@ -1,4 +1,4 @@
-clarifai/__init__.py,sha256=rJghd8fTbSCfCAow2Dmd1bS2hdZ2VQdNcu2IHtIH5vU,23
+clarifai/__init__.py,sha256=ITGMrK4qn_qf8hhGNDzj09T9nNZUSu_PifQ8w_1luTk,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
@@ -54,15 +54,15 @@ clarifai/rag/__init__.py,sha256=wu3PzAzo7uqgrEzuaC9lY_3gj1HFiR3GU3elZIKTT5g,40
 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=M6TaNy5gWgAJG29ZkUgzGThVNnWpWJerIiFINk2X-j4,4259
-clarifai/runners/dockerfile_template/Dockerfile.cpu.template,sha256=lJw28GwMHEGO1uaDmEk2xb-Xx4y5pr_YY2Ipg25SLqo,1213
-clarifai/runners/dockerfile_template/Dockerfile.cuda.template,sha256=lwDwfeb9vtW3zVLBtlJYo44j02Am7FH2FABthwY47kY,4971
+clarifai/runners/server.py,sha256=CVLrv2DjzCvKVXcJ4SWvcFWUZq0bdlBmyEpfVlfgT2A,4902
+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=i10oxz4pb1NsTQwkyhccJ3URg88Qn63XiuoBRCnJn9w,2737
-clarifai/runners/models/model_upload.py,sha256=4MD85lYtUwEolZF9nxmiH0zRM69Altv-z3luDlvxEvM,14276
+clarifai/runners/models/model_servicer.py,sha256=L5AuqKDZrsKOnv_Fz1Ld4-nzqehltLTsYAS7NIclm1g,2880
+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
@@ -83,9 +83,9 @@ clarifai/workflows/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuF
 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.7.dist-info/LICENSE,sha256=mUqF_d12-qE2n41g7C5_sq-BMLOcj6CNN-jevr15YHU,555
-clarifai-10.8.7.dist-info/METADATA,sha256=VwT5l9f_03dv65G4fsQgcHyEWZcsTOCBmpmodcj3OhE,19479
-clarifai-10.8.7.dist-info/WHEEL,sha256=GV9aMThwP_4oNCtvEC2ec3qUYutgWeAzklro_0m4WJQ,91
-clarifai-10.8.7.dist-info/entry_points.txt,sha256=qZOr_MIPG0dBBE1zringDJS_wXNGTAA_SQ-zcbmDHOw,82
-clarifai-10.8.7.dist-info/top_level.txt,sha256=wUMdCQGjkxaynZ6nZ9FAnvBUCgp5RJUVFSy2j-KYo0s,9
-clarifai-10.8.7.dist-info/RECORD,,
+clarifai-10.8.9.dist-info/LICENSE,sha256=mUqF_d12-qE2n41g7C5_sq-BMLOcj6CNN-jevr15YHU,555
+clarifai-10.8.9.dist-info/METADATA,sha256=5XzN2apyDmGS5cNukftBldIVjwRpEeGP1oXWomopRs4,19479
+clarifai-10.8.9.dist-info/WHEEL,sha256=GV9aMThwP_4oNCtvEC2ec3qUYutgWeAzklro_0m4WJQ,91
+clarifai-10.8.9.dist-info/entry_points.txt,sha256=qZOr_MIPG0dBBE1zringDJS_wXNGTAA_SQ-zcbmDHOw,82
+clarifai-10.8.9.dist-info/top_level.txt,sha256=wUMdCQGjkxaynZ6nZ9FAnvBUCgp5RJUVFSy2j-KYo0s,9
+clarifai-10.8.9.dist-info/RECORD,,