clarifai 11.2.3rc6__py3-none-any.whl → 11.2.3rc8__py3-none-any.whl

clarifai/runners/utils/data_types.py

@@ -83,10 +83,6 @@ class NamedFields(metaclass=NamedFieldsMeta):
     return list(self.keys())
 
 
-class Stream(Iterable):
-  pass
-
-
 class JSON:
 
   def __init__(self, value):

clarifai/runners/utils/data_utils.py

@@ -1,13 +1,13 @@
 from io import BytesIO
+from typing import List
 
+from clarifai_grpc.grpc.api import resources_pb2
 from clarifai_grpc.grpc.api.resources_pb2 import ModelTypeEnumOption
 from clarifai_grpc.grpc.api.resources_pb2 import ModelTypeField as InputFieldProto
 from clarifai_grpc.grpc.api.resources_pb2 import ModelTypeRangeInfo
 from PIL import Image
 
 from clarifai.runners.utils.data_types import MessageData
-from clarifai_grpc.grpc.api import resources_pb2
-from typing import List
 
 
 def image_to_bytes(img: Image.Image, format="JPEG") -> bytes:
@@ -202,7 +202,7 @@ class DataConverter:
         if field.required:
           raise ValueError(f"Field {field.name} is required but not set")
     return new_data
-  
+
   @classmethod
   def _convert_field(cls, old_data: resources_pb2.Data,
                      field: resources_pb2.ModelTypeField) -> resources_pb2.Data:
@@ -221,19 +221,19 @@ class DataConverter:
         new_data.video.CopyFrom(old_data.video)
       return new_data
     elif data_type == resources_pb2.ModelTypeField.DataType.BOOL:
-      if old_data.HasField('bool_value'):
+      if old_data.bool_value is not False:
         new_data.bool_value = old_data.bool_value
       return new_data
     elif data_type == resources_pb2.ModelTypeField.DataType.INT:
-      if old_data.HasField('int_value'):
+      if old_data.int_value != 0:
         new_data.int_value = old_data.int_value
       return new_data
     elif data_type == resources_pb2.ModelTypeField.DataType.FLOAT:
-      if old_data.HasField('float_value'):
+      if old_data.float_value != 0.0:
         new_data.float_value = old_data.float_value
       return new_data
     elif data_type == resources_pb2.ModelTypeField.DataType.BYTES:
-      if old_data.HasField('bytes_value'):
+      if old_data.bytes_value != b"":
         new_data.bytes_value = old_data.bytes_value
       return new_data
     elif data_type == resources_pb2.ModelTypeField.DataType.NDARRAY:
@@ -299,7 +299,7 @@ class DataConverter:
         return True
 
     return False
-  
+
   @classmethod
   def convert_output_data_to_old_format(cls, data: resources_pb2.Data) -> resources_pb2.Data:
     """Convert output data to old format."""
@@ -311,7 +311,7 @@ class DataConverter:
       old_data.text.raw = old_data.string_value
 
     return old_data
-  
+
   @classmethod
   def _is_data_set(cls, data_msg):
     # Singular message fields
@@ -334,4 +334,4 @@ class DataConverter:
         data_msg.bool_value is True or data_msg.string_value != ""):
       return True
 
-    return False
+    return False

clarifai/runners/utils/loader.py

@@ -6,6 +6,7 @@ import shutil
 
 import requests
 
+from clarifai.runners.utils.const import CONCEPTS_REQUIRED_MODEL_TYPE
 from clarifai.utils.logging import logger
 
 
@@ -13,9 +14,10 @@ class HuggingFaceLoader:
 
   HF_DOWNLOAD_TEXT = "The 'huggingface_hub' package is not installed. Please install it using 'pip install huggingface_hub'."
 
-  def __init__(self, repo_id=None, token=None):
+  def __init__(self, repo_id=None, token=None, model_type_id=None):
     self.repo_id = repo_id
     self.token = token
+    self.clarifai_model_type_id = model_type_id
     if token:
       if self.validate_hftoken(token):
         try:
@@ -43,13 +45,17 @@ class HuggingFaceLoader:
           f"Error setting up Hugging Face token, please make sure you have the correct token: {e}")
       return False
 
-  def download_checkpoints(self, checkpoint_path: str):
+  def download_checkpoints(self,
+                           checkpoint_path: str,
+                           allowed_file_patterns=None,
+                           ignore_file_patterns=None):
     # throw error if huggingface_hub wasn't installed
     try:
       from huggingface_hub import snapshot_download
     except ImportError:
       raise ImportError(self.HF_DOWNLOAD_TEXT)
-    if os.path.exists(checkpoint_path) and self.validate_download(checkpoint_path):
+    if os.path.exists(checkpoint_path) and self.validate_download(
+        checkpoint_path, allowed_file_patterns, ignore_file_patterns):
       logger.info("Checkpoints already exist")
       return True
     else:
@@ -61,10 +67,16 @@ class HuggingFaceLoader:
           return False
 
         self.ignore_patterns = self._get_ignore_patterns()
