clarifai 10.8.5__tar.gz → 10.8.7__tar.gz

{clarifai-10.8.5/clarifai.egg-info → clarifai-10.8.7}/PKG-INFO

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

clarifai-10.8.7/clarifai/__init__.py

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

{clarifai-10.8.5 → clarifai-10.8.7}/clarifai/client/app.py

@@ -19,8 +19,7 @@ from clarifai.client.workflow import Workflow
 from clarifai.constants.model import TRAINABLE_MODEL_TYPES
 from clarifai.errors import UserError
 from clarifai.urls.helper import ClarifaiUrlHelper
-from clarifai.utils.logging import (display_concept_relations_tree, display_workflow_tree,
-                                    get_logger)
+from clarifai.utils.logging import display_concept_relations_tree, display_workflow_tree, logger
 from clarifai.utils.misc import concept_relations_accumulation
 from clarifai.workflows.utils import get_yaml_output_info_proto, is_same_yaml_model
 from clarifai.workflows.validate import validate
@@ -61,7 +60,7 @@ class App(Lister, BaseClient):
 
     self.kwargs = {**kwargs, 'id': app_id}
     self.app_info = resources_pb2.App(**self.kwargs)
-    self.logger = get_logger(logger_level="INFO", name=__name__)
+    self.logger = logger
     BaseClient.__init__(
         self,
         user_id=self.user_id,

{clarifai-10.8.5 → clarifai-10.8.7}/clarifai/client/auth/helper.py

@@ -58,17 +58,15 @@ def https_cache(cache: dict, url: str) -> str:
 
 class ClarifaiAuthHelper:
 
-  def __init__(
-      self,
-      user_id: str,
-      app_id: str,
-      pat: str,
-      token: str = "",
-      base: str = DEFAULT_BASE,
-      ui: str = DEFAULT_UI,
-      root_certificates_path: str = None,
-      validate: bool = True,
-  ):
+  def __init__(self,
+               user_id: str = "",
+               app_id: str = "",
+               pat: str = "",
+               token: str = "",
+               base: str = DEFAULT_BASE,
+               ui: str = DEFAULT_UI,
+               root_certificates_path: str = None,
+               validate: bool = True):
     """
         A helper to get the authorization information needed to make API calls with the grpc
         client to a specific app using a personal access token.

{clarifai-10.8.5 → clarifai-10.8.7}/clarifai/client/base.py

@@ -8,6 +8,7 @@ from google.protobuf.wrappers_pb2 import BoolValue
 
 from clarifai.client.auth import create_stub
 from clarifai.client.auth.helper import ClarifaiAuthHelper
+from clarifai.constants.base import COMPUTE_ORCHESTRATION_RESOURCES
 from clarifai.errors import ApiError, UserError
 from clarifai.utils.constants import CLARIFAI_PAT_ENV_VAR, CLARIFAI_SESSION_TOKEN_ENV_VAR
 from clarifai.utils.misc import get_from_dict_or_env
@@ -88,8 +89,8 @@ class BaseClient:
       if kwargs.get("url"):
         default_kwargs.pop("user_id", "")
         default_kwargs.pop("app_id", "")
-      # Remove app_id if the class name contains "Runner"
-      if 'Runner' in _clss.__name__:
+      # Remove app_id if the class name is a compute orchestration resource
+      if any(co_resource in _clss.__name__ for co_resource in COMPUTE_ORCHESTRATION_RESOURCES):
         default_kwargs.pop("app_id", "")
       kwargs.update({**default_kwargs, "base_url": _base})
 
@@ -181,7 +182,7 @@ class BaseClient:
             value = resources_pb2.ImageInfo(**value)
           elif key == 'hosted_image_info':
             continue
-          elif key in ['metadata']:
+          elif key in ['metadata', 'presets']:
             if isinstance(value, dict) and value != {}:
               value_s = struct_pb2.Struct()
               value_s.update(value)

clarifai-10.8.7/clarifai/client/compute_cluster.py

@@ -0,0 +1,196 @@
+import os
+from typing import Any, Dict, Generator, List
+
+import yaml
+from clarifai_grpc.grpc.api import resources_pb2, service_pb2
+from clarifai_grpc.grpc.api.status import status_code_pb2
+from google.protobuf.json_format import MessageToDict
+
+from clarifai.client.base import BaseClient
+from clarifai.client.lister import Lister
+from clarifai.client.nodepool import Nodepool
+from clarifai.errors import UserError
+from clarifai.utils.logging import logger
+
+
+class ComputeCluster(Lister, BaseClient):
+  """ComputeCluster is a class that provides access to Clarifai API endpoints related to Compute Cluster information."""
+
+  def __init__(self,
+               compute_cluster_id: str = None,
+               user_id: str = None,
+               base_url: str = "https://api.clarifai.com",
+               pat: str = None,
+               token: str = None,
+               root_certificates_path: str = None,
+               **kwargs):
+    """Initializes an ComputeCluster object.
+
+    Args:
+        compute_cluster_id (str): The ComputeCluster ID for the ComputeCluster to interact with.
+        user_id (str): The user ID of the user.
+        base_url (str): Base API url. Default "https://api.clarifai.com"
+        pat (str): A personal access token for authentication. Can be set as env var CLARIFAI_PAT
+        token (str): A session token for authentication. Accepts either a session token or a pat. Can be set as env var CLARIFAI_SESSION_TOKEN
+        root_certificates_path (str): Path to the SSL root certificates file, used to establish secure gRPC connections.
+        **kwargs: Additional keyword arguments to be passed to the compute cluster.
+    """
+    self.kwargs = {**kwargs, 'id': compute_cluster_id, 'user_id': user_id}
+    self.compute_cluster_info = resources_pb2.ComputeCluster(**self.kwargs)
+    self.logger = logger
+    BaseClient.__init__(
+        self,
+        user_id=self.user_id,
+        base=base_url,
+        pat=pat,
+        token=token,
+        root_certificates_path=root_certificates_path)
+    Lister.__init__(self)
+
+  def list_nodepools(self, page_no: int = None,
+                     per_page: int = None) -> Generator[Nodepool, None, None]:
+    """Lists all the available nodepools of the compute cluster.
+
+    Args:
+        compute_cluster_id (str): The compute cluster ID to list the nodepools.
+        page_no (int): The page number to list.
+        per_page (int): The number of items per page.
+
+    Yields:
+        Nodepool: Nodepool objects for the nodepools in the compute cluster.
+
+    Example:
+        >>> from clarifai.client.compute_cluster import ComputeCluster
+        >>> compute_cluster = ComputeCluster(compute_cluster_id="compute_cluster_id", user_id="user_id")
+        >>> all_nodepools = list(compute_cluster.list_nodepools())
+
+    Note:
+        Defaults to 16 per page if page_no is specified and per_page is not specified.
+        If both page_no and per_page are None, then lists all the resources.
+    """
+    request_data = dict(user_app_id=self.user_app_id, compute_cluster_id=self.id)
+    all_nodepools_info = self.list_pages_generator(
+        self.STUB.ListNodepools,
+        service_pb2.ListNodepoolsRequest,
+        request_data,
+        per_page=per_page,
+        page_no=page_no)
+
+    for nodepool_info in all_nodepools_info:
+      yield Nodepool.from_auth_helper(auth=self.auth_helper, **nodepool_info)
+
+  def _process_nodepool_config(self, config_filepath: str) -> Dict[str, Any]:
+    with open(config_filepath, "r") as file:
+      nodepool_config = yaml.safe_load(file)
+
+    assert "nodepool" in nodepool_config, "nodepool info not found in the config file"
+    nodepool = nodepool_config['nodepool']
+    assert "instance_types" in nodepool, "region not found in the config file"
+    assert "node_capacity_type" in nodepool, "managed_by not found in the config file"
+    assert "max_instances" in nodepool, "cluster_type not found in the config file"
+    nodepool['compute_cluster'] = resources_pb2.ComputeCluster(id=self.id, user_id=self.user_id)
+    nodepool['node_capacity_type'] = resources_pb2.NodeCapacityType(capacity_types=[
+        capacity_type for capacity_type in nodepool['node_capacity_type']['capacity_types']
+    ])
+    instance_types = []
+    for instance_type in nodepool['instance_types']:
+      if 'compute_info' in instance_type:
+        instance_type['compute_info'] = resources_pb2.ComputeInfo(**instance_type['compute_info'])
+      instance_types.append(resources_pb2.InstanceType(**instance_type))
+    nodepool['instance_types'] = instance_types
+    if "visibility" in nodepool:
+      nodepool["visibility"] = resources_pb2.Visibility(**nodepool["visibility"])
+    return nodepool
+
+  def create_nodepool(self, nodepool_id: str, config_filepath: str) -> Nodepool:
+    """Creates a nodepool for the compute cluster.
+
+    Args:
+        nodepool_id (str): The nodepool ID for the nodepool to create.
+        config_filepath (str): The path to the nodepool config file.
+
+    Returns:
+        Nodepool: A Nodepool object for the specified nodepool ID.
+
+    Example:
+        >>> from clarifai.client.compute_cluster import ComputeCluster
+        >>> compute_cluster = ComputeCluster(compute_cluster_id="compute_cluster_id", user_id="user_id")
+        >>> nodepool = compute_cluster.create_nodepool(nodepool_id="nodepool_id", config_filepath="config.yml")
+    """
+    if not os.path.exists(config_filepath):
+      raise UserError(f"Nodepool config file not found at {config_filepath}")
+
+    nodepool_config = self._process_nodepool_config(config_filepath)
+
+    if 'id' in nodepool_config:
+      nodepool_id = nodepool_config['id']
+      nodepool_config.pop('id')
+
+    request = service_pb2.PostNodepoolsRequest(
+        user_app_id=self.user_app_id,
+        compute_cluster_id=self.id,
+        nodepools=[resources_pb2.Nodepool(id=nodepool_id, **nodepool_config)])
+    response = self._grpc_request(self.STUB.PostNodepools, request)
+    if response.status.code != status_code_pb2.SUCCESS:
+      raise Exception(response.status)
+    self.logger.info("\nNodepool created\n%s", response.status)
+
+    return Nodepool.from_auth_helper(self.auth_helper, nodepool_id=nodepool_id)
+
+  def nodepool(self, nodepool_id: str) -> Nodepool:
+    """Returns a Nodepool object for the existing nodepool ID.
+
+    Args:
+        nodepool_id (str): The nodepool ID for the nodepool to interact with.
+
+    Returns:
+        Nodepool: A Nodepool object for the existing nodepool ID.
+
+    Example:
+        >>> from clarifai.client.compute_cluster import ComputeCluster
+        >>> compute_cluster = ComputeCluster(compute_cluster_id="compute_cluster_id", user_id="user_id")
+        >>> nodepool = compute_cluster.nodepool(nodepool_id="nodepool_id")
+    """
+    request = service_pb2.GetNodepoolRequest(
+        user_app_id=self.user_app_id, compute_cluster_id=self.id, nodepool_id=nodepool_id)
+    response = self._grpc_request(self.STUB.GetNodepool, request)
+
+    if response.status.code != status_code_pb2.SUCCESS:
+      raise Exception(response.status)
+    dict_response = MessageToDict(response, preserving_proto_field_name=True)
+    kwargs = self.process_response_keys(dict_response[list(dict_response.keys())[1]],
+                                        list(dict_response.keys())[1])
+
+    return Nodepool.from_auth_helper(auth=self.auth_helper, **kwargs)
+
+  def delete_nodepools(self, nodepool_ids: List[str]) -> None:
+    """Deletes list of nodepools for the compute cluster.
+
+    Args:
+        nodepool_ids (List[str]): The nodepool IDs of the compute cluster to delete.
+
+    Example:
+        >>> from clarifai.client.compute_cluster import ComputeCluster
+        >>> compute_cluster = ComputeCluster(compute_cluster_id="compute_cluster_id", user_id="user_id")
+        >>> compute_cluster.delete_nodepools(nodepool_ids=["nodepool_id1", "nodepool_id2"])
+    """
+    assert isinstance(nodepool_ids, list), "nodepool_ids param should be a list"
+
+    request = service_pb2.DeleteNodepoolsRequest(
+        user_app_id=self.user_app_id, compute_cluster_id=self.id, ids=nodepool_ids)
+    response = self._grpc_request(self.STUB.DeleteNodepools, request)
+
+    if response.status.code != status_code_pb2.SUCCESS:
+      raise Exception(response.status)
+    self.logger.info("\nNodepools Deleted\n%s", response.status)
+
+  def __getattr__(self, name):
+    return getattr(self.compute_cluster_info, name)
+
+  def __str__(self):
+    init_params = [param for param in self.kwargs.keys()]
+    attribute_strings = [
+        f"{param}={getattr(self.compute_cluster_info, param)}" for param in init_params
+        if hasattr(self.compute_cluster_info, param)
+    ]
+    return f"Clarifai Compute Cluster Details: \n{', '.join(attribute_strings)}\n"

{clarifai-10.8.5 → clarifai-10.8.7}/clarifai/client/dataset.py

@@ -30,7 +30,7 @@ from clarifai.datasets.upload.text import TextClassificationDataset
 from clarifai.datasets.upload.utils import DisplayUploadStatus
 from clarifai.errors import UserError
 from clarifai.urls.helper import ClarifaiUrlHelper
-from clarifai.utils.logging import add_file_handler, get_logger, process_log_files
+from clarifai.utils.logging import add_file_handler, logger, process_log_files
 from clarifai.utils.misc import BackoffIterator, Chunker
 
 ClarifaiDatasetType = TypeVar('ClarifaiDatasetType', VisualClassificationDataset,
@@ -86,7 +86,7 @@ class Dataset(Lister, BaseClient):
         token=token,
         base_url=base_url,
         root_certificates_path=root_certificates_path)
-    self.logger = get_logger(logger_level="INFO", name=__name__)
+    self.logger = logger
     BaseClient.__init__(
         self,
         user_id=self.user_id,

clarifai-10.8.7/clarifai/client/deployment.py

@@ -0,0 +1,51 @@
+from clarifai_grpc.grpc.api import resources_pb2
+
+from clarifai.client.base import BaseClient
+from clarifai.client.lister import Lister
+from clarifai.utils.logging import logger
+
+
+class Deployment(Lister, BaseClient):
+  """Deployment is a class that provides access to Clarifai API endpoints related to Deployment information."""
+
+  def __init__(self,
+               deployment_id: str = None,
+               user_id: str = None,
+               base_url: str = "https://api.clarifai.com",
+               pat: str = None,
+               token: str = None,
+               root_certificates_path: str = None,
+               **kwargs):
+    """Initializes a Deployment object.
+
+    Args:
+        deployment_id (str): The Deployment ID for the Deployment to interact with.
+        user_id (str): The user ID of the user.
+        base_url (str): Base API url. Default "https://api.clarifai.com"
+        pat (str): A personal access token for authentication. Can be set as env var CLARIFAI_PAT
+        token (str): A session token for authentication. Accepts either a session token or a pat. Can be set as env var CLARIFAI_SESSION_TOKEN
+        root_certificates_path (str): Path to the SSL root certificates file, used to establish secure gRPC connections.
+        **kwargs: Additional keyword arguments to be passed to the deployment.
+    """
+    self.kwargs = {**kwargs, 'id': deployment_id, 'user_id': user_id}
+    self.deployment_info = resources_pb2.Deployment(**self.kwargs)
+    self.logger = logger
+    BaseClient.__init__(
+        self,
+        user_id=user_id,
+        base=base_url,
+        pat=pat,
+        token=token,
+        root_certificates_path=root_certificates_path)
+    Lister.__init__(self)
+
+  def __getattr__(self, name):
+    return getattr(self.deployment_info, name)
+
+  def __str__(self):
+    init_params = [param for param in self.kwargs.keys()]
+    attribute_strings = [
+        f"{param}={getattr(self.deployment_info, param)}" for param in init_params
+        if hasattr(self.deployment_info, param)
+    ]
+    return f"Deployment Details: \n{', '.join(attribute_strings)}\n"

{clarifai-10.8.5 → clarifai-10.8.7}/clarifai/client/input.py

@@ -21,7 +21,7 @@ from clarifai.client.lister import Lister
 from clarifai.constants.dataset import MAX_RETRIES
 from clarifai.constants.input import MAX_UPLOAD_BATCH_SIZE
 from clarifai.errors import UserError
-from clarifai.utils.logging import get_logger
+from clarifai.utils.logging import logger
 from clarifai.utils.misc import BackoffIterator, Chunker
 
 
@@ -52,7 +52,7 @@ class Inputs(Lister, BaseClient):
     self.app_id = app_id
     self.kwargs = {**kwargs}
     self.input_info = resources_pb2.Input(**self.kwargs)
-    self.logger = get_logger(logger_level=logger_level, name=__name__)
+    self.logger = logger
     BaseClient.__init__(
         self,
         user_id=self.user_id,

{clarifai-10.8.5 → clarifai-10.8.7}/clarifai/client/model.py

@@ -23,7 +23,7 @@ from clarifai.constants.model import (CHUNK_SIZE, MAX_CHUNK_SIZE, MAX_MODEL_PRED
                                       MODEL_EXPORT_TIMEOUT, RANGE_SIZE, TRAINABLE_MODEL_TYPES)
 from clarifai.errors import UserError
 from clarifai.urls.helper import ClarifaiUrlHelper
-from clarifai.utils.logging import get_logger
+from clarifai.utils.logging import logger
 from clarifai.utils.misc import BackoffIterator
 from clarifai.utils.model_train import (find_and_replace_key, params_parser,
                                         response_to_model_params, response_to_param_info,
@@ -68,7 +68,7 @@ class Model(Lister, BaseClient):
       kwargs = {'user_id': user_id, 'app_id': app_id}
     self.kwargs = {**kwargs, 'id': model_id, 'model_version': model_version, }
     self.model_info = resources_pb2.Model(**self.kwargs)
-    self.logger = get_logger(logger_level="INFO", name=__name__)
+    self.logger = logger
     self.training_params = {}
     BaseClient.__init__(
         self,

{clarifai-10.8.5 → clarifai-10.8.7}/clarifai/client/module.py

@@ -6,7 +6,7 @@ from clarifai.client.base import BaseClient
 from clarifai.client.lister import Lister
 from clarifai.errors import UserError
 from clarifai.urls.helper import ClarifaiUrlHelper
-from clarifai.utils.logging import get_logger
+from clarifai.utils.logging import logger
 
 
 class Module(Lister, BaseClient):
@@ -44,7 +44,7 @@ class Module(Lister, BaseClient):
 
     self.kwargs = {**kwargs, 'id': module_id, 'module_version': module_version}
     self.module_info = resources_pb2.Module(**self.kwargs)
-    self.logger = get_logger(logger_level="INFO", name=__name__)
+    self.logger = logger
     BaseClient.__init__(
         self,
         user_id=self.user_id,

clarifai-10.8.7/clarifai/client/nodepool.py

@@ -0,0 +1,207 @@
+import os
+from typing import Any, Dict, Generator, List
+
+import yaml
+from clarifai_grpc.grpc.api import resources_pb2, service_pb2
+from clarifai_grpc.grpc.api.status import status_code_pb2
+from google.protobuf.json_format import MessageToDict
+
+from clarifai.client.base import BaseClient
+from clarifai.client.deployment import Deployment
+from clarifai.client.lister import Lister
+from clarifai.errors import UserError
+from clarifai.utils.logging import logger
+
+
+class Nodepool(Lister, BaseClient):
+  """Nodepool is a class that provides access to Clarifai API endpoints related to Nodepool information."""
+
+  def __init__(self,
+               nodepool_id: str = None,
+               user_id: str = None,
+               base_url: str = "https://api.clarifai.com",
+               pat: str = None,
+               token: str = None,
+               root_certificates_path: str = None,
+               **kwargs):
+    """Initializes a Nodepool object.
+
+    Args:
+        nodepool_id (str): The Nodepool ID for the Nodepool to interact with.
+        user_id (str): The user ID of the user.
+        base_url (str): Base API url. Default "https://api.clarifai.com"
+        pat (str): A personal access token for authentication. Can be set as env var CLARIFAI_PAT
+        token (str): A session token for authentication. Accepts either a session token or a pat. Can be set as env var CLARIFAI_SESSION_TOKEN
+        root_certificates_path (str): Path to the SSL root certificates file, used to establish secure gRPC connections.
+        **kwargs: Additional keyword arguments to be passed to the nodepool.
+    """
+    self.kwargs = {**kwargs, 'id': nodepool_id}
+    self.nodepool_info = resources_pb2.Nodepool(**self.kwargs)
+    self.logger = logger
+    BaseClient.__init__(
+        self,
+        user_id=user_id,
+        base=base_url,
+        pat=pat,
+        token=token,
+        root_certificates_path=root_certificates_path)
+    Lister.__init__(self)
+
+  def list_deployments(self,
+                       filter_by: Dict[str, Any] = {},
+                       page_no: int = None,
+                       per_page: int = None) -> Generator[Deployment, None, None]:
+    """Lists all the available deployments of compute cluster.
+
+    Args:
+        filter_by (Dict[str, Any]): The filter to apply to the list of deployments.
+        page_no (int): The page number to list.
+        per_page (int): The number of items per page.
+
+    Yields:
+        Deployment: Deployment objects for the nodepools in the compute cluster.
+
+    Example:
+        >>> from clarifai.client.nodepool import Nodepool
+        >>> nodepool = Nodepool(nodepool_id="nodepool_id", user_id="user_id")
+        >>> all_deployments = list(nodepool.list_deployments())
+
+    Note:
+        Defaults to 16 per page if page_no is specified and per_page is not specified.
+        If both page_no and per_page are None, then lists all the resources.
+    """
+    request_data = dict(user_app_id=self.user_app_id, nodepool_id=self.id, **filter_by)
+    all_deployments_info = self.list_pages_generator(
+        self.STUB.ListDeployments,
+        service_pb2.ListDeploymentsRequest,
+        request_data,
+        per_page=per_page,
+        page_no=page_no)
+
+    for deployment_info in all_deployments_info:
+      yield Deployment.from_auth_helper(auth=self.auth_helper, **deployment_info)
+
+  def _process_deployment_config(self, config_filepath: str) -> Dict[str, Any]:
+    with open(config_filepath, "r") as file:
+      deployment_config = yaml.safe_load(file)
+
+    assert "deployment" in deployment_config, "deployment info not found in the config file"
+    deployment = deployment_config['deployment']
+    assert "autoscale_config" in deployment, "autoscale_config not found in the config file"
+    assert ("worker" in deployment) and (
+        ("model" in deployment["worker"]) or
+        ("workflow" in deployment["worker"])), "worker info not found in the config file"
+    assert "scheduling_choice" in deployment, "scheduling_choice not found in the config file"
+    assert "nodepools" in deployment, "nodepools not found in the config file"
+    deployment['user_id'] = self.user_app_id.user_id
+    deployment['autoscale_config'] = resources_pb2.AutoscaleConfig(
+        **deployment['autoscale_config'])
+    deployment['nodepools'] = [
+        resources_pb2.Nodepool(
+            id=nodepool['id'],
+            compute_cluster=resources_pb2.ComputeCluster(
+                id=nodepool['compute_cluster']['id'], user_id=self.user_app_id.user_id))
+        for nodepool in deployment['nodepools']
+    ]
+    if 'user' in deployment['worker']:
+      deployment['worker']['user'] = resources_pb2.User(**deployment['worker']['user'])
+    elif 'model' in deployment['worker']:
+      deployment['worker']['model'] = resources_pb2.Model(**deployment['worker']['model'])
+    elif 'workflow' in deployment['worker']:
+      deployment['worker']['workflow'] = resources_pb2.Workflow(**deployment['worker']['workflow'])
+    deployment['worker'] = resources_pb2.Worker(**deployment['worker'])
+    if "visibility" in deployment:
+      deployment["visibility"] = resources_pb2.Visibility(**deployment["visibility"])
+    return deployment
+
+  def create_deployment(self, deployment_id: str, config_filepath: str) -> Deployment:
+    """Creates a deployment for the nodepool.
+
+    Args:
+        deployment_id (str): The deployment ID for the deployment to create.
+        config_filepath (str): The path to the deployment config file.
+
+    Returns:
+        Deployment: A Deployment object for the specified deployment ID.
+
+    Example:
+        >>> from clarifai.client.nodepool import Nodepool
+        >>> nodepool = Nodepool(nodepool_id="nodepool_id", user_id="user_id")
+        >>> deployment = nodepool.create_deployment(deployment_id="deployment_id", config_filepath="config.yml")
+    """
+    if not os.path.exists(config_filepath):
+      raise UserError(f"Deployment config file not found at {config_filepath}")
+
+    deployment_config = self._process_deployment_config(config_filepath)
+
+    if 'id' in deployment_config:
+      deployment_id = deployment_config['id']
+      deployment_config.pop('id')
+
+    request = service_pb2.PostDeploymentsRequest(
+        user_app_id=self.user_app_id,
+        deployments=[resources_pb2.Deployment(id=deployment_id, **deployment_config)])
+    response = self._grpc_request(self.STUB.PostDeployments, request)
+    if response.status.code != status_code_pb2.SUCCESS:
+      raise Exception(response.status)
+    self.logger.info("\nDeployment created\n%s", response.status)
+
+    return Deployment.from_auth_helper(self.auth_helper, deployment_id=deployment_id)
+
+  def deployment(self, deployment_id: str) -> Deployment:
+    """Returns a Deployment object for the existing deployment ID.
+
+    Args:
+        deployment_id (str): The deployment ID for the deployment to interact with.
+
+    Returns:
+        Deployment: A Deployment object for the existing deployment ID.
+
+    Example:
+        >>> from clarifai.client.nodepool import Nodepool
+        >>> nodepool = Nodepool(nodepool_id="nodepool_id", user_id="user_id")
+        >>> deployment = nodepool.deployment(deployment_id="deployment_id")
+    """
+    request = service_pb2.GetDeploymentRequest(
+        user_app_id=self.user_app_id, deployment_id=deployment_id)
+    response = self._grpc_request(self.STUB.GetDeployment, request)
+
+    if response.status.code != status_code_pb2.SUCCESS:
+      raise Exception(response.status)
+    dict_response = MessageToDict(response, preserving_proto_field_name=True)
+    kwargs = self.process_response_keys(dict_response[list(dict_response.keys())[1]],
+                                        list(dict_response.keys())[1])
+
+    return Deployment.from_auth_helper(auth=self.auth_helper, **kwargs)
+
+  def delete_deployments(self, deployment_ids: List[str]) -> None:
+    """Deletes list of deployments for the nodepool.
+
+    Args:
+        deployment_ids (List[str]): The list of deployment IDs to delete.
+
+    Example:
+        >>> from clarifai.client.nodepool import Nodepool
+        >>> nodepool = Nodepool(nodepool_id="nodepool_id", user_id="user_id")
+        >>> nodepool.delete_deployments(deployment_ids=["deployment_id1", "deployment_id2"])
+    """
+    assert isinstance(deployment_ids, list), "deployment_ids param should be a list"
+
+    request = service_pb2.DeleteDeploymentsRequest(
+        user_app_id=self.user_app_id, ids=deployment_ids)
+    response = self._grpc_request(self.STUB.DeleteDeployments, request)
+
+    if response.status.code != status_code_pb2.SUCCESS:
+      raise Exception(response.status)
+    self.logger.info("\nDeployments Deleted\n%s", response.status)
+
+  def __getattr__(self, name):
+    return getattr(self.nodepool_info, name)
+
+  def __str__(self):
+    init_params = [param for param in self.kwargs.keys()]
+    attribute_strings = [
+        f"{param}={getattr(self.nodepool_info, param)}" for param in init_params
+        if hasattr(self.nodepool_info, param)
+    ]
+    return f"Nodepool Details: \n{', '.join(attribute_strings)}\n"