clarifai 10.11.0__py3-none-any.whl → 10.11.2rc1__py3-none-any.whl

clarifai/runners/models/model_upload.py

@@ -1,5 +1,6 @@
 import os
 import re
+import sys
 import time
 from string import Template
 
@@ -8,8 +9,12 @@ from clarifai_grpc.grpc.api import resources_pb2, service_pb2
 from clarifai_grpc.grpc.api.status import status_code_pb2
 from google.protobuf import json_format
 from rich import print
+from rich.markup import escape
 
 from clarifai.client import BaseClient
+from clarifai.runners.utils.const import (AVAILABLE_PYTHON_IMAGES, AVAILABLE_TORCH_IMAGES,
+                                          CONCEPTS_REQUIRED_MODEL_TYPE, DEFAULT_PYTHON_VERSION,
+                                          PYTHON_BASE_IMAGE, TORCH_BASE_IMAGE)
 from clarifai.runners.utils.loader import HuggingFaceLoader
 from clarifai.urls.helper import ClarifaiUrlHelper
 from clarifai.utils.logging import logger
@@ -23,53 +28,18 @@ def _clear_line(n: int = 1) -> None:
 
 
 class ModelUploader:
-  DEFAULT_PYTHON_VERSION = 3.11
-  DEFAULT_TORCH_VERSION = '2.4.0'
-  DEFAULT_CUDA_VERSION = '124'
-  # List of available torch images for matrix
-  '''
-        python_version: ['3.8', '3.9', '3.10', '3.11']
-        torch_version: ['2.0.0', '2.1.0', '2.2.0', '2.3.0', '2.4.0', '2.4.1', '2.5.0']
-        cuda_version: ['124']
-  '''
-  AVAILABLE_TORCH_IMAGES = [
-      '2.0.0-py3.8-cuda124',
-      '2.0.0-py3.9-cuda124',
-      '2.0.0-py3.10-cuda124',
-      '2.0.0-py3.11-cuda124',
-      '2.1.0-py3.8-cuda124',
-      '2.1.0-py3.9-cuda124',
-      '2.1.0-py3.10-cuda124',
-      '2.1.0-py3.11-cuda124',
-      '2.2.0-py3.8-cuda124',
-      '2.2.0-py3.9-cuda124',
-      '2.2.0-py3.10-cuda124',
-      '2.2.0-py3.11-cuda124',
-      '2.3.0-py3.8-cuda124',
-      '2.3.0-py3.9-cuda124',
-      '2.3.0-py3.10-cuda124',
-      '2.3.0-py3.11-cuda124',
-      '2.4.0-py3.8-cuda124',
-      '2.4.0-py3.9-cuda124',
-      '2.4.0-py3.10-cuda124',
-      '2.4.0-py3.11-cuda124',
-      '2.4.1-py3.8-cuda124',
-      '2.4.1-py3.9-cuda124',
-      '2.4.1-py3.10-cuda124',
-      '2.4.1-py3.11-cuda124',
-  ]
-  AVAILABLE_PYTHON_IMAGES = ['3.8', '3.9', '3.10', '3.11', '3.12', '3.13']
-  PYTHON_BASE_IMAGE = 'public.ecr.aws/clarifai-models/python-base:{python_version}'
-  TORCH_BASE_IMAGE = 'public.ecr.aws/clarifai-models/torch:{torch_version}-py{python_version}-cuda{cuda_version}'
-
-  CONCEPTS_REQUIRED_MODEL_TYPE = [
-      'visual-classifier', 'visual-detector', 'visual-segmenter', 'text-classifier'
-  ]
-
-  def __init__(self, folder: str):
+
+  def __init__(self, folder: str, validate_api_ids: bool = True):
+    """
+    :param folder: The folder containing the model.py, config.yaml, requirements.txt and
+    checkpoints.
+    :param validate_api_ids: Whether to validate the user_id and app_id in the config file.
+    """
     self._client = None
     self.folder = self._validate_folder(folder)
     self.config = self._load_config(os.path.join(self.folder, 'config.yaml'))
+    self.validate_api_ids = validate_api_ids
+    self._validate_config()
     self.model_proto = self._get_model_proto()
     self.model_id = self.model_proto.id
     self.model_version_id = None
@@ -108,13 +78,64 @@ class ModelUploader:
       assert "repo_id" in self.config.get("checkpoints"), "No repo_id specified in the config file"
       repo_id = self.config.get("checkpoints").get("repo_id")
 
