clarifai 10.8.5__py3-none-any.whl → 10.8.7__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_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:
@@ -28,12 +28,11 @@ class ModelUploader:
   ]
 
   def __init__(self, folder: str):
+    self._client = None
     self.folder = self._validate_folder(folder)
     self.config = self._load_config(os.path.join(self.folder, 'config.yaml'))
-    self.initialize_client()
     self.model_proto = self._get_model_proto()
     self.model_id = self.model_proto.id
-    self.user_app_id = self.client.user_app_id
     self.inference_compute_info = self._get_inference_compute_info()
     self.is_v3 = True  # Do model build for v3
 
@@ -41,7 +40,9 @@ 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)
     assert "requirements.txt" in files, "requirements.txt not found in the folder"
     assert "config.yaml" in files, "config.yaml not found in the folder"
@@ -56,18 +57,21 @@ class ModelUploader:
       config = yaml.safe_load(file)
     return config
 
-  def initialize_client(self):
-    assert "model" in self.config, "model info not found in the config file"
-    model = self.config.get('model')
-    assert "user_id" in model, "user_id not found in the config file"
-    assert "app_id" in model, "app_id not found in the config file"
-    user_id = model.get('user_id')
-    app_id = model.get('app_id')
+  @property
+  def client(self):
+    if self._client is None:
+      assert "model" in self.config, "model info not found in the config file"
+      model = self.config.get('model')
+      assert "user_id" in model, "user_id not found in the config file"
+      assert "app_id" in model, "app_id not found in the config file"
+      user_id = model.get('user_id')
+      app_id = model.get('app_id')
 
-    base = os.environ.get('CLARIFAI_API_BASE', 'https://api-dev.clarifai.com')
+      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}")
+      self._client = BaseClient(user_id=user_id, app_id=app_id, base=base)
+      logger.info(f"Client initialized for user {user_id} and app {app_id}")
+    return self._client
 
   def _get_model_proto(self):
     assert "model" in self.config, "model info not found in the config file"
@@ -96,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
@@ -127,7 +131,15 @@ class ModelUploader:
 
     # Get the Python version from the config file
     build_info = self.config.get('build_info', {})
-    python_version = build_info.get('python_version', self.DEFAULT_PYTHON_VERSION)
+    if 'python_version' in build_info:
+      python_version = build_info['python_version']
+      logger.info(
+          f"Using Python version {python_version} from the config file to build the Dockerfile")
+    else:
+      logger.info(
+          f"Python version not found in the config file, using default Python version: {self.DEFAULT_PYTHON_VERSION}"
+      )
+      python_version = self.DEFAULT_PYTHON_VERSION
 
     # Replace placeholders with actual values
     dockerfile_content = dockerfile_template.safe_substitute(
@@ -141,25 +153,33 @@ 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"
       repo_id = self.config.get("checkpoints").get("repo_id")
 
-      hf_token = self.config.get("checkpoints").get("hf_token", None)
+      # prefer env var for HF_TOKEN but if not provided then use the one from config.yaml if any.
+      if 'HF_TOKEN' in os.environ:
+        hf_token = os.environ['HF_TOKEN']
+      else:
+        hf_token = self.config.get("checkpoints").get("hf_token", None)
+        assert hf_token != 'hf_token', "The default 'hf_token' is not valid. Please provide a valid token or leave that field out of config.yaml if not needed."
       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 = []
@@ -183,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):
 
@@ -209,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()
 
@@ -230,14 +250,15 @@ class ModelUploader:
       print(
           f"Status: {response.status.description}, "
           f"Progress: {percent_completed}% - {details} ",
+          f"request_id: {response.status.req_id}",
           end='\r',
           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)
 
@@ -247,24 +268,35 @@ 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
-
+      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):
-        chunk = f.read(chunk_size)
-        read_so_far += len(chunk)
-        yield service_pb2.PostModelVersionsUploadRequest(
-            content_part=resources_pb2.UploadContentPart(
-                data=chunk,
-                part_number=part_id + 1,
-                range_start=read_so_far,
-            ))
-    print("\nUpload complete!, waiting for model build...")
+        try:
+          chunk_size = min(chunk_size, file_size - read_so_far)
+          chunk = f.read(chunk_size)
+          if not chunk:
+            break
+          read_so_far += len(chunk)
+          yield service_pb2.PostModelVersionsUploadRequest(
+              content_part=resources_pb2.UploadContentPart(
+                  data=chunk,
+                  part_number=part_id + 1,
+                  range_start=read_so_far,
+              ))
+        except Exception as e:
+          logger.exception(f"\nError uploading file: {e}")
+          break
+
+    if read_so_far == file_size:
+      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}' with 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,
@@ -285,22 +317,25 @@ 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(
-            f"Check out the model at https://clarifai.com/{self.user_app_id.user_id}/apps/{self.user_app_id.app_id}/models/{self.model_id}/versions/{model_version_id}"
+        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
 
 
-def main(folder):
+def main(folder, download_checkpoints):
   uploader = ModelUploader(folder)
-  uploader.download_checkpoints()
+  if download_checkpoints:
+    uploader.download_checkpoints()
   uploader.create_dockerfile()
   input("Press Enter to continue...")
   uploader.upload_model_version()
@@ -310,6 +345,13 @@ if __name__ == "__main__":
   parser = argparse.ArgumentParser()
   parser.add_argument(
       '--model_path', type=str, help='Path of the model folder to upload', required=True)
+  # flag to default to not download checkpoints
+  parser.add_argument(
+      '--download_checkpoints',
+      action='store_true',
+      help=
+      'Flag to download checkpoints before uploading and including them in the tar file that is uploaded. Defaults to False, which will attempt to download them at docker build time.',
+  )
   args = parser.parse_args()
 
-  main(args.model_path)
+  main(args.model_path, args.download_checkpoints)

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,8 +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.5.dist-info → clarifai-10.8.7.dist-info}/METADATA

@@ -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