clarifai 11.2.2__py3-none-any.whl → 11.2.3__py3-none-any.whl

clarifai/cli/nodepool.py

@@ -1,31 +1,27 @@
 import click
+
 from clarifai.cli.base import cli
-from clarifai.client.compute_cluster import ComputeCluster
-from clarifai.utils.cli import display_co_resources, dump_yaml, from_yaml, validate_context
+from clarifai.utils.cli import (AliasedGroup, display_co_resources, dump_yaml, from_yaml,
+                                validate_context)
 
 
-@cli.group(['nodepool', 'np'])
+@cli.group(['nodepool', 'np'], cls=AliasedGroup)
 def nodepool():
   """Manage Nodepools: create, delete, list"""
-  pass
 
 
-@nodepool.command()
-@click.option(
-    '-cc_id',
-    '--compute_cluster_id',
-    required=False,
-    help='Compute Cluster ID for the compute cluster to interact with.')
+@nodepool.command(['c'])
+@click.argument('compute_cluster_id')
+@click.argument('nodepool_id')
 @click.option(
     '--config',
     type=click.Path(exists=True),
     required=True,
     help='Path to the nodepool config file.')
-@click.option(
-    '-np_id', '--nodepool_id', required=False, help='New Nodepool ID for the nodepool to create.')
 @click.pass_context
-def create(ctx, compute_cluster_id, config, nodepool_id):
+def create(ctx, compute_cluster_id, nodepool_id, config):
   """Create a new Nodepool with the given config file."""
+  from clarifai.client.compute_cluster import ComputeCluster
 
   validate_context(ctx)
   nodepool_config = from_yaml(config)
@@ -43,52 +39,74 @@ def create(ctx, compute_cluster_id, config, nodepool_id):
 
   compute_cluster = ComputeCluster(
       compute_cluster_id=compute_cluster_id,
-      user_id=ctx.obj['user_id'],
-      pat=ctx.obj['pat'],
-      base_url=ctx.obj['base_url'])
+      user_id=ctx.obj.current.user_id,
+      pat=ctx.obj.current.pat,
+      base_url=ctx.obj.current.api_base)
   if nodepool_id:
     compute_cluster.create_nodepool(config, nodepool_id=nodepool_id)
   else:
     compute_cluster.create_nodepool(config)
 
 
-@nodepool.command()
-@click.option(
-    '-cc_id',
-    '--compute_cluster_id',
-    required=True,
-    help='Compute Cluster ID for the compute cluster to interact with.')
+@nodepool.command(['ls'])
+@click.argument('compute_cluster_id', default="")
 @click.option('--page_no', required=False, help='Page number to list.', default=1)
-@click.option('--per_page', required=False, help='Number of items per page.', default=16)
+@click.option('--per_page', required=False, help='Number of items per page.', default=128)
 @click.pass_context
 def list(ctx, compute_cluster_id, page_no, per_page):
-  """List all nodepools for the user."""
+  """List all nodepools for the user across all compute clusters. If compute_cluster_id is provided
+  it will list only within that compute cluster. """
+  from clarifai.client.compute_cluster import ComputeCluster
+  from clarifai.client.user import User
 
   validate_context(ctx)
-  compute_cluster = ComputeCluster(
-      compute_cluster_id=compute_cluster_id,
-      user_id=ctx.obj['user_id'],
-      pat=ctx.obj['pat'],
-      base_url=ctx.obj['base_url'])
-  response = compute_cluster.list_nodepools(page_no, per_page)
-  display_co_resources(response, "Nodepool")
 
+  cc_id = compute_cluster_id
 