-      # prefer env var for HF_TOKEN but if not provided then use the one from config.yaml if any.
-      if 'HF_TOKEN' in os.environ:
-        hf_token = os.environ['HF_TOKEN']
-      else:
-        hf_token = self.config.get("checkpoints").get("hf_token", None)
+      # get from config.yaml otherwise fall back to HF_TOKEN env var.
+      hf_token = self.config.get("checkpoints").get("hf_token", os.environ.get("HF_TOKEN", None))
       return repo_id, hf_token
 
+  def _check_app_exists(self):
+    if not self.validate_api_ids:
+      return True
+    resp = self.client.STUB.GetApp(service_pb2.GetAppRequest(user_app_id=self.client.user_app_id))
+    if resp.status.code == status_code_pb2.SUCCESS:
+      return True
+    return False
+
+  def _validate_config_model(self):
+    assert "model" in self.config, "model section not found in the config file"
+    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"
+    assert "model_type_id" in model, "model_type_id not found in the config file"
+    assert "id" in model, "model_id not found in the config file"
+    if '.' in model.get('id'):
+      logger.error(
+          "Model ID cannot contain '.', please remove it from the model_id in the config file")
+      sys.exit(1)
+
+    assert model.get('user_id') != "", "user_id cannot be empty in the config file"
+    assert model.get('app_id') != "", "app_id cannot be empty in the config file"
+    assert model.get('model_type_id') != "", "model_type_id cannot be empty in the config file"
+    assert model.get('id') != "", "model_id cannot be empty in the config file"
+
+    if not self._check_app_exists():
+      logger.error(
+          f"App {self.client.user_app_id.app_id} not found for user {self.client.user_app_id.user_id}"
+      )
+      sys.exit(1)
+
+  def _validate_config(self):
+    self._validate_config_model()
+
+    if self.config.get("checkpoints"):
+      self._validate_config_checkpoints()
+
+    assert "inference_compute_info" in self.config, "inference_compute_info not found in the config file"
+
+    if self.config.get("concepts"):
+      model_type_id = self.config.get('model').get('model_type_id')
+      assert model_type_id in CONCEPTS_REQUIRED_MODEL_TYPE, f"Model type {model_type_id} not supported for concepts"
+
+    if self.config.get("checkpoints"):
+      _, hf_token = self._validate_config_checkpoints()
+
+      if hf_token:
+        is_valid_token = HuggingFaceLoader.validate_hftoken(hf_token)
+        if not is_valid_token:
+          logger.error(
+              "Invalid Hugging Face token provided in the config file, this might cause issues with downloading the restricted model checkpoints."
+          )
+          logger.info("Continuing without Hugging Face token")
+
   @property
   def client(self):
     if self._client is None:
@@ -233,33 +254,35 @@ class ModelUploader:
     build_info = self.config.get('build_info', {})
     if 'python_version' in build_info:
       python_version = build_info['python_version']
-      if python_version not in self.AVAILABLE_PYTHON_IMAGES:
+      if python_version not in AVAILABLE_PYTHON_IMAGES:
         logger.error(
-            f"Python version {python_version} not supported, please use one of the following versions: {self.AVAILABLE_PYTHON_IMAGES}"
+            f"Python version {python_version} not supported, please use one of the following versions: {AVAILABLE_PYTHON_IMAGES}"
         )
         return
       logger.info(
           f"Using Python version {python_version} from the config file to build the Dockerfile")
     else:
       logger.info(
-          f"Python version not found in the config file, using default Python version: {self.DEFAULT_PYTHON_VERSION}"
+          f"Python version not found in the config file, using default Python version: {DEFAULT_PYTHON_VERSION}"
       )
-      python_version = self.DEFAULT_PYTHON_VERSION
+      python_version = DEFAULT_PYTHON_VERSION
 
-    base_image = self.PYTHON_BASE_IMAGE.format(python_version=python_version)
+    base_image = PYTHON_BASE_IMAGE.format(python_version=python_version)
 
     # Parse the requirements.txt file to determine the base image
     dependencies = self._parse_requirements()
     if 'torch' in dependencies and dependencies['torch']:
       torch_version = dependencies['torch']
 
-      for image in self.AVAILABLE_TORCH_IMAGES:
+      for image in AVAILABLE_TORCH_IMAGES:
         if torch_version in image and f'py{python_version}' in image:
