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

clarifai/cli/nodepool.py

@@ -1,30 +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.client.user import User
+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."""
 
   validate_context(ctx)
@@ -43,44 +40,63 @@ 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. """
 
   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."""
@@ -88,7 +104,7 @@ def delete(ctx, compute_cluster_id, nodepool_id):
   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/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,14 +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 tabulate import tabulate
 
 from clarifai.utils.logging import logger
 
@@ -31,19 +30,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,24 +39,128 @@ 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):