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

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

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

clarifai/runners/models/model_upload.py

@@ -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}")
       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(f"File size: {file_size}")
+      logger.info(f"Chunk size: {chunk_size}")
+      logger.info(f"Number of chunks: {num_chunks}")
       read_so_far = 0
       for part_id in range(num_chunks):
         try:
@@ -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,
@@ -316,13 +320,14 @@ class ModelUploader:
         print(f"Model is building... (elapsed {time.time() - st:.1f}s)", end='\r', flush=True)
         time.sleep(1)
       elif status_code == status_code_pb2.MODEL_TRAINED:
-        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,8 @@ 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.runners.models.model_upload import ModelUploader
+from clarifai.utils.logging import logger
 
 
 def main():
@@ -93,21 +94,26 @@ def main():
 
   MyRunner = classes[0]
 
-  # initialize the Runner class. This is what the user implements.
-  # (Note) do we want to set runner_id, nodepool_id, compute_cluster_id, base_url, num_parallel_polls as env vars? or as args?
-  runner = MyRunner(
-      runner_id=os.environ["CLARIFAI_RUNNER_ID"],
-      nodepool_id=os.environ["CLARIFAI_NODEPOOL_ID"],
-      compute_cluster_id=os.environ["CLARIFAI_COMPUTE_CLUSTER_ID"],
-      base_url=os.environ["CLARIFAI_API_BASE"],
-      num_parallel_polls=int(os.environ.get("CLARIFAI_NUM_THREADS", 1)),
-  )
-
-  # initialize the servicer
-  servicer = ModelServicer(runner)
-
   # Setup the grpc server for local development.
   if parsed_args.start_dev_server:
+
+    # We validate that we have checkpoints downloaded before constructing MyRunner which
+    # will call load_model()
+    uploader = ModelUploader(parsed_args.model_path)
+    uploader.download_checkpoints()
+
+    # initialize the Runner class. This is what the user implements.
+    # we aren't going to call runner.start() to engage with the API so IDs are not necessary.
+    runner = MyRunner(
+        runner_id="n/a",
+        nodepool_id="n/a",
+        compute_cluster_id="n/a",
+        health_check_port=None,  # not needed when running local server
+    )
+
+    # initialize the servicer with the runner so that it gets the predict(), generate(), stream() classes.
+    servicer = ModelServicer(runner)
+
     server = GRPCServer(
         futures.ThreadPoolExecutor(
             max_workers=parsed_args.pool_size,
@@ -121,9 +127,18 @@ def main():
     service_pb2_grpc.add_V2Servicer_to_server(servicer, server)
     server.start()
     logger.info("Started server on port %s", parsed_args.port)
-    # server.wait_for_termination() # won't get here currently.
-
-  runner.start()  # start the runner loop to fetch work from the API.
+    server.wait_for_termination()
+  else:  # start the runner with the proper env variables and as a runner protocol.
+
+    # initialize the Runner class. This is what the user implements.
+    runner = MyRunner(
+        runner_id=os.environ["CLARIFAI_RUNNER_ID"],
+        nodepool_id=os.environ["CLARIFAI_NODEPOOL_ID"],
+        compute_cluster_id=os.environ["CLARIFAI_COMPUTE_CLUSTER_ID"],
+        base_url=os.environ["CLARIFAI_API_BASE"],
+        num_parallel_polls=int(os.environ.get("CLARIFAI_NUM_THREADS", 1)),
+    )
+    runner.start()  # start the runner to fetch work from the API.
 
 
 if __name__ == '__main__':

clarifai/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.8.dist-info}/METADATA

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