-          base_image = self.TORCH_BASE_IMAGE.format(
+          cuda_version = image.split('-')[-1].replace('cuda', '')
+          base_image = TORCH_BASE_IMAGE.format(
               torch_version=torch_version,
               python_version=python_version,
-              cuda_version=self.DEFAULT_CUDA_VERSION)
-          logger.info(f"Using Torch version {torch_version} base image  to build the Docker image")
+              cuda_version=cuda_version,
+          )
+          logger.info(f"Using Torch version {torch_version} base image to build the Docker image")
           break
 
     # Replace placeholders with actual values
@@ -296,6 +319,7 @@ class ModelUploader:
 
     if not success:
       logger.error(f"Failed to download checkpoints for model {repo_id}")
+      sys.exit(1)
     else:
       logger.info(f"Downloaded checkpoints for model {repo_id}")
     return success
@@ -314,7 +338,7 @@ class ModelUploader:
       config = yaml.safe_load(file)
     model = config.get('model')
     model_type_id = model.get('model_type_id')
-    assert model_type_id in self.CONCEPTS_REQUIRED_MODEL_TYPE, f"Model type {model_type_id} not supported for concepts"
+    assert model_type_id in CONCEPTS_REQUIRED_MODEL_TYPE, f"Model type {model_type_id} not supported for concepts"
     concept_protos = self._concepts_protos_from_concepts(labels)
 
     config['concepts'] = [{'id': concept.id, 'name': concept.name} for concept in concept_protos]
@@ -332,7 +356,7 @@ class ModelUploader:
     )
 
     model_type_id = self.config.get('model').get('model_type_id')
-    if model_type_id in self.CONCEPTS_REQUIRED_MODEL_TYPE:
+    if model_type_id in CONCEPTS_REQUIRED_MODEL_TYPE:
 
       if 'concepts' in self.config:
         labels = self.config.get('concepts')
@@ -347,7 +371,10 @@ class ModelUploader:
         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)
+        try:
+          self.hf_labels_to_config(labels, config_file)
+        except Exception as e:
+          logger.error(f"Failed to update the config.yaml file with the concepts: {e}")
 
         model_version_proto.output_info.data.concepts.extend(
             self._concepts_protos_from_concepts(labels))
@@ -359,7 +386,7 @@ class ModelUploader:
 
     model_type_id = self.config.get('model').get('model_type_id')
 
-    if (model_type_id in self.CONCEPTS_REQUIRED_MODEL_TYPE) and 'concepts' not in self.config:
+    if (model_type_id in CONCEPTS_REQUIRED_MODEL_TYPE) and 'concepts' not in self.config:
       logger.info(
           f"Model type {model_type_id} requires concepts to be specified in the config.yaml file.."
       )
@@ -387,10 +414,10 @@ class ModelUploader:
     model_version_proto = self.get_model_version_proto()
 
     if download_checkpoints:
-      tar_cmd = f"tar --exclude=*~ -czvf {self.tar_file} -C {self.folder} ."
+      tar_cmd = f"tar --exclude=*~ --exclude={self.tar_file} -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_cmd = f"tar --exclude={self.checkpoint_suffix} --exclude=*~ --exclude={self.tar_file} -czvf {self.tar_file} -C {self.folder} ."
     # Tar the folder
     logger.debug(tar_cmd)
     os.system(tar_cmd)
@@ -400,6 +427,9 @@ class ModelUploader:
     logger.info(f"Size of the tar is: {file_size} bytes")
 
     self.maybe_create_model()
+    if not self.check_model_exists():
+      logger.error(f"Failed to create model: {self.model_proto.id}")
+      sys.exit(1)
 
     for response in self.client.STUB.PostModelVersionsUpload(
         self.model_version_stream_upload_iterator(model_version_proto, file_path),):
