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

clarifai/__init__.py

@@ -1 +1 @@
-__version__ = "10.8.6"
+__version__ = "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/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/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/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/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/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/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/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/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/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"

clarifai/client/user.py

@@ -1,5 +1,7 @@
+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
@@ -7,9 +9,10 @@ from google.protobuf.wrappers_pb2 import BoolValue
 
 from clarifai.client.app import App
 from clarifai.client.base import BaseClient
+from clarifai.client.compute_cluster import ComputeCluster
 from clarifai.client.lister import Lister
 from clarifai.errors import UserError
-from clarifai.utils.logging import get_logger
+from clarifai.utils.logging import logger
 
 
 class User(Lister, BaseClient):
@@ -34,7 +37,7 @@ class User(Lister, BaseClient):
     """
     self.kwargs = {**kwargs, 'id': user_id}
     self.user_info = resources_pb2.User(**self.kwargs)
-    self.logger = get_logger(logger_level="INFO", name=__name__)
+    self.logger = logger
     BaseClient.__init__(
         self,
         user_id=self.id,
@@ -109,6 +112,37 @@ class User(Lister, BaseClient):
     for runner_info in all_runners_info:
       yield dict(auth=self.auth_helper, check_runner_exists=False, **runner_info)
 
+  def list_compute_clusters(self, page_no: int = None,
+                            per_page: int = None) -> Generator[dict, None, None]:
+    """List all compute clusters for the user
+
+    Args:
+        page_no (int): The page number to list.
+        per_page (int): The number of items per page.
+
+    Yields:
+        Dict: Dictionaries containing information about the compute clusters.
+
+    Example:
+        >>> from clarifai.client.user import User
+        >>> client = User(user_id="user_id")
+        >>> all_compute_clusters= list(client.list_compute_clusters())
+
+    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)
+    all_compute_clusters_info = self.list_pages_generator(
+        self.STUB.ListComputeClusters,
+        service_pb2.ListComputeClustersRequest,
+        request_data,
+        per_page=per_page,
+        page_no=page_no)
+
+    for compute_cluster_info in all_compute_clusters_info:
+      yield ComputeCluster.from_auth_helper(self.auth_helper, **compute_cluster_info)
+
   def create_app(self, app_id: str, base_workflow: str = 'Empty', **kwargs) -> App:
     """Creates an app for the user.
 
@@ -172,6 +206,59 @@ class User(Lister, BaseClient):
         description=description,
         check_runner_exists=False)
 
+  def _process_compute_cluster_config(self, config_filepath: str) -> Dict[str, Any]:
+    with open(config_filepath, "r") as file:
+      compute_cluster_config = yaml.safe_load(file)
+
+    assert "compute_cluster" in compute_cluster_config, "compute cluster info not found in the config file"
+    compute_cluster = compute_cluster_config['compute_cluster']
+    assert "region" in compute_cluster, "region not found in the config file"
+    assert "managed_by" in compute_cluster, "managed_by not found in the config file"
+    assert "cluster_type" in compute_cluster, "cluster_type not found in the config file"
+    compute_cluster['cloud_provider'] = resources_pb2.CloudProvider(
+        **compute_cluster['cloud_provider'])
+    compute_cluster['key'] = resources_pb2.Key(id=self.pat)
+    if "visibility" in compute_cluster:
+      compute_cluster["visibility"] = resources_pb2.Visibility(**compute_cluster["visibility"])
+    return compute_cluster
+
+  def create_compute_cluster(self, compute_cluster_id: str,
+                             config_filepath: str) -> ComputeCluster:
+    """Creates a compute cluster for the user.
+
+    Args:
+        compute_cluster_id (str): The compute cluster ID for the compute cluster to create.
+        config_filepath (str): The path to the compute cluster config file.
+
+    Returns:
+        ComputeCluster: A Compute Cluster object for the specified compute cluster ID.
+
+    Example:
+        >>> from clarifai.client.user import User
+        >>> client = User(user_id="user_id")
+        >>> compute_cluster = client.create_compute_cluster(compute_cluster_id="compute_cluster_id", config_filepath="config.yml")
+    """
+    if not os.path.exists(config_filepath):
+      raise UserError(f"Compute Cluster config file not found at {config_filepath}")
+
+    compute_cluster_config = self._process_compute_cluster_config(config_filepath)
+
+    if 'id' in compute_cluster_config:
+      compute_cluster_id = compute_cluster_config['id']
+      compute_cluster_config.pop('id')
+
+    request = service_pb2.PostComputeClustersRequest(
+        user_app_id=self.user_app_id,
+        compute_clusters=[
+            resources_pb2.ComputeCluster(id=compute_cluster_id, **compute_cluster_config)
+        ])
+    response = self._grpc_request(self.STUB.PostComputeClusters, request)
+    if response.status.code != status_code_pb2.SUCCESS:
+      raise Exception(response.status)
+    self.logger.info("\nCompute Cluster created\n%s", response.status)
+    return ComputeCluster.from_auth_helper(
+        auth=self.auth_helper, compute_cluster_id=compute_cluster_id)
+
   def app(self, app_id: str, **kwargs) -> App:
     """Returns an App object for the specified app ID.
 
