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

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'

clarifai/utils/logging.py

@@ -10,15 +10,6 @@ import traceback
 from collections import defaultdict
 from typing import Any, Dict, List, Optional, Union
 
-from rich import print as rprint
-from rich.console import Console
-from rich.logging import RichHandler
-from rich.table import Table
-from rich.traceback import install
-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.
@@ -29,6 +20,20 @@ FIELD_BLACKLIST = [
     'msg', 'message', 'account', 'levelno', 'created', 'threadName', 'name', 'processName',
     'module', 'funcName', 'msecs', 'relativeCreated', 'pathname', 'args', 'thread', 'process'
 ]
+COLORS = {
+    'ARGUMENTS': '\033[90m',  # Gray
+    'DEBUG': '\033[90m',  # Gray
+    'INFO': '\033[32m',  # Green
+    'WARNING': '\033[33m',  # Yellow
+    'ERROR': '\033[31m',  # Red
+    'CRITICAL': '\033[31m',  # Red
+    'TIME': '\033[34m',
+    'RESET': '\033[0m'
+}
+LOG_FORMAT = f"[%(levelname)s] {COLORS.get('TIME')}%(asctime)s{COLORS.get('RESET')} %(message)s |" \
+             f"{COLORS.get('ARGUMENTS')} " \
+             f"%(optional_args)s " \
+             f"thread=%(thread)d {COLORS.get('RESET')}"
 
 # Create thread local storage that the format() call below uses.
 # This is only used by the json_logger in the appropriate CLARIFAI_DEPLOY levels.
@@ -59,6 +64,9 @@ def get_req_id_from_context():
 
 def display_workflow_tree(nodes_data: List[Dict]) -> None:
   """Displays a tree of the workflow nodes."""
+  from rich import print as rprint
+  from rich.tree import Tree
+
   # Create a mapping of node_id to the list of node_ids that are connected to it.
   node_adj_mapping = defaultdict(list)
   # Create a mapping of node_id to the node data info.
@@ -104,8 +112,10 @@ def display_workflow_tree(nodes_data: List[Dict]) -> None:
   rprint(tree)
 
 
-def table_from_dict(data: List[Dict], column_names: List[str], title: str = "") -> Table:
+def table_from_dict(data: List[Dict], column_names: List[str],
+                    title: str = "") -> 'rich.Table':  #noqa F821
   """Use this function for printing tables from a list of dicts."""
+  from rich.table import Table
   table = Table(title=title, show_lines=False, show_header=True, header_style="blue")
   for column_name in column_names:
     table.add_column(column_name)
@@ -134,23 +144,18 @@ def _configure_logger(name: str, logger_level: Union[int, str] = logging.NOTSET)
   # If ENABLE_JSON_LOGGER is not set, then use json logger if in k8s.
   enabled_json = os.getenv('ENABLE_JSON_LOGGER', None)
   in_k8s = 'KUBERNETES_SERVICE_HOST' in os.environ
+  handler = logging.StreamHandler()
+  handler.setLevel(logger_level)
   if enabled_json == 'true' or (in_k8s and enabled_json != 'false'):
     # Add the json handler and formatter
-    handler = logging.StreamHandler()
     formatter = JsonFormatter()
     handler.setFormatter(formatter)
-    logger.addHandler(handler)
   else:
-    # Add the new rich handler and formatter
-    try:
-      width, _ = os.get_terminal_size()
-    except OSError:
-      width = 255
-    handler = RichHandler(
-        rich_tracebacks=True, log_time_format="%Y-%m-%d %H:%M:%S.%f", console=Console(width=width))
-    formatter = logging.Formatter('%(message)s')
+    # create formatter and add it to the handlers
+    formatter = TerminalFormatter(LOG_FORMAT)
     handler.setFormatter(formatter)
-    logger.addHandler(handler)
+  # add the handlers to the logger
+  logger.addHandler(handler)
 
 
 def get_logger(logger_level: Union[int, str] = logging.NOTSET,
@@ -207,6 +212,8 @@ def display_concept_relations_tree(relations_dict: Dict[str, Any]) -> None:
     Args:
         relations_dict (dict): A dict of concept relations info.
     """
+  from rich import print as rprint
+  from rich.tree import Tree
   for parent, children in relations_dict.items():
     tree = Tree(parent)
     for child in children:
@@ -372,5 +379,41 @@ class JsonFormatter(logging.Formatter):
       )
 
 
+class TerminalFormatter(logging.Formatter):
+  """ If you have fields in your Formatter (see setup_logger where we setup the format strings) then
+  you can set them on the record using a filter. We do that for req_id here which is a request
+  specific field. This allows us to find requests easily between services.
+  """
+
+  def format(self, record):
+    record.optional_args = []
+
+    user_id = getattr(thread_log_info, 'user_id', None)
+    if user_id is not None:
+      record.optional_args.append("user_id=" + user_id)
+
+    app_id = getattr(thread_log_info, 'app_id', None)
+    if app_id is not None:
+      record.optional_args.append("app_id=" + app_id)
+
+    req_id = getattr(thread_log_info, 'req_id', None)
+    if req_id is not None:
+      record.optional_args.append("req_id=" + req_id)
+
+    record.optional_args = " ".join(record.optional_args)
+
+    color_code = COLORS.get(record.levelname, '')
+
+    record.levelname = f"{color_code}{record.levelname}{COLORS.get('RESET')}"
+    record.msg = f"{color_code}{str(record.msg)}{COLORS.get('RESET')}"
+
+    return super(TerminalFormatter, self).format(record)
+
+  def formatTime(self, record, datefmt=None):
+    # Note we didn't go with UTC here as it's easier to understand time in your time zone.
+    # The json logger leverages UTC though.
+    return datetime.datetime.fromtimestamp(record.created).strftime('%H:%M:%S.%f')
+
+
 # the default logger for the SDK.
 logger = get_logger(logger_level=os.environ.get("LOG_LEVEL", "INFO"), name="clarifai")

clarifai/utils/misc.py

@@ -12,6 +12,8 @@ RETRYABLE_CODES = [
     status_code_pb2.MODEL_BUSY_PLEASE_RETRY
 ]
 
+DEFAULT_CONFIG = f'{os.environ["HOME"]}/.config/clarifai/config'
+
 
 def status_is_retryable(status_code: int) -> bool:
   """Check if a status code is retryable."""

{clarifai-11.2.3rc7.dist-info → clarifai-11.2.3rc8.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: clarifai
-Version: 11.2.3rc7
+Version: 11.2.3rc8
 Summary: Clarifai Python SDK
 Home-page: https://github.com/Clarifai/clarifai-python
 Author: Clarifai