-@nodepool.command()
-@click.option(
-    '-cc_id',
-    '--compute_cluster_id',
-    required=True,
-    help='Compute Cluster ID for the compute cluster to interact with.')
-@click.option('-np_id', '--nodepool_id', help='Nodepool ID of the user to delete.')
+  if cc_id:
+    compute_cluster = ComputeCluster(
+        compute_cluster_id=cc_id,
+        user_id=ctx.obj.current.user_id,
+        pat=ctx.obj.current.pat,
+        base_url=ctx.obj.current.api_base)
+    response = compute_cluster.list_nodepools(page_no, per_page)
+  else:
+    user = User(
+        user_id=ctx.obj.current.user_id,
+        pat=ctx.obj.current.pat,
+        base_url=ctx.obj.current.api_base)
+    ccs = user.list_compute_clusters(page_no, per_page)
+    response = []
+    for cc in ccs:
+      compute_cluster = ComputeCluster(
+          compute_cluster_id=cc.id,
+          user_id=ctx.obj.current.user_id,
+          pat=ctx.obj.current.pat,
+          base_url=ctx.obj.current.api_base)
+      response.extend([i for i in compute_cluster.list_nodepools(page_no, per_page)])
+
+  display_co_resources(
+      response,
+      custom_columns={
+          'ID': lambda c: c.id,
+          'USER_ID': lambda c: c.compute_cluster.user_id,
+          'COMPUTE_CLUSTER_ID': lambda c: c.compute_cluster.id,
+          'DESCRIPTION': lambda c: c.description,
+      })
+
+
+@nodepool.command(['rm'])
+@click.argument('compute_cluster_id')
+@click.argument('nodepool_id')
 @click.pass_context
 def delete(ctx, compute_cluster_id, nodepool_id):
   """Deletes a nodepool for the user."""
+  from clarifai.client.compute_cluster import ComputeCluster
 
   validate_context(ctx)
   compute_cluster = ComputeCluster(
       compute_cluster_id=compute_cluster_id,
-      user_id=ctx.obj['user_id'],
-      pat=ctx.obj['pat'],
-      base_url=ctx.obj['base_url'])
+      user_id=ctx.obj.current.user_id,
+      pat=ctx.obj.current.pat,
+      base_url=ctx.obj.current.api_base)
   compute_cluster.delete_nodepools([nodepool_id])

clarifai/client/auth/stub.py

@@ -1,5 +1,4 @@
 import itertools
-import logging
 import time
 from concurrent.futures import ThreadPoolExecutor
 
@@ -8,7 +7,7 @@ from clarifai_grpc.grpc.api.status import status_code_pb2
 
 from clarifai.client.auth.helper import ClarifaiAuthHelper
 from clarifai.client.auth.register import RpcCallable, V2Stub