@@ -223,6 +310,31 @@ class User(Lister, BaseClient):
 
     return dict(self.auth_helper, check_runner_exists=False, **kwargs)
 
+  def compute_cluster(self, compute_cluster_id: str) -> ComputeCluster:
+    """Returns an Compute Cluster object for the specified compute cluster ID.
+
+    Args:
+        compute_cluster_id (str): The compute cluster ID for the compute cluster to interact with.
+
+    Returns:
+        ComputeCluster: A Compute Cluster object for the specified compute cluster ID.
+
+    Example:
+        >>> from clarifai.client.user import User
+        >>> compute_cluster = User("user_id").compute_cluster("compute_cluster_id")
+    """
+    request = service_pb2.GetComputeClusterRequest(
+        user_app_id=self.user_app_id, compute_cluster_id=compute_cluster_id)
+    response = self._grpc_request(self.STUB.GetComputeCluster, 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 ComputeCluster.from_auth_helper(auth=self.auth_helper, **kwargs)
+
   def patch_app(self, app_id: str, action: str = 'overwrite', **kwargs) -> App:
     """Patch an app for the user.
 
@@ -290,6 +402,25 @@ class User(Lister, BaseClient):
       raise Exception(response.status)
     self.logger.info("\nRunner Deleted\n%s", response.status)
 
+  def delete_compute_clusters(self, compute_cluster_ids: List[str]) -> None:
+    """Deletes a list of compute clusters for the user.
+
+    Args:
+        compute_cluster_ids (List[str]): The compute cluster IDs of the user to delete.
+
+    Example:
+        >>> from clarifai.client.user import User
+        >>> user = User("user_id").delete_compute_clusters(compute_cluster_ids=["compute_cluster_id1", "compute_cluster_id2"])
+    """
+    assert isinstance(compute_cluster_ids, list), "compute_cluster_ids param should be a list"
+
+    request = service_pb2.DeleteComputeClustersRequest(
+        user_app_id=self.user_app_id, ids=compute_cluster_ids)
+    response = self._grpc_request(self.STUB.DeleteComputeClusters, request)
+    if response.status.code != status_code_pb2.SUCCESS:
+      raise Exception(response.status)
+    self.logger.info("\nCompute Cluster Deleted\n%s", response.status)
+
   def __getattr__(self, name):
     return getattr(self.user_info, name)
 

clarifai/client/workflow.py

@@ -12,7 +12,7 @@ from clarifai.client.lister import Lister
 from clarifai.constants.workflow import MAX_WORKFLOW_PREDICT_INPUTS
 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.workflows.export import Exporter
 
@@ -59,7 +59,7 @@ class Workflow(Lister, BaseClient):
     self.kwargs = {**kwargs, 'id': workflow_id, 'version': workflow_version}
     self.output_config = output_config
     self.workflow_info = resources_pb2.Workflow(**self.kwargs)
-    self.logger = get_logger(logger_level="INFO", name=__name__)
+    self.logger = logger
     BaseClient.__init__(
         self,
         user_id=self.user_id,

clarifai/constants/base.py

@@ -0,0 +1 @@
+COMPUTE_ORCHESTRATION_RESOURCES = ['Runner', 'ComputeCluster', 'Nodepool', 'Deployment']

clarifai/datasets/export/inputs_annotations.py

@@ -14,9 +14,7 @@ from tqdm import tqdm
 
 from clarifai.constants.dataset import CONTENT_TYPE
 from clarifai.errors import UserError
-from clarifai.utils.logging import get_logger
-
-logger = get_logger("INFO", __name__)
+from clarifai.utils.logging import logger
 
 
 class DatasetExportReader:

clarifai/rag/rag.py

@@ -15,7 +15,7 @@ from clarifai.errors import UserError
 from clarifai.rag.utils import (convert_messages_to_str, format_assistant_message, load_documents,
                                 split_document)
 from clarifai.utils.constants import CLARIFAI_USER_ID_ENV_VAR
-from clarifai.utils.logging import get_logger
+from clarifai.utils.logging import logger
 from clarifai.utils.misc import get_from_dict_or_env
 
 DEFAULT_RAG_PROMPT_TEMPLATE = "Context information is below:\n{data.hits}\nGiven the context information and not prior knowledge, answer the query.\nQuery: {data.text.raw}\nAnswer: "
@@ -40,7 +40,7 @@ class RAG:
                **kwargs):
     """Initialize an empty or existing RAG.
     """
-    self.logger = get_logger(logger_level="INFO", name=__name__)
+    self.logger = logger
     if workflow_url is not None and workflow is None:
       self.logger.info("workflow_url:%s", workflow_url)
       w = Workflow(workflow_url, base_url=base_url, pat=pat)

clarifai/runners/models/model_upload.py

@@ -10,8 +10,8 @@ from google.protobuf import json_format
 from rich import print
 
 from clarifai.client import BaseClient
-
 from clarifai.runners.utils.loader import HuggingFaceLoarder
+from clarifai.utils.logging import logger
 
 
 def _clear_line(n: int = 1) -> None:
@@ -40,7 +40,7 @@ class ModelUploader:
   def _validate_folder(folder):
     if not folder.startswith("/"):
       folder = os.path.join(os.getcwd(), folder)
-    print(f"Validating folder: {folder}")
+    logger.info(f"Validating folder: {folder}")
     if not os.path.exists(folder):
       raise FileNotFoundError(f"Folder {folder} not found, please provide a valid folder path")
     files = os.listdir(folder)
@@ -70,7 +70,7 @@ class ModelUploader:
       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)
-      print(f"Client initialized for user {user_id} and app {app_id}")
+      logger.info(f"Client initialized for user {user_id} and app {app_id}")
     return self._client
 
   def _get_model_proto(self):
@@ -100,7 +100,7 @@ class ModelUploader:
         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:
-      print(
+      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
@@ -133,9 +133,10 @@ class ModelUploader:
     build_info = self.config.get('build_info', {})
     if 'python_version' in build_info:
       python_version = build_info['python_version']
-      print(f"Using Python version {python_version} from the config file to build the Dockerfile")
+      logger.info(
+          f"Using Python version {python_version} from the config file to build the Dockerfile")
     else:
-      print(
+      logger.info(
           f"Python version not found in the config file, using default Python version: {self.DEFAULT_PYTHON_VERSION}"
       )
       python_version = self.DEFAULT_PYTHON_VERSION
@@ -152,13 +153,13 @@ class ModelUploader:
 
   def download_checkpoints(self):
     if not self.config.get("checkpoints"):
-      print("No checkpoints specified in the config file")
+      logger.info("No checkpoints specified in the config file")
       return
 
     assert "type" in self.config.get("checkpoints"), "No loader type specified in the config file"
     loader_type = self.config.get("checkpoints").get("type")
     if not loader_type:
-      print("No loader type specified in the config file for checkpoints")
+      logger.info("No loader type specified in the config file for checkpoints")
     assert loader_type == "huggingface", "Only huggingface loader supported for now"
     if loader_type == "huggingface":
       assert "repo_id" in self.config.get("checkpoints"), "No repo_id specified in the config file"
@@ -173,9 +174,12 @@ class ModelUploader:
       loader = HuggingFaceLoarder(repo_id=repo_id, token=hf_token)
 
       checkpoint_path = os.path.join(self.folder, '1', 'checkpoints')
-      loader.download_checkpoints(checkpoint_path)
+      success = loader.download_checkpoints(checkpoint_path)
 
-      print(f"Downloaded checkpoints for model {repo_id}")
+      if not success:
+        logger.error(f"Failed to download checkpoints for model {repo_id}")
+        return
+      logger.info(f"Downloaded checkpoints for model {repo_id}")
 
   def _concepts_protos_from_concepts(self, concepts):
     concept_protos = []
@@ -199,7 +203,7 @@ class ModelUploader:
     with open(config_file, 'w') as file:
       yaml.dump(config, file, sort_keys=False)
     concepts = config.get('concepts')
-    print(f"Updated config.yaml with {len(concepts)} concepts.")
+    logger.info(f"Updated config.yaml with {len(concepts)} concepts.")
 
   def _get_model_version_proto(self):
 
@@ -225,11 +229,11 @@ class ModelUploader:
 
   def upload_model_version(self):
     file_path = f"{self.folder}.tar.gz"
-    print(f"Will tar it into file: {file_path}")
+    logger.info(f"Will tar it into file: {file_path}")
 
     # Tar the folder
     os.system(f"tar --exclude=*~ -czvf {self.folder}.tar.gz -C {self.folder} .")
-    print("Tarring complete, about to start upload.")
+    logger.info("Tarring complete, about to start upload.")
 
     model_version = self._get_model_version_proto()
 
@@ -251,10 +255,10 @@ class ModelUploader:
           flush=True)
     print()
     if response.status.code != status_code_pb2.MODEL_BUILDING:
-      print(f"Failed to upload model version: {response.status.description}")
+      logger.error(f"Failed to upload model version: {response.status.description}")
       return
     model_version_id = response.model_version_id
-    print(f"Created Model Version ID: {model_version_id}")
+    logger.info(f"Created Model Version ID: {model_version_id}")
 
     self.monitor_model_build(model_version_id)
 
@@ -264,10 +268,10 @@ class ModelUploader:
       file_size = os.path.getsize(file_path)
       chunk_size = int(127 * 1024 * 1024)  # 127MB chunk size
       num_chunks = (file_size // chunk_size) + 1
-      print("Uploading file...")
-      print("File size: ", file_size)
-      print("Chunk size: ", chunk_size)
-      print("Number of chunks: ", num_chunks)
+      logger.info("Uploading file...")
+      logger.info("File size: ", file_size)
+      logger.info("Chunk size: ", chunk_size)
+      logger.info("Number of chunks: ", num_chunks)
       read_so_far = 0
       for part_id in range(num_chunks):
         try:
@@ -283,16 +287,16 @@ class ModelUploader:
                   range_start=read_so_far,
               ))
         except Exception as e:
-          print(f"\nError uploading file: {e}")
+          logger.exception(f"\nError uploading file: {e}")
           break
 
     if read_so_far == file_size:
-      print("\nUpload complete!, waiting for model build...")
+      logger.info("\nUpload complete!, waiting for model build...")
 
   def init_upload_model_version(self, model_version, file_path):
     file_size = os.path.getsize(file_path)
-    print(f"Uploading model version '{model_version.id}' of model {self.model_proto.id}")
-    print(f"Using file '{os.path.basename(file_path)}' of size: {file_size} bytes")
+    logger.info(f"Uploading model version '{model_version.id}' 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,
@@ -313,16 +317,18 @@ 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)
+        logger.info(
+            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:
-        print("\nModel build complete!")
-        print(
+        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
       else:
-        print(f"\nModel build failed with status: {resp.model_version.status}")
+        logger.info(
+            f"\nModel build failed with status: {resp.model_version.status} and response {resp}")
         break
 
 

clarifai/runners/server.py

@@ -15,7 +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.utils.logging import logger
+from clarifai.utils.logging import logger
 
 
 def main():

clarifai/runners/utils/loader.py

@@ -3,6 +3,8 @@ import json
 import os
 import subprocess
 
+from clarifai.utils.logging import logger
+
 
 class HuggingFaceLoarder:
 
@@ -29,22 +31,24 @@ class HuggingFaceLoarder:
           "The 'huggingface_hub' package is not installed. Please install it using 'pip install huggingface_hub'."
       )
     if os.path.exists(checkpoint_path) and self.validate_download(checkpoint_path):
-      print("Checkpoints already exist")
+      logger.info("Checkpoints already exist")
+      return True
     else:
       os.makedirs(checkpoint_path, exist_ok=True)
       try:
         is_hf_model_exists = self.validate_hf_model()
         if not is_hf_model_exists:
-          print("Model not found on Hugging Face")
+          logger.error("Model %s not found on Hugging Face" % (self.repo_id))
           return False
-        snapshot_download(repo_id=self.repo_id, local_dir=checkpoint_path)
+        snapshot_download(
+            repo_id=self.repo_id, local_dir=checkpoint_path, local_dir_use_symlinks=False)
       except Exception as e:
-        print("Error downloading model checkpoints ", e)
+        logger.exception(f"Error downloading model checkpoints {e}")
         return False
       finally:
         is_downloaded = self.validate_download(checkpoint_path)
         if not is_downloaded:
-          print("Error downloading model checkpoints")
+          logger.error("Error validating downloaded model checkpoints")
           return False
       return True
 
@@ -57,7 +61,10 @@ class HuggingFaceLoarder:
   def validate_download(self, checkpoint_path: str):
     # check if model exists on HF
     from huggingface_hub import list_repo_files
-    return (len(os.listdir(checkpoint_path)) >= len(list_repo_files(self.repo_id))) and len(
+    checkpoint_dir_files = [
+        f for dp, dn, fn in os.walk(os.path.expanduser(checkpoint_path)) for f in fn
+    ]
+    return (len(checkpoint_dir_files) >= len(list_repo_files(self.repo_id))) and len(
         list_repo_files(self.repo_id)) > 0
 
   def fetch_labels(self, checkpoint_path: str):

clarifai/runners/utils/url_fetcher.py

@@ -2,7 +2,7 @@ import concurrent.futures
 
 import fsspec
 
-from .logging import logger
+from clarifai.utils.logging import logger
 
 
 def download_input(input):

clarifai/utils/evaluation/helpers.py

@@ -20,8 +20,7 @@ except ImportError:
 try:
   from loguru import logger
 except ImportError:
-  from ..logging import get_logger
-  logger = get_logger(logger_level="INFO", name=__name__)
+  from ..logging import logger
 
 MACRO_AVG = "macro_avg"
 

clarifai/utils/evaluation/main.py

@@ -26,8 +26,7 @@ except ImportError:
 try:
   from loguru import logger
 except ImportError:
-  from ..logging import get_logger
-  logger = get_logger(logger_level="INFO", name=__name__)
+  from ..logging import logger
 
 __all__ = ['EvalResultCompare']
 

clarifai/utils/logging.py

@@ -19,6 +19,8 @@ from rich.tree import Tree
 
 install()
 
+# The default logger to use throughout the SDK is defined at bottom of this file.
+
 # For the json logger.
 JSON_LOGGER_NAME = "clarifai-json"
 JSON_LOG_KEY = 'msg'
@@ -357,3 +359,7 @@ class JsonFormatter(logging.Formatter):
           default=self.json_default,
           cls=self.json_cls,
       )
+
+
+# the default logger for the SDK.
+logger = get_logger(logger_level=os.environ.get("LOG_LEVEL", "INFO"), name="clarifai")

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

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

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

@@ -1,22 +1,26 @@
-clarifai/__init__.py,sha256=5gJxqMyHfStgLsUbgDyNI4zTcQbFwffphiPw6fZhAHk,23
+clarifai/__init__.py,sha256=rJghd8fTbSCfCAow2Dmd1bS2hdZ2VQdNcu2IHtIH5vU,23
 clarifai/cli.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 clarifai/errors.py,sha256=RwzTajwds51wLD0MVlMC5kcpBnzRpreDLlazPSBZxrg,2605
 clarifai/versions.py,sha256=jctnczzfGk_S3EnVqb2FjRKfSREkNmvNEwAAa_VoKiQ,222
 clarifai/client/__init__.py,sha256=xI1U0l5AZdRThvQAXCLsd9axxyFzXXJ22m8LHqVjQRU,662
-clarifai/client/app.py,sha256=VC5TqeYVNUyENPxOOKNSAl0q3ivPiqg-gtRr77ACIIM,38424
-clarifai/client/base.py,sha256=JXbbjg2CXo8rOdw-XgKWWtLVAhPv3OZua5LFT5w4U2Q,7380
-clarifai/client/dataset.py,sha256=AmkeYdZI7oe7ZCEh4odTuzC5r4ESCmkdHHo4v23dSeQ,30204
-clarifai/client/input.py,sha256=ZLqa1jGx4NgCbunOTpJxCq4lDQ5xAf4GQ0rsZY8AHCM,44456
+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/input.py,sha256=cEVRytrMF1gCgwHLbXlSbPSEQN8uHpUAoKcCdyHO1pc,44406
 clarifai/client/lister.py,sha256=03KGMvs5RVyYqxLsSrWhNc34I8kiF1Ph0NeyEwu7nMU,2082
-clarifai/client/model.py,sha256=YqeCwk1v_Rs2L6OTZSkDZvxGaxMoFMYuxVV7s9jdd0I,74416
-clarifai/client/module.py,sha256=360JaOasX0DZCNE_Trj0LNTr-T_tUDZLfGpz0CdIi78,4248
+clarifai/client/model.py,sha256=_9kr__KP74v6PtSBtK1RrJjhrxzunXFVqyVn3xL78U0,74372
+clarifai/client/module.py,sha256=FTkm8s9m-EaTKN7g9MnLhGJ9eETUfKG7aWZ3o1RshYs,4204
+clarifai/client/nodepool.py,sha256=J9pnxQGO_HfScaUahccmEvJ4EOBib6k2nQR3gBdMoNs,9029
 clarifai/client/search.py,sha256=GaPWN6JmTQGZaCHr6U1yv0zqR6wKFl7i9IVLg2ul1CI,14254
-clarifai/client/user.py,sha256=Fr3vDEHieqD7HRRKnlp9h-AIX4AuYBirRYtG4KLwSe8,11836
-clarifai/client/workflow.py,sha256=e3axkhU6c6WcxK9P5tgmnV464k-afslSzsSXx6nSMgA,10560
+clarifai/client/user.py,sha256=0tcOk8_Yd1_ANj9E6sy9mz6s01V3qkmJS7pZVn_zUYo,17637
+clarifai/client/workflow.py,sha256=Wm4Fry6lGx8T43sBUqRI7v7sAmuvq_4Jft3vSW8UUJU,10516
 clarifai/client/auth/__init__.py,sha256=7EwR0NrozkAUwpUnCsqXvE_p0wqx_SelXlSpKShKJK0,136
-clarifai/client/auth/helper.py,sha256=hqwI7Zlsvivc-O9aAdtxyJT3zkpuMvbxjRaiCTsWYGk,14183
+clarifai/client/auth/helper.py,sha256=BuyI_smxuRq__8RF0Nv3lr_Rmb-CJVEyK4hv60VEV5A,14259
 clarifai/client/auth/register.py,sha256=2CMdBsoVLoTfjyksE6j7BM2tiEc73WKYvxnwDDgNn1k,536
 clarifai/client/auth/stub.py,sha256=xy4-fV0W8keCgXld4eOVzFQEIKxOktNwtL5bLztReug,4940
+clarifai/constants/base.py,sha256=ogmFSZYoF0YhGjHg5aiOc3MLqPr_poKAls6xaD0_C3U,89
 clarifai/constants/dataset.py,sha256=vjK3IlgXu31HycuvjRSzEQSqhU6xfj5TIgo6IpyUWoc,609
 clarifai/constants/input.py,sha256=WcHwToUVIK9ItAhDefaSohQHCLNeR55PSjZ0BFnoZ3U,28
 clarifai/constants/model.py,sha256=Um1hLfMFlh5R_vtP3Z6P-o6zon-tdbLcKVIl4PucrV4,438
@@ -25,7 +29,7 @@ clarifai/constants/search.py,sha256=yYEqTaFg-KdnpJE_Ytp-EPVHIIC395iNtZrpVlLIf4o,
 clarifai/constants/workflow.py,sha256=cECq1xdvf44MCdtK2AbkiuuwhyL-6OWZdQfYbsLKy_o,33
 clarifai/datasets/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 clarifai/datasets/export/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-clarifai/datasets/export/inputs_annotations.py,sha256=7c6HWdATI4aPCRoCPZetUBNNEz9dBhbyYX1QqX-xYe4,9744
+clarifai/datasets/export/inputs_annotations.py,sha256=Mwo-wFRIYXsoe13bR2bfsXViA6DlJbWmNuPpD3yHSrE,9701
 clarifai/datasets/upload/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 clarifai/datasets/upload/base.py,sha256=UIc0ufyIBCrb83_sFpv21L8FshsX4nwsLYQkdlJfzD4,2357
 clarifai/datasets/upload/features.py,sha256=jv2x7jGZKS-LMt87sEZNBwwOskHbP26XTMjoiaSA5pg,2024
@@ -47,10 +51,10 @@ clarifai/modules/css.py,sha256=kadCEunmyh5h2yf0-4aysE3ZcZ6qaQcxuAgDXS96yF8,2020
 clarifai/modules/pages.py,sha256=iOoM3RNRMgXlV0qBqcdQofxoXo2RuRQh0h9c9BIS0-I,1383
 clarifai/modules/style.css,sha256=j7FNPZVhLPj35vvBksAJ90RuX5sLuqzDR5iM2WIEhiA,6073
 clarifai/rag/__init__.py,sha256=wu3PzAzo7uqgrEzuaC9lY_3gj1HFiR3GU3elZIKTT5g,40
-clarifai/rag/rag.py,sha256=0udYyWVzBML-5-E05QuxBz7rNLxu7aMlist5uP7zPIY,12638
+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=xzEoYoBcQE5JUxmpy1aj5CF5gIpUZKLDKqVXTcQRH4Y,4267
+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/models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -58,31 +62,30 @@ clarifai/runners/models/base_typed_model.py,sha256=OnAk08Lo2Y1fGiBc6JJ6UvJ8P435c
 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=PsCHO4CsJ2N6kBdeo7uUNjxWooXUgLepW_NfjU_YJ1A,13899
+clarifai/runners/models/model_upload.py,sha256=4MD85lYtUwEolZF9nxmiH0zRM69Altv-z3luDlvxEvM,14276
 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
-clarifai/runners/utils/loader.py,sha256=r1FFfN7fE3GXPLOGaJAqmSpwETESkOAVZViOI8IpXNk,2532
-clarifai/runners/utils/logging.py,sha256=xan5ZQH5XHVyNIIjUAQoc_bS3MrjQjEvBYuo0CQKdho,153
-clarifai/runners/utils/url_fetcher.py,sha256=6u7tPRXuBe-4a2LYxRNJ5WTrNMH2kYXsk73Zuo14qb4,1432
+clarifai/runners/utils/loader.py,sha256=taWTf-TCIZKh8jjwiFDYg3EqtJPXqn9EFoedIbnYXE8,2811
+clarifai/runners/utils/url_fetcher.py,sha256=-Hwjb1SURszn7zUVwi4Of0-nrksfZy-uqT4SvPGCgSU,1446
 clarifai/schema/search.py,sha256=JjTi8ammJgZZ2OGl4K6tIA4zEJ1Fr2ASZARXavI1j5c,2448
 clarifai/urls/helper.py,sha256=tjoMGGHuWX68DUB0pk4MEjrmFsClUAQj2jmVEM_Sy78,4751
 clarifai/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 clarifai/utils/constants.py,sha256=MG_iHnSwNEyUZOpvsrTicNwaT4CIjmlK_Ixk_qqEX8g,142
-clarifai/utils/logging.py,sha256=_nzRyXu3fUa_5X8vXig5dV392YkNESDTc3ZoiwVOGZY,11359
+clarifai/utils/logging.py,sha256=rhutBRQJLtkNRz8IErNCgbIpvtl2fQ3D2otYcGqd3-Q,11565
 clarifai/utils/misc.py,sha256=ptjt1NtteDT0EhrPoyQ7mgWtvoAQ-XNncQaZvNHb0KI,2253
 clarifai/utils/model_train.py,sha256=Mndqy5GNu7kjQHjDyNVyamL0hQFLGSHcWhOuPyOvr1w,8005
 clarifai/utils/evaluation/__init__.py,sha256=PYkurUrXrGevByj7RFb6CoU1iC7fllyQSfnnlo9WnY8,69
-clarifai/utils/evaluation/helpers.py,sha256=d_dcASRI_lhsHIRukAF1S-w7XazLpK9y6E_ug3l50t4,18440
-clarifai/utils/evaluation/main.py,sha256=0SbTN8cUDjfd4vHUSIG0qVVmDDlJE_5il4vcZGi6a5g,15781
+clarifai/utils/evaluation/helpers.py,sha256=Fl3QzrtlvhtaLc8kD3As2hJGpnf7yHcQ6hA0sDstnnI,18378
+clarifai/utils/evaluation/main.py,sha256=u8j_ZcY2vKfhJhNJRvf6Ww1OsHfKg8gR-5HnXHF4aEY,15719
 clarifai/utils/evaluation/testset_annotation_parser.py,sha256=iZfLw6oR1qgJ3MHMbOZXcGBLu7btSDn0VqdiAzpIm4g,5002
 clarifai/workflows/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 clarifai/workflows/export.py,sha256=vICRhIreqDSShxLKjHNM2JwzKsf1B4fdXB0ciMcA70k,1945
 clarifai/workflows/utils.py,sha256=nGeB_yjVgUO9kOeKTg4OBBaBz-AwXI3m-huSVj-9W18,1924
 clarifai/workflows/validate.py,sha256=yJq03MaJqi5AK3alKGJJBR89xmmjAQ31sVufJUiOqY8,2556
-clarifai-10.8.6.dist-info/LICENSE,sha256=mUqF_d12-qE2n41g7C5_sq-BMLOcj6CNN-jevr15YHU,555
-clarifai-10.8.6.dist-info/METADATA,sha256=u7wP6djeaOnVhlz_RBIE2aDEretrTZuJWHbfC_UVHpY,19479
-clarifai-10.8.6.dist-info/WHEEL,sha256=GV9aMThwP_4oNCtvEC2ec3qUYutgWeAzklro_0m4WJQ,91
-clarifai-10.8.6.dist-info/entry_points.txt,sha256=qZOr_MIPG0dBBE1zringDJS_wXNGTAA_SQ-zcbmDHOw,82
-clarifai-10.8.6.dist-info/top_level.txt,sha256=wUMdCQGjkxaynZ6nZ9FAnvBUCgp5RJUVFSy2j-KYo0s,9
-clarifai-10.8.6.dist-info/RECORD,,
+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/runners/utils/logging.py

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