+        if ignore_file_patterns:
+          if self.ignore_patterns:
+            self.ignore_patterns.extend(ignore_file_patterns)
+          else:
+            self.ignore_patterns = ignore_file_patterns
         snapshot_download(
             repo_id=self.repo_id,
             local_dir=checkpoint_path,
             local_dir_use_symlinks=False,
+            allow_patterns=allowed_file_patterns,
             ignore_patterns=self.ignore_patterns)
         # Remove the `.cache` folder if it exists
         cache_path = os.path.join(checkpoint_path, ".cache")
@@ -75,7 +87,8 @@ class HuggingFaceLoader:
         logger.error(f"Error downloading model checkpoints {e}")
         return False
       finally:
-        is_downloaded = self.validate_download(checkpoint_path)
+        is_downloaded = self.validate_download(checkpoint_path, allowed_file_patterns,
+                                               ignore_file_patterns)
         if not is_downloaded:
           logger.error("Error validating downloaded model checkpoints")
           return False
@@ -109,9 +122,13 @@ class HuggingFaceLoader:
       from huggingface_hub import file_exists, repo_exists
     except ImportError:
       raise ImportError(self.HF_DOWNLOAD_TEXT)
-    return repo_exists(self.repo_id) and file_exists(self.repo_id, 'config.json')
+    if self.clarifai_model_type_id in CONCEPTS_REQUIRED_MODEL_TYPE:
+      return repo_exists(self.repo_id) and file_exists(self.repo_id, 'config.json')
+    else:
+      return repo_exists(self.repo_id)
 
-  def validate_download(self, checkpoint_path: str):
+  def validate_download(self, checkpoint_path: str, allowed_file_patterns: list,
+                        ignore_file_patterns: list):
     # check if model exists on HF
     try:
       from huggingface_hub import list_repo_files
@@ -120,7 +137,20 @@ class HuggingFaceLoader:
     # Get the list of files on the repo
     repo_files = list_repo_files(self.repo_id, token=self.token)
 
+    # Get the list of files on the repo that are allowed
+    if allowed_file_patterns:
+
+      def should_allow(file_path):
+        return any(fnmatch.fnmatch(file_path, pattern) for pattern in allowed_file_patterns)
+
+      repo_files = [f for f in repo_files if should_allow(f)]
+
     self.ignore_patterns = self._get_ignore_patterns()
+    if ignore_file_patterns:
+      if self.ignore_patterns:
+        self.ignore_patterns.extend(ignore_file_patterns)
+      else:
+        self.ignore_patterns = ignore_file_patterns
     # Get the list of files on the repo that are not ignored
     if getattr(self, "ignore_patterns", None):
       patterns = self.ignore_patterns

clarifai/runners/utils/method_signatures.py

@@ -1,3 +1,4 @@
+import collections.abc as abc
 import inspect
 import json
 from collections import namedtuple
@@ -354,7 +355,7 @@ def _normalize_type(tp):
   '''
   # stream type indicates streaming, not part of the data itself
   # it can only be used at the top-level of the var type
-  streaming = (get_origin(tp) == data_types.Stream)
+  streaming = (get_origin(tp) in [abc.Iterator, abc.Generator, abc.Iterable])
   if streaming:
     tp = get_args(tp)[0]
 

clarifai/runners/utils/openai_format.py

@@ -0,0 +1,87 @@
+import time
+import uuid
+
+def generate_id():
+    return f"chatcmpl-{uuid.uuid4().hex}"
+
+def format_non_streaming_response(
+    generated_text,
+    model="custom-model",
+    id=None,
+    created=None,
+    usage=None,
+    finish_reason="stop",
+):
+    if id is None:
+        id = generate_id()
+    if created is None:
+        created = int(time.time())
+    
+    response = {
+        "id": id,
+        "object": "chat.completion",
+        "created": created,
+        "model": model,
+        "choices": [
+            {
+                "index": 0,
+                "message": {
+                    "role": "assistant",
+                    "content": generated_text,
+                },
+                "finish_reason": finish_reason,
+                "logprobs": None,
+            }
+        ],
+    }
+    
+    if usage is not None:
+        response["usage"] = usage
+    
+    return response
+
+def format_streaming_response(
+    generated_chunks,
+    model="custom-model",
+    id=None,
+    created=None,
+    finish_reason="stop",
+):
+    if id is None:
+        id = generate_id()
+    if created is None:
+        created = int(time.time())
+    
+    for chunk in generated_chunks:
+        yield {
+            "id": id,
+            "object": "chat.completion.chunk",
+            "created": created,
+            "model": model,
+            "choices": [
+                {
+                    "index": 0,
+                    "delta": {
+                        "content": chunk,
+                    },
+                    "finish_reason": None,
+                    "logprobs": None,
+                }
+            ],
+        }
+    
+    # Final chunk indicating completion
+    yield {
+        "id": id,
+        "object": "chat.completion.chunk",
+        "created": created,
+        "model": model,
+        "choices": [
+            {
+                "index": 0,
+                "delta": {},
+                "finish_reason": finish_reason,
+                "logprobs": None,
+            }
+        ],
+    }

clarifai/utils/cli.py

@@ -1,14 +1,14 @@
 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
 
 
 def from_yaml(filename: str):
@@ -28,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')
@@ -50,21 +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'