-
+from clarifai.utils.logging import logger
 throttle_status_codes = {
     status_code_pb2.CONN_THROTTLED,
     status_code_pb2.CONN_EXCEED_HOURLY_LIMIT,
@@ -26,7 +25,7 @@ def validate_response(response, attempt, max_attempts):
   def handle_simple_response(response):
     if hasattr(response, 'status') and hasattr(response.status, 'code'):
       if (response.status.code in throttle_status_codes) and attempt < max_attempts:
-        logging.debug('Retrying with status %s' % str(response.status))
+        logger.debug('Retrying with status %s' % str(response.status))
         return None  # Indicates a retry is needed
       else:
         return response
@@ -42,7 +41,7 @@ def validate_response(response, attempt, max_attempts):
         return itertools.chain([validated_response], response)
       return None  # Indicates a retry is needed
     except grpc.RpcError as e:
-      logging.error('Error processing streaming response: %s' % str(e))
+      logger.error('Error processing streaming response: %s' % str(e))
       return None  # Indicates an error
   else:
     # Handle simple response validation
@@ -143,7 +142,7 @@ class _RetryRpcCallable(RpcCallable):
           return v
       except grpc.RpcError as e:
         if (e.code() in retry_codes_grpc) and attempt < self.max_attempts:
-          logging.debug('Retrying with status %s' % e.code())
+          logger.debug('Retrying with status %s' % e.code())
         else:
           raise
 

clarifai/client/dataset.py

@@ -1,4 +1,3 @@
-import logging
 import os
 import time
 import uuid
@@ -354,7 +353,7 @@ class Dataset(Lister, BaseClient):
         break
       if failed_input_ids:
         retry_input_ids = [dataset_obj.all_input_ids[id] for id in failed_input_ids]
-        logging.warning(
+        logger.warning(
             f"Retrying upload for {len(failed_input_ids)} inputs in current batch: {retry_input_ids}\n"
         )
         failed_retrying_inputs, _, retry_response = self._upload_inputs_annotations(
@@ -494,7 +493,7 @@ class Dataset(Lister, BaseClient):
       add_file_handler(self.logger, f"Dataset_Upload{str(int(datetime.now().timestamp()))}.log")
 
     if retry_duplicates and duplicate_input_ids:
-      logging.warning(f"Retrying upload for {len(duplicate_input_ids)} duplicate inputs...\n")
+      logger.warning(f"Retrying upload for {len(duplicate_input_ids)} duplicate inputs...\n")
       duplicate_inputs_indexes = [input["Index"] for input in duplicate_input_ids]
       self.upload_dataset(
           dataloader=dataloader,
@@ -505,7 +504,7 @@ class Dataset(Lister, BaseClient):
 
     if failed_input_ids:
       #failed_inputs= ([input["Input_ID"] for input in failed_input_ids])
-      logging.warning(f"Retrying upload for {len(failed_input_ids)} failed inputs...\n")
+      logger.warning(f"Retrying upload for {len(failed_input_ids)} failed inputs...\n")
       failed_input_indexes = [input["Index"] for input in failed_input_ids]
       self.upload_dataset(
           dataloader=dataloader, log_retry_ids=failed_input_indexes, is_log_retry=True, **kwargs)

clarifai/runners/models/model_builder.py

@@ -142,17 +142,21 @@ class ModelBuilder:
   def _validate_config_checkpoints(self):
     """
     Validates the checkpoints section in the config file.
+      return loader_type, repo_id, hf_token, when, allowed_file_patterns, ignore_file_patterns
     :return: loader_type the type of loader or None if no checkpoints.
     :return: repo_id location of checkpoint.
     :return: hf_token token to access checkpoint.
+    :return: when one of ['upload', 'build', 'runtime'] to download checkpoint
+    :return: allowed_file_patterns patterns to allow in downloaded checkpoint
+    :return: ignore_file_patterns patterns to ignore in downloaded checkpoint
     """
     if "checkpoints" not in self.config:
-      return None, None, None, DEFAULT_DOWNLOAD_CHECKPOINT_WHEN
+      return None, None, None, DEFAULT_DOWNLOAD_CHECKPOINT_WHEN, None, None
     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:
       logger.info("No loader type specified in the config file for checkpoints")
-      return None, None, None
+      return None, None, None, DEFAULT_DOWNLOAD_CHECKPOINT_WHEN, None, None
     checkpoints = self.config.get("checkpoints")
     if 'when' not in checkpoints:
       logger.warn(
@@ -184,9 +188,17 @@ class ModelBuilder:
     resp = self.client.STUB.GetApp(service_pb2.GetAppRequest(user_app_id=self.client.user_app_id))
     if resp.status.code == status_code_pb2.SUCCESS:
       return True
+    if resp.status.code == status_code_pb2.CONN_KEY_INVALID:
+      logger.error(
+          f"Invalid PAT provided for user {self.client.user_app_id.user_id}. Please check your PAT and try again."
+      )
+      return False
     logger.error(
         f"Error checking API {self._base_api} for user app {self.client.user_app_id.user_id}/{self.client.user_app_id.app_id}. Error code: {resp.status.code}"
     )
+    logger.error(
+        f"App {self.client.user_app_id.app_id} not found for user {self.client.user_app_id.user_id}. Please create the app first and try again."
+    )
     return False
 
   def _validate_config_model(self):
@@ -207,9 +219,6 @@ class ModelBuilder:
     assert model.get('id') != "", "model_id cannot be empty in the config file"
 
     if not self._check_app_exists():
-      logger.error(
-          f"App {self.client.user_app_id.app_id} not found for user {self.client.user_app_id.user_id}"
-      )
       sys.exit(1)
 
   def _validate_config(self):
@@ -406,11 +415,12 @@ class ModelBuilder:
       # Sort in reverse so that newer cuda versions come first and are preferred.
       for image in sorted(AVAILABLE_TORCH_IMAGES, reverse=True):
         if torch_version in image and f'py{python_version}' in image:
-          cuda_version = image.split('-')[-1].replace('cuda', '')
+          # like cu124, rocm6.3, etc.
+          gpu_version = image.split('-')[-1]
           final_image = TORCH_BASE_IMAGE.format(
               torch_version=torch_version,
               python_version=python_version,
-              cuda_version=cuda_version,
+              gpu_version=gpu_version,
           )
           logger.info(f"Using Torch version {torch_version} base image to build the Docker image")
           break

clarifai/runners/models/model_run_locally.py

@@ -108,6 +108,7 @@ class ModelRunLocally:
 
   def _build_stream_request(self):
     request = self._build_request()
+    ensure_urls_downloaded(request)
     for i in range(1):
       yield request
 

clarifai/runners/utils/const.py

@@ -2,10 +2,10 @@ import os
 
 registry = os.environ.get('CLARIFAI_BASE_IMAGE_REGISTRY', 'public.ecr.aws/clarifai-models')
 
-GIT_SHA = "df565436eea93efb3e8d1eb558a0a46df29523ec"
+GIT_SHA = "b8ae56bf3b7c95e686ca002b07ca83d259c716eb"
 
 PYTHON_BASE_IMAGE = registry + '/python-base:{python_version}-' + GIT_SHA
-TORCH_BASE_IMAGE = registry + '/torch:{torch_version}-py{python_version}-cuda{cuda_version}-' + GIT_SHA
+TORCH_BASE_IMAGE = registry + '/torch:{torch_version}-py{python_version}-{gpu_version}-' + GIT_SHA
 
 # List of available python base images
 AVAILABLE_PYTHON_IMAGES = ['3.11', '3.12']
@@ -21,12 +21,13 @@ DEFAULT_RUNTIME_DOWNLOAD_PATH = os.path.join(os.sep, "tmp", ".cache")
 # List of available torch images
 # Keep sorted by most recent cuda version.
 AVAILABLE_TORCH_IMAGES = [
-    '2.4.1-py3.11-cuda124',
-    '2.5.1-py3.11-cuda124',
-    '2.4.1-py3.12-cuda124',
-    '2.5.1-py3.12-cuda124',
-    # '2.4.1-py3.13-cuda124',
-    # '2.5.1-py3.13-cuda124',
+    '2.4.1-py3.11-cu124',
+    '2.5.1-py3.11-cu124',
+    '2.4.1-py3.12-cu124',
+    '2.5.1-py3.12-cu124',
+    '2.6.0-py3.12-cu126',
+    '2.7.0-py3.12-cu128',
+    '2.7.0-py3.12-rocm6.3',
 ]
 CONCEPTS_REQUIRED_MODEL_TYPE = [
     'visual-classifier', 'visual-detector', 'visual-segmenter', 'text-classifier'

clarifai/utils/cli.py

@@ -2,16 +2,13 @@ import importlib
 import os
 import pkgutil
 import sys
+import typing as t
+from collections import defaultdict
+from typing import OrderedDict
 
 import click
 import yaml
-
-from rich.console import Console
-from rich.panel import Panel
-from rich.style import Style
-from rich.text import Text
-
-from clarifai.utils.logging import logger
+from tabulate import tabulate
 
 
 def from_yaml(filename: str):
@@ -31,19 +28,6 @@ def dump_yaml(data, filename: str):
     click.echo(f"Error writing YAML file: {e}", err=True)
 
 
-def set_base_url(env):
-  environments = {
-      'prod': 'https://api.clarifai.com',
-      'staging': 'https://api-staging.clarifai.com',
-      'dev': 'https://api-dev.clarifai.com'
-  }
-
-  if env in environments:
-    return environments[env]
-  else:
-    raise ValueError("Invalid environment. Please choose from 'prod', 'staging', 'dev'.")
-
-
 # Dynamically find and import all command modules from the cli directory
 def load_command_modules():
   package_dir = os.path.join(os.path.dirname(os.path.dirname(__file__)), 'cli')
@@ -53,27 +37,132 @@ def load_command_modules():
       importlib.import_module(f'clarifai.cli.{module_name}')
 
 
-def display_co_resources(response, resource_type):
+def display_co_resources(response,
+                         custom_columns={
+                             'ID': lambda c: c.id,
+                             'USER_ID': lambda c: c.user_id,
+                             'DESCRIPTION': lambda c: c.description,
+                         }):
   """Display compute orchestration resources listing results using rich."""
 
-  console = Console()
-  panel = Panel(
-      Text(f"List of {resource_type}s", justify="center"),
-      title="",
-      style=Style(color="blue", bold=True),
-      border_style="green",
-      width=60)
-  console.print(panel)
-  for indx, item in enumerate(list(response)):
-    panel = Panel(
-        "\n".join([f"{'ID'}: {item.id}", f"{'Description'}: {item.description}"]),
-        title=f"{resource_type} {(indx + 1)}",
-        border_style="green",
-        width=60)
-    console.print(panel)
+  formatter = TableFormatter(custom_columns)
+  print(formatter.format(list(response), fmt="plain"))
+
+
+class TableFormatter:
+
+  def __init__(self, custom_columns: OrderedDict):
+    """
+        Initializes the TableFormatter with column headers and custom column mappings.
+
+        :param headers: List of column headers for the table.
+        """
+    self.custom_columns = custom_columns
+
+  def format(self, objects, fmt='plain'):
+    """
+        Formats a list of objects into a table with custom columns.
+
+        :param objects: List of objects to format into a table.
+        :return: A string representing the table.
+        """
+    # Prepare the rows by applying the custom column functions to each object
+    rows = []
+    for obj in objects:
+      #   row = [self.custom_columns[header](obj) for header in self.headers]
+      row = [f(obj) for f in self.custom_columns.values()]
+      rows.append(row)
+
+    # Create the table
+    table = tabulate(rows, headers=self.custom_columns.keys(), tablefmt=fmt)
+    return table
+
+
+class AliasedGroup(click.Group):
+
+  def __init__(self,
+               name: t.Optional[str] = None,
+               commands: t.Optional[t.Union[t.MutableMapping[str, click.Command], t.Sequence[
+                   click.Command]]] = None,
+               **attrs: t.Any) -> None:
+    super().__init__(name, commands, **attrs)
+    self.alias_map = {}
+    self.command_to_aliases = defaultdict(list)
+
+  def add_alias(self, cmd: click.Command, alias: str) -> None:
+    self.alias_map[alias] = cmd
+    if alias != cmd.name:
+      self.command_to_aliases[cmd].append(alias)
+
+  def command(self, aliases=None, *args,
+              **kwargs) -> t.Callable[[t.Callable[..., t.Any]], click.Command]:
+    cmd_decorator = super().command(*args, **kwargs)
+    if aliases is None:
+      aliases = []
+
+    def aliased_decorator(f):
+      cmd = cmd_decorator(f)
+      if cmd.name:
+        self.add_alias(cmd, cmd.name)
+      for alias in aliases:
+        self.add_alias(cmd, alias)
+      return cmd
+
+    f = None
+    if args and callable(args[0]):
+      (f,) = args
+    if f is not None:
+      return aliased_decorator(f)
+    return aliased_decorator
+
+  def group(self, aliases=None, *args,
+            **kwargs) -> t.Callable[[t.Callable[..., t.Any]], click.Group]:
+    cmd_decorator = super().group(*args, **kwargs)
+    if aliases is None:
+      aliases = []
+
+    def aliased_decorator(f):
+      cmd = cmd_decorator(f)
+      if cmd.name:
+        self.add_alias(cmd, cmd.name)
+      for alias in aliases:
+        self.add_alias(cmd, alias)
+      return cmd
+
+    f = None
+    if args and callable(args[0]):
+      (f,) = args
+    if f is not None:
+      return aliased_decorator(f)
+    return aliased_decorator
+
+  def get_command(self, ctx: click.Context, cmd_name: str) -> t.Optional[click.Command]:
+    rv = click.Group.get_command(self, ctx, cmd_name)
+    if rv is not None:
+      return rv
+    return self.alias_map.get(cmd_name)
+
+  def format_commands(self, ctx, formatter):
+    sub_commands = self.list_commands(ctx)
+
+    rows = []
+    for sub_command in sub_commands:
+      cmd = self.get_command(ctx, sub_command)
+      if cmd is None or getattr(cmd, 'hidden', False):
+        continue
+      if cmd in self.command_to_aliases:
+        aliases = ', '.join(self.command_to_aliases[cmd])
+        sub_command = f'{sub_command} ({aliases})'
+      cmd_help = cmd.help
+      rows.append((sub_command, cmd_help))
+
+    if rows:
+      with formatter.section("Commands"):
+        formatter.write_dl(rows)
 
 
 def validate_context(ctx):
+  from clarifai.utils.logging import logger
   if ctx.obj == {}:
     logger.error("CLI config file missing. Run `clarifai login` to set up the CLI config.")
     sys.exit(1)

clarifai/utils/config.py

@@ -0,0 +1,105 @@
+import os
+from collections import OrderedDict
+from dataclasses import dataclass, field
+
+import yaml
+
+from clarifai.utils.constants import DEFAULT_CONFIG
+
+
+class Context(OrderedDict):
+  """
+    A context which has a name and a set of key-values as a dict under env.
+
+    You can access the keys directly.
+    """
+
+  def __init__(self, name, **kwargs):
+    self['name'] = name
+    # when loading from config we may have the env: section in yaml already so we get it here.
+    if 'env' in kwargs:
+      self['env'] = kwargs['env']
+    else:  # when consructing as Context(name, key=value) we set it here.
+      self['env'] = kwargs
+
+  def __getattr__(self, key):
+    try:
+      if key == 'name':
+        return self[key]
+      if key == 'env':
+        raise AttributeError("Don't access .env directly")
+
+      # Allow accessing CLARIFAI_PAT type env var names from config as .pat
+      envvar_name = 'CLARIFAI_' + key.upper()
+      env = self['env']
+      if envvar_name in env:
+        value = env[envvar_name]
+        if value == "ENVVAR":
+          return os.environ[envvar_name]
+      else:
+        value = env[key]
+
+      if isinstance(value, dict):
+        return Context(value)
+
+      return value
+    except KeyError as e:
+      raise AttributeError(f"'{type(self).__name__}' object has no attribute '{key}'") from e
+
+  def __setattr__(self, key, value):
+    if key == "name":
+      self['name'] = value
+    else:
+      self['env'][key] = value
+
+  def __delattr__(self, key):
+    try:
+      del self['env'][key]
+    except KeyError as e:
+      raise AttributeError(f"'{type(self).__name__}' object has no attribute '{key}'") from e
+
+  def to_serializable_dict(self):
+    return dict(self['env'])
+
+
+@dataclass
+class Config():
+  current_context: str
+  filename: str
+  contexts: OrderedDict[str, Context] = field(default_factory=OrderedDict)
+
+  def __post_init__(self):
+    for k, v in self.contexts.items():
+      if 'name' not in v:
+        v['name'] = k
+    self.contexts = {k: Context(**v) for k, v in self.contexts.items()}
+
+  @classmethod
+  def from_yaml(cls, filename: str = DEFAULT_CONFIG):
+    with open(filename, 'r') as f:
+      cfg = yaml.safe_load(f)
+    return cls(**cfg, filename=filename)
+
+  def to_dict(self):
+    return {
+        'current_context': self.current_context,
+        'contexts': {k: v.to_serializable_dict()
+                     for k, v in self.contexts.items()}
+    }
+
+  def to_yaml(self, filename: str = None):
+    if filename is None:
+      filename = self.filename
+    dir = os.path.dirname(filename)
+    if len(dir):
+      os.makedirs(dir, exist_ok=True)
+    _dict = self.to_dict()
+    for k, v in _dict['contexts'].items():
+      v.pop('name', None)
+    with open(filename, 'w') as f:
+      yaml.safe_dump(_dict, f)
+
+  @property
+  def current(self) -> Context:
+    """ get the current Context """
+    return self.contexts[self.current_context]

clarifai/utils/constants.py

@@ -1,3 +1,7 @@
+import os
+
 CLARIFAI_PAT_ENV_VAR = "CLARIFAI_PAT"
 CLARIFAI_SESSION_TOKEN_ENV_VAR = "CLARIFAI_SESSION_TOKEN"
 CLARIFAI_USER_ID_ENV_VAR = "CLARIFAI_USER_ID"
+
+DEFAULT_CONFIG = f'{os.environ["HOME"]}/.config/clarifai/config'