@@ -464,7 +494,7 @@ class ModelUploader:
     file_size = os.path.getsize(file_path)
     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(
+    result = service_pb2.PostModelVersionsUploadRequest(
         upload_config=service_pb2.PostModelVersionsUploadConfig(
             user_app_id=self.client.user_app_id,
             model_id=self.model_proto.id,
@@ -472,9 +502,23 @@ class ModelUploader:
             total_size=file_size,
             is_v3=self.is_v3,
         ))
+    return result
+
+  def get_model_build_logs(self):
+    logs_request = service_pb2.ListLogEntriesRequest(
+        log_type="builder",
+        user_app_id=self.client.user_app_id,
+        model_id=self.model_proto.id,
+        model_version_id=self.model_version_id,
+        page=1,
+        per_page=50)
+    response = self.client.STUB.ListLogEntries(logs_request)
+
+    return response
 
   def monitor_model_build(self):
     st = time.time()
+    seen_logs = set()  # To avoid duplicate log messages
     while True:
       resp = self.client.STUB.GetModelVersion(
           service_pb2.GetModelVersionRequest(
@@ -485,6 +529,13 @@ class ModelUploader:
       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)
+
+        # Fetch and display the logs
+        logs = self.get_model_build_logs()
+        for log_entry in logs.log_entries:
+          if log_entry.url not in seen_logs:
+            seen_logs.add(log_entry.url)
+            print(f"Model Building Logs...: {escape(log_entry.message.strip())}")
         time.sleep(1)
       elif status_code == status_code_pb2.MODEL_TRAINED:
         logger.info(f"\nModel build complete! (elapsed {time.time() - st:.1f}s)")

clarifai/runners/server.py

@@ -108,6 +108,7 @@ def main():
         runner_id="n/a",
         nodepool_id="n/a",
         compute_cluster_id="n/a",
+        user_id="n/a",
         health_check_port=None,  # not needed when running local server
     )
 
@@ -127,6 +128,7 @@ def main():
     service_pb2_grpc.add_V2Servicer_to_server(servicer, server)
     server.start()
     logger.info("Started server on port %s", parsed_args.port)
+    logger.info(f"Access the model at http://localhost:{parsed_args.port}")
     server.wait_for_termination()
   else:  # start the runner with the proper env variables and as a runner protocol.
 

clarifai/runners/utils/const.py

@@ -0,0 +1,42 @@
+import os
+
+registry = os.environ.get('CLARIFAI_BASE_IMAGE_REGISTRY', 'public.ecr.aws/clarifai-models')
+
+PYTHON_BASE_IMAGE = registry + '/python-base:{python_version}'
+TORCH_BASE_IMAGE = registry + '/torch:{torch_version}-py{python_version}-cuda{cuda_version}'
+
+# List of available python base images
+AVAILABLE_PYTHON_IMAGES = ['3.11', '3.12', '3.13']
+
+DEFAULT_PYTHON_VERSION = 3.12
+
+# List of available torch images
+AVAILABLE_TORCH_IMAGES = [
+    '2.2.2-py3.11-cuda121',
+    '2.3.1-py3.11-cuda121',
+    '2.4.0-py3.11-cuda121',
+    '2.4.0-py3.11-cuda124',
+    '2.4.1-py3.11-cuda121',
+    '2.4.1-py3.11-cuda124',
+    '2.5.1-py3.11-cuda121',
+    '2.5.1-py3.11-cuda124',
+    '2.2.2-py3.12-cuda121',
+    '2.3.1-py3.12-cuda121',
+    '2.4.0-py3.12-cuda121',
+    '2.4.0-py3.12-cuda124',
+    '2.4.1-py3.12-cuda121',
+    '2.4.1-py3.12-cuda124',
+    '2.5.1-py3.12-cuda121',
+    '2.5.1-py3.12-cuda124',
+    # '2.2.2-py3.13-cuda121',
+    # '2.3.1-py3.13-cuda121',
+    # '2.4.0-py3.13-cuda121',
+    # '2.4.0-py3.13-cuda124',
+    # '2.4.1-py3.13-cuda121',
+    # '2.4.1-py3.13-cuda124',
+    # '2.5.1-py3.13-cuda121',
+    # '2.5.1-py3.13-cuda124',
+]
+CONCEPTS_REQUIRED_MODEL_TYPE = [
+    'visual-classifier', 'visual-detector', 'visual-segmenter', 'text-classifier'
+]

clarifai/runners/utils/loader.py

@@ -14,26 +14,32 @@ class HuggingFaceLoader:
     self.repo_id = repo_id
     self.token = token
     if token:
-      try:
-        if importlib.util.find_spec("huggingface_hub") is None:
-          raise ImportError(self.HF_DOWNLOAD_TEXT)
-        os.environ['HF_TOKEN'] = token
-        from huggingface_hub import HfApi
-
-        api = HfApi()
-        api.whoami(token=token)
-
+      if self.validate_hftoken(token):
         subprocess.run(f'huggingface-cli login --token={os.environ["HF_TOKEN"]}', shell=True)
-      except Exception as e:
-        logger.error(
-            f"Error setting up Hugging Face token, please make sure you have the correct token: {e}"
-        )
+        logger.info("Hugging Face token validated")
+      else:
         logger.info("Continuing without Hugging Face token")
 
+  @classmethod
+  def validate_hftoken(cls, hf_token: str):
+    try:
+      if importlib.util.find_spec("huggingface_hub") is None:
+        raise ImportError(cls.HF_DOWNLOAD_TEXT)
+      os.environ['HF_TOKEN'] = hf_token
+      from huggingface_hub import HfApi
+
+      api = HfApi()
+      api.whoami(token=hf_token)
+      return True
+    except Exception as e:
+      logger.error(
+          f"Error setting up Hugging Face token, please make sure you have the correct token: {e}")
+      return False
+
   def download_checkpoints(self, checkpoint_path: str):
     # throw error if huggingface_hub wasn't installed
     try:
-      from huggingface_hub import snapshot_download
+      from huggingface_hub import list_repo_files, snapshot_download
     except ImportError:
       raise ImportError(self.HF_DOWNLOAD_TEXT)
     if os.path.exists(checkpoint_path) and self.validate_download(checkpoint_path):
@@ -46,10 +52,19 @@ class HuggingFaceLoader:
         if not is_hf_model_exists:
           logger.error("Model %s not found on Hugging Face" % (self.repo_id))
           return False
+
+        ignore_patterns = None  # Download everything.
+        repo_files = list_repo_files(repo_id=self.repo_id, token=self.token)
+        if any(f.endswith(".safetensors") for f in repo_files):
+          logger.info(f"SafeTensors found in {self.repo_id}, downloading only .safetensors files.")
+          ignore_patterns = ["**/original/*", "**/*.pth", "**/*.bin"]
         snapshot_download(
-            repo_id=self.repo_id, local_dir=checkpoint_path, local_dir_use_symlinks=False)
+            repo_id=self.repo_id,
+            local_dir=checkpoint_path,
+            local_dir_use_symlinks=False,
+            ignore_patterns=ignore_patterns)
       except Exception as e:
-        logger.exception(f"Error downloading model checkpoints {e}")
+        logger.error(f"Error downloading model checkpoints {e}")
         return False
       finally:
         is_downloaded = self.validate_download(checkpoint_path)

clarifai/runners/utils/logging.py

@@ -0,0 +1,6 @@
+import os
+
+from clarifai.utils.logging import get_logger
+
+logger_level = os.environ.get("LOG_LEVEL", "INFO")
+logger = get_logger(logger_level, __name__)

clarifai/utils/logging.py

@@ -282,6 +282,11 @@ class JsonFormatter(logging.Formatter):
       except Exception:
         self.source_host = ""
 
+    self.extra_blacklist_fields = []
+    extra_blacklist_fields = os.getenv('EXTRA_JSON_LOGGER_BLACKLIST_FIELDS', None)
+    if extra_blacklist_fields:
+      self.extra_blacklist_fields = extra_blacklist_fields.split(",")
+
   def _build_fields(self, defaults, fields):
     """Return provided fields including any in defaults
     """
@@ -302,6 +307,8 @@ class JsonFormatter(logging.Formatter):
       msg = record.getMessage()
     for k in FIELD_BLACKLIST:
       fields.pop(k, None)
+    for k in self.extra_blacklist_fields:
+      fields.pop(k, None)
     # Rename 'levelname' to 'level' and make the value lowercase to match Go logs
     level = fields.pop('levelname', None)
     if level:

