clarifai 10.8.8__tar.gz → 10.9.0__tar.gz

{clarifai-10.8.8/clarifai.egg-info → clarifai-10.9.0}/PKG-INFO

@@ -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.9.0/clarifai/__init__.py

@@ -0,0 +1 @@
+__version__ = "10.9.0"

{clarifai-10.8.8 → clarifai-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-10.8.8 → clarifai-10.9.0}/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-10.8.8 → clarifai-10.9.0}/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-10.8.8 → clarifai-10.9.0}/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-10.8.8 → clarifai-10.9.0}/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