{clarifai-10.11.0.dist-info → clarifai-10.11.2rc1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: clarifai
-Version: 10.11.0
+Version: 10.11.2rc1
 Summary: Clarifai Python SDK
 Home-page: https://github.com/Clarifai/clarifai-python
 Author: Clarifai
@@ -20,22 +20,21 @@ Classifier: Operating System :: OS Independent
 Requires-Python: >=3.8
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: clarifai-grpc>=10.10.2
-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
-Requires-Dist: rich>=13.4.2
-Requires-Dist: PyYAML>=6.0.1
-Requires-Dist: schema==0.7.5
-Requires-Dist: Pillow>=9.5.0
-Requires-Dist: inquirerpy==0.3.4
-Requires-Dist: tabulate>=0.9.0
-Requires-Dist: protobuf==5.27.3
-Requires-Dist: fsspec==2024.6.1
-Requires-Dist: click==8.1.7
+Requires-Dist: clarifai-grpc >=11.0.0
+Requires-Dist: clarifai-protocol >=0.0.14
+Requires-Dist: numpy >=1.22.0
+Requires-Dist: tqdm >=4.65.0
+Requires-Dist: tritonclient >=2.34.0
+Requires-Dist: rich >=13.4.2
+Requires-Dist: PyYAML >=6.0.1
+Requires-Dist: schema ==0.7.5
+Requires-Dist: Pillow >=9.5.0
+Requires-Dist: inquirerpy ==0.3.4
+Requires-Dist: tabulate >=0.9.0
+Requires-Dist: fsspec ==2024.6.1
+Requires-Dist: click ==8.1.7
 Provides-Extra: all
-Requires-Dist: pycocotools==2.0.6; extra == "all"
+Requires-Dist: pycocotools ==2.0.6 ; extra == 'all'
 
 <h1 align="center">
   <a href="https://www.clarifai.com/"><img alt="Clarifai" title="Clarifai" src="https://github.com/user-attachments/assets/623b883b-7fe5-4b95-bbfa-8691f5779af4"></a>
@@ -73,6 +72,10 @@ Give the repo a star ⭐
 
 * **[Installation](#rocket-installation)**
 * **[Getting Started](#memo-getting-started)**
+* **[Compute Orchestration](#rocket-compute-orchestration)**
+  * [Cluster Operations](#cluster-operations)
+  * [Nodepool Operations](#nodepool-operations)
+  * [Depolyment Operations](#deployment-operations)
 * **[Interacting with Datasets](#floppy_disk-interacting-with-datasets)**
 * **[Interacting with Inputs](#floppy_disk-interacting-with-inputs)**
   * [Input Upload](#input-upload)
@@ -157,6 +160,73 @@ client = User(user_id="user_id", pat="your personal access token")
 ```
 
 
+## :rocket: Compute Orchestration
+
+Clarifai’s Compute Orchestration offers a streamlined solution for managing the infrastructure required for training, deploying, and scaling machine learning models and workflows.
+
+This flexible system supports any compute instance — across various hardware providers and deployment methods — and provides automatic scaling to match workload demands. [More Details](https://www.clarifai.com/products/compute-orchestration)
+
+#### Cluster Operations
+```python
+from clarifai.client.user import User
+client = User(user_id="user_id",base_url="https://api.clarifai.com")
+
+# Create a new compute cluster
+compute_cluster = client.create_compute_cluster(compute_cluster_id="demo-id",config_filepath="computer_cluster_config.yaml")
+
+# List Clusters
+all_compute_clusters = list(client.list_compute_clusters())
+print(all_compute_clusters)
+```
+##### [Example Cluster Config](https://github.com/Clarifai/examples/blob/main/ComputeOrchestration/configs/compute_cluster_config.yaml)
+
+
+
+#### Nodepool Operations
+```python
+from clarifai.client.compute_cluster import ComputeCluster
+
+# Initialize the ComputeCluster instance
+compute_cluster = ComputeCluster(user_id="user_id",compute_cluster_id="demo-id")
+
+# Create a new nodepool
+nodepool = compute_cluster.create_nodepool(nodepool_id="demo-nodepool-id",config_filepath="nodepool_config.yaml")
+
+#Get a nodepool
+nodepool = compute_cluster.nodepool(nodepool_id="demo-nodepool-id")
+print(nodepool)
+
+# List nodepools
+all_nodepools = list(compute_cluster.list_nodepools())
+print(all_nodepools)
+```
+##### [Example Nodepool config](https://github.com/Clarifai/examples/blob/main/ComputeOrchestration/configs/nodepool_config.yaml)
+
+#### Deployment Operations
+```python
+from clarifai.client.nodepool import Nodepool
+
+# Initialize the Nodepool instance
+nodepool = Nodepool(user_id="user_id",nodepool_id="demo-nodepool-id")
+
+# Create a new deployment
+deployment = nodepool.create_deployment(deployment_id="demo-deployment-id",config_filepath="deployment_config.yaml")
+
+#Get a deployment
+deployment = nodepool.deployment(nodepool_id="demo-deployment-id")
+print(deployment)
+
+# List deployments
+all_deployments = list(nodepool.list_deployments())
+print(all_deployments)
+
+```
+##### [Example Deployment config](https://github.com/Clarifai/examples/blob/main/ComputeOrchestration/configs/deployment_config.yaml)
+
+#### Compute Orchestration CLI Operations
+Refer Here: https://github.com/Clarifai/clarifai-python/tree/master/clarifai/cli
+
+
 ## :floppy_disk: Interacting with Datasets
 
 Clarifai datasets help in managing datasets used for model training and evaluation. It provides functionalities like creating datasets,uploading datasets, retrying failed uploads from logs and exporting datasets